ROCsoft: beamtime/tof-tdctest/go4/SCALERS/TScalersProc.cxx (r4864/r4329) Source File

Go to the documentation of this file.
00001 #include "TScalersProc.h"
00002 
00003 TScalersProc::TScalersProc(const char* name) : TCBMBeamtimeProc(name),
00004 fCrateInputEvent(0),
00005 fTriglogInputEvent(0),
00006 fOutputEvent(0)
00007 {
00008    TGo4Log::Info("**** TScalersProc: Create instance %s" , name );
00009 
00010    fPar = (TScalersParam*) MakeParameter("ScalersPar", "TScalersParam");
00011 
00012    //~ cout<<name<<endl;
00013 
00014    fTriggerPattern =
00015           MakeTH1('I', Form("Triglog/TriggerPattern"),
00016           Form("Trigger Pattern Histogram") ,
00017           16, -0.5, 15.5, "Trigger", "Counts[]");
00018    
00019    iScalerBinNb  = 36000;
00020    dScalerBinMax = 3600.;
00021    cout<<"Bin size: "<<dScalerBinMax/(Double_t)iScalerBinNb<<" s"<<endl;
00022 
00023    /* Reference */
00024    uInitialMbsTime   = 0;
00025    uInitialMilliTime = 0;
00026    uLastMbsTime      = 0;
00027    uLastMbsMilliTime = 0;
00028 #if SCALORMU_NB_SCAL == 16
00029    // Oct 12
00030    uInitialScalerRef = 0;
00031    dInitialCycleSize = 0.0;
00032    uScalerRefCycle   = 0;
00033    uLastScalerRefAll = 0;
00034 #else
00035       // Starting Nov 12
00036    uInitialScalerRefTriglog = 0;
00037    dInitialCycleSizeTriglog = 0;
00038    uScalerRefCycleTriglog = 0;
00039    uLastScalerRefAllTriglog = 0;
00040    uInitialScalerRefScalOrMu = 0;
00041    dInitialCycleSizeScalOrMu = 0;
00042    uScalerRefCycleScalOrMu = 0;
00043    uLastScalerRefAllScalOrMu = 0;
00044 #endif
00045 
00046    /* Triglog */
00047    for( UInt_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00048       for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00049       {
00050          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] = 0;
00051          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd] = 0;
00052 
00053          fScalerRate[uTriglogScalerInd][uTriglogChanInd] =
00054                (TProfile*)GetHistogram(
00055                      Form("Triglog/RateScaler%d/trlo_Scal%dTrigg%d", uTriglogScalerInd, uTriglogScalerInd, uTriglogChanInd) );
00056          if( 0 == fScalerRate[uTriglogScalerInd][uTriglogChanInd] )
00057          {
00058             fScalerRate[uTriglogScalerInd][uTriglogChanInd] = new TProfile(
00059                   Form("trlo_Scal%dTrigg%d", uTriglogScalerInd, uTriglogChanInd),
00060                   Form("Evolution of rate on scaler %d for trigg %d in Triglog; Time [s]; Rate [Hz]",
00061                         uTriglogScalerInd, uTriglogChanInd),
00062                   iScalerBinNb, 0, dScalerBinMax);
00063             AddHistogram(  fScalerRate[uTriglogScalerInd][uTriglogChanInd],
00064                   Form("Triglog/RateScaler%d/", uTriglogScalerInd) );
00065          } // if( 0 == fScalerRate[uTriglogScalerInd][uTriglogChanInd] )
00066       } // For TriglogScalers and TriglogChan
00067 
00068    /* ScalOrMu */
00069    for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00070    {
00071       uLastScalerScalOrMu[uScalOrMuChanInd] = 0;
00072       uLastScalerRefScalOrMu[uScalOrMuChanInd] = 0;
00073 
00074       fScalOrMuRate[uScalOrMuChanInd] = (TProfile*)GetHistogram( Form("ScalOrMu/SOM_Scal%d",uScalOrMuChanInd) );
00075       if( 0 == fScalOrMuRate[uScalOrMuChanInd] )
00076       {
00077          fScalOrMuRate[uScalOrMuChanInd] = new TProfile( Form("SOM_Scal%d",uScalOrMuChanInd),
00078                    Form("Evolution of rate on scaler %d in ScalOrMu; Time [s]; Rate [Hz]", uScalOrMuChanInd),
00079                    iScalerBinNb, 0, dScalerBinMax);
00080          AddHistogram(  fScalOrMuRate[uScalOrMuChanInd],
00081                         "ScalOrMu/" );
00082       } // if( 0 == fScalOrMuRate[uScalOrMuChanInd] )
00083    } // for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00084 
00085    /* Detectors */
00086    for( UInt_t uDetectorInd = 0; uDetectorInd < fPar->uNbDetectorsScalormu; uDetectorInd++)
00087    {
00088       fDetectorsRate[uDetectorInd] = (TProfile*)GetHistogram( Form("ScalOrMu/SOM_Det%d",uDetectorInd) );
00089       if( 0 == fDetectorsRate[uDetectorInd] )
00090       {
00091          fDetectorsRate[uDetectorInd] = new TProfile( Form("SOM_Det%d",uDetectorInd),
00092                    Form("Evolution of rate on detector %d in ScalOrMu; Time [s]; Rate [Hz]", uDetectorInd),
00093                    iScalerBinNb, 0, dScalerBinMax);
00094          AddHistogram(  fDetectorsRate[uDetectorInd],
00095                         "ScalOrMu/" );
00096       } // if( 0 == fDetectorsRate[uDetectorInd] )
00097    } // for( UInt_t uDetectorInd = 0; uDetectorInd < fPar->uNbDetectorsScalormu; uDetectorInd++)
00098 
00099 #if SCALORMU_NB_SCAL != 16
00100    fReferenceClockComparison = MakeTH1('I', "ScalOrMu/RefClkComp",
00101          "Comparison of the reference clocks in Triglog and Scalormu", 100000, -50000, 50000.);
00102    fTriglogRefClockEvolution = MakeTH1('I', "Triglog/TrloRefClkEvo",
00103          "Evolution of the reference clock in Triglog", 3600, 0, 3600.);
00104    fScalOrMuRefClockEvolution = MakeTH1('I', "ScalOrMu/SomRefClkEvo",
00105          "Evolution of the reference clock in ScalOrMu", 3600, 0, 3600.);
00106    //~ TGo4Log::Info("**** TScalersProc: Instance %s created", name );
00107 #endif
00108 }
00109 
00110 
00111 TScalersProc::~TScalersProc()
00112 {
00113    cout << "**** TScalersProc: Delete instance " << endl;
00114 
00115 }
00116 
00117 void TScalersProc::InitEvent(TGo4EventElement* outevnt)
00118 {
00119    // first assign input event:
00120    // since input event object is never discarded within processor lifetime,
00121    // we just search for subevent by name once to speed up processing
00122 
00123    if(fCrateInputEvent==0)
00124         {
00125       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Calibration"));
00126       if(btevent)
00127       {
00128          fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
00129       }
00130       else
00131       {
00132          fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(GetInputEvent());
00133       }
00134       if(fCrateInputEvent==0) {
00135          GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: no input event TMbsCrateEvent!!! STOP GO4");
00136       }
00137    } // if(fCrateInputEvent==0)
00138    if(fTriglogInputEvent==0)
00139    {
00140       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Calibration"));
00141       if(btevent)
00142       {
00143          fTriglogInputEvent=dynamic_cast<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
00144       }
00145 
00146       if(fTriglogInputEvent==0) {
00147          GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: input event is/has not a TTriglogEvent!!! STOP GO4");
00148       }
00149    } // if(fTriglogInputEvent==0)
00150    // then assign output event
00151    // since output event object is never discarded within processor lifetime,
00152    // we just search for subevent by name once to speed up processing
00153    if(fOutputEvent==0)
00154    {
00155       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
00156       if(btevent)
00157       {
00158          fOutputEvent=dynamic_cast<TScalersEvent*>(btevent->GetSubEvent("SCALERS"));
00159       }
00160       else
00161       {
00162 
00163          fOutputEvent= dynamic_cast<TScalersEvent*>(outevnt);
00164       }
00165       if(fOutputEvent==0) {
00166         GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: output event is not a TScalersEvent!!! STOP GO4");
00167       }
00168       else {
00169          //     BuildEvent(dynamic_cast<TGo4MbsSubEvent*>(btevent->GetSubEvent("MBSCRATE")));
00170       }
00171    }
00172 }
00173 
00174 void TScalersProc::FinalizeEvent()
00175 {
00176    Double_t dDt = 0.0;
00177    Double_t dDtInit = 0.0;
00178 
00179    if (fTriglogInputEvent && fTriglogInputEvent->IsValid())
00180    {
00181       for( UInt_t uBit=0; uBit < 16; uBit++)
00182       {
00183          if(((UInt_t)fTriglogInputEvent->fVulomTriggerPattern>>uBit)&0x00000001)
00184          {
00185             fTriggerPattern->Fill(uBit);
00186          } // if(((UInt_t)fTriglogInputEvent->fVulomTriggerPattern>>uBit)&0x00000001)
00187       } // for( UInt_t uBit=0; uBit < 16; uBit++)
00188    } // if (fTriglogInputEvent && fTriglogInputEvent->IsValid())
00189 
00190 #if SCALORMU_NB_SCAL == 16
00191    // Oct 12
00192 
00193    if( 0 == uInitialScalerRef )
00194    {
00195       /* Reference */
00196       uInitialScalerRef = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00197       dInitialCycleSize = ((Double_t)0xFFFFFFFF - (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel])
00198                            /fPar->dReferenceClockFrequency;
00199 
00200       /* Triglog */
00201       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00202          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00203       {
00204          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00205          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00206       }
00207 
00208       /* ScalOrMu */
00209       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00210       {
00211          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00212          uLastScalerRefScalOrMu[uScalOrMuChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00213       }
00214       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00215    }
00216    else if( fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel] < uInitialScalerRef)
00217    {
00218       /* Reference */
00219       uInitialScalerRef = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00220       uScalerRefCycle++;
00221 
00222       /* Triglog */
00223       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00224          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00225       {
00226          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00227          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00228       }
00229 
00230       /* ScalOrMu */
00231       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00232       {
00233          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00234          uLastScalerRefScalOrMu[uScalOrMuChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00235       }
00236       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00237    } // else if( fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel] < uInitialScalerRef)
00238    else
00239    {
00240       dDtInit = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00241                  - (Double_t)uInitialScalerRef) / fPar->dReferenceClockFrequency
00242                  + ( 0 < uScalerRefCycle ? dInitialCycleSize : 0.0)
00243                  + ( 1 < uScalerRefCycle ? (Double_t)(uScalerRefCycle-1)*((Double_t)0xFFFFFFFF/fPar->dReferenceClockFrequency): 0.0) ;
00244       (fOutputEvent->fEvent).fDTimeSinceFirstEventSecondsTriglog= dDtInit;
00245 
00246       dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00247                  - (Double_t)uLastScalerRefAll) / fPar->dReferenceClockFrequency;
00248       (fOutputEvent->fEvent).fDTimeSinceLastEventSecondsTriglog= dDt;
00249       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00250 
00251       /* Triglog */
00252       for( UInt_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00253          for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00254          {
00255             // Check if we are on the reference clock channel
00256             if( uTriglogScalerInd == fPar->uReferenceClockScaler&&
00257                   uTriglogChanInd == fPar->uReferenceClockChannel )
00258             {
00259 
00260                if( 0 == uInitialMilliTime && 0 == uInitialMbsTime )
00261                {
00262                   uInitialMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00263                   uInitialMbsTime    = fTriglogInputEvent->fMbsTimeSecs;
00264                   uLastMbsMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00265                   uLastMbsTime       = fTriglogInputEvent->fMbsTimeSecs;
00266                } // if initial time
00267                else
00268                {
00269                   dDt = (  ((Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0)
00270                         - ((Double_t)uLastMbsTime + (Double_t)uLastMbsMilliTime/1000.0 ) + 0.0 );
00271                   if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00272                       0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00273                       uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00274                       0. < dDt  )
00275                   {
00276                      (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00277                            (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00278                             - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00279 
00280                      fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill(
00281                         (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00282                       - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00283                       (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00284                   } // if correct dt and scaler increase
00285                      else
00286                      {
00287                         (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00288 //                        fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill(
00289 //                                  (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00290 //                              - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0), 0.0);
00291                      } // else of if correct dt and scaler increase
00292 
00293 
00294                   uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00295                   uLastMbsMilliTime = fTriglogInputEvent->fMbsTimeMillisec;
00296                   uLastMbsTime      = fTriglogInputEvent->fMbsTimeSecs;
00297                } // else of if initial time
00298 
00299                continue;
00300             } // if this channel is our refrence clock scaler
00301 /*
00302             dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00303                        - (Double_t)uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]) / fPar->dReferenceClockFrequency;
00304 */
00305             if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00306                 0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00307                 uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00308                // dDtMbs < 0.01 &&
00309                 0. < dDt  )
00310             {
00311                (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00312                      (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00313                       - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00314                fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit,
00315                      (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00316             } // if correct dt and scaler increase
00317                else
00318                {
00319                   (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00320 //                  fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit, 0.0);
00321                } // else of if correct dt and scaler increase
00322 
00323 
00324             uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]    = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00325             uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd] = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00326          } // for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00327 
00328       /* ScalOrMu */
00329       for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00330       {
00331          /*
00332          dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00333                     - (Double_t)uLastScalerRefScalOrMu[uScalOrMuChanInd]) / fPar->dReferenceClockFrequency;
00334                     */
00335          if( 0 != uLastScalerScalOrMu[uScalOrMuChanInd] &&
00336              0 != fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00337              uLastScalerScalOrMu[uScalOrMuChanInd] < fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00338              0.0 < dDt  )
00339          {
00340             (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] =
00341                   (  (Double_t)fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd]
00342                    - (Double_t)uLastScalerScalOrMu[uScalOrMuChanInd] ) / dDt ;
00343             fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd], dDt );
00344          } // if correct dt and scaler increase
00345             else
00346             {
00347                (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] = -1.0;
00348 //               fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, 0.0);
00349             } // else of if correct dt and scaler increase
00350 
00351 
00352          uLastScalerScalOrMu[uScalOrMuChanInd]    = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00353          uLastScalerRefScalOrMu[uScalOrMuChanInd] = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00354       } // for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00355 
00356       for( UInt_t uScalOrMuDetInd = 0; uScalOrMuDetInd <  fPar->uNbDetectorsScalormu; uScalOrMuDetInd++)
00357       {
00358          (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] = 0.0;
00359          for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00360             if( uScalOrMuDetInd == fPar->uDetectorScaler[uScalOrMuChanInd] && -1 < (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] )
00361                (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] += (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd];
00362          if( 0.0 < (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] &&
00363              0.0 < dDt )
00364             fDetectorsRate[uScalOrMuDetInd]->Fill( dDtInit, (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd], dDt );
00365       }
00366    } // else of (else if scaler ref made a loop) of if( 0 == uInitialScalerRef )
00367 #else // #if SCALORMU_NB_SCAL == 16
00368    // Starting Nov 12
00369    if( 0 == uInitialScalerRefTriglog && 0 == uInitialScalerRefScalOrMu )
00370    {
00371       /* Reference */
00372       uInitialScalerRefTriglog = fCrateInputEvent->fTriglogReferenceClock;
00373       dInitialCycleSizeTriglog = ( (Double_t)0xFFFFFFFF - (Double_t)fCrateInputEvent->fTriglogReferenceClock )
00374                                /fPar->dReferenceClockFrequency;
00375       uScalerRefCycleTriglog   = 0;
00376       uInitialScalerRefScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00377       dInitialCycleSizeScalOrMu = ( (Double_t)0xFFFFFFFF - (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock )
00378                                   /fPar->dReferenceClockFrequencyScalOrMu;
00379       uScalerRefCycleScalOrMu   = 0;
00380 
00381       /* Triglog */
00382       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00383          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00384       {
00385          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00386          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= uInitialScalerRefTriglog;
00387       }
00388 
00389       /* ScalOrMu */
00390       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00391       {
00392          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00393          uLastScalerRefScalOrMu[uScalOrMuChanInd]= uInitialScalerRefScalOrMu;
00394       }
00395 
00396       uLastScalerRefAllTriglog  = uInitialScalerRefTriglog;
00397       uLastScalerRefAllScalOrMu = uInitialScalerRefScalOrMu;
00398 
00399       if( 0 == uInitialMilliTime && 0 == uInitialMbsTime )
00400       {
00401          uInitialMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00402          uInitialMbsTime    = fTriglogInputEvent->fMbsTimeSecs;
00403          uLastMbsMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00404          uLastMbsTime       = fTriglogInputEvent->fMbsTimeSecs;
00405       } // if initial time
00406    }
00407    else
00408    {
00409       if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00410       {
00411          /* Reference */
00412          uInitialScalerRefTriglog = fCrateInputEvent->fTriglogReferenceClock;
00413          uScalerRefCycleTriglog++;
00414 
00415          /* Triglog */
00416          for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00417             for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00418          {
00419             uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00420             uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= uInitialScalerRefTriglog;
00421          }
00422          uLastScalerRefAllTriglog    = uInitialScalerRefTriglog;
00423       } // if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00424          else
00425          {
00426             dDtInit = (  (Double_t)fCrateInputEvent->fTriglogReferenceClock
00427                        - (Double_t)uInitialScalerRefTriglog) / fPar->dReferenceClockFrequencyTriglog
00428                        + ( 0 < uScalerRefCycleTriglog ? dInitialCycleSizeTriglog : 0.0)
00429                        + ( 1 < uScalerRefCycleTriglog ?
00430                              (Double_t)(uScalerRefCycleTriglog-1)*((Double_t)0xFFFFFFFF
00431                                    /fPar->dReferenceClockFrequencyTriglog):
00432                              0.0) ;
00433             (fOutputEvent->fEvent).fDTimeSinceFirstEventSecondsTriglog = dDtInit;
00434 
00435             dDt     = (  (Double_t)fCrateInputEvent->fTriglogReferenceClock
00436                        - (Double_t)uLastScalerRefAllTriglog) / fPar->dReferenceClockFrequencyTriglog;
00437             (fOutputEvent->fEvent).fDTimeSinceLastEventSecondsTriglog = dDt;
00438 
00439             /* Triglog */
00440             for( UInt_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00441                for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00442                {
00443                   if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00444                       0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00445                       uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00446                      // dDtMbs < 0.01 &&
00447                       0. < dDt  )
00448                   {
00449                      (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00450                            (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00451                             - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00452                      fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit,
00453                            (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00454                   } // if correct dt and scaler increase
00455                      else
00456                      {
00457                         (fOutputEvent->fEvent).fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00458                      } // else of if correct dt and scaler increase
00459 
00460 
00461                   uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]    = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00462                   uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd] = fCrateInputEvent->fTriglogReferenceClock;
00463                } // for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00464 
00465             fTriglogRefClockEvolution->Fill(
00466                   (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00467                                         - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00468                   fCrateInputEvent->fTriglogReferenceClock - uLastScalerRefAllTriglog
00469                   );
00470             uLastScalerRefAllTriglog = fCrateInputEvent->fTriglogReferenceClock;
00471          } // else of if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00472       if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00473       {
00474          /* Reference */
00475          uInitialScalerRefScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00476          uScalerRefCycleScalOrMu++;
00477 
00478          /* ScalOrMu */
00479          for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00480          {
00481             uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00482             uLastScalerRefScalOrMu[uScalOrMuChanInd]= uInitialScalerRefScalOrMu;
00483          }
00484          uLastScalerRefAllScalOrMu = uInitialScalerRefScalOrMu;
00485       } // if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00486          else
00487          {
00488             dDtInit = (  (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock
00489                        - (Double_t)uInitialScalerRefScalOrMu) / fPar->dReferenceClockFrequencyScalOrMu
00490                        + ( 0 < uScalerRefCycleScalOrMu ? dInitialCycleSizeScalOrMu : 0.0)
00491                        + ( 1 < uScalerRefCycleScalOrMu ?
00492                              (Double_t)(uScalerRefCycleScalOrMu-1)*((Double_t)0xFFFFFFFF
00493                                    /fPar->dReferenceClockFrequencyScalOrMu):
00494                              0.0) ;
00495             (fOutputEvent->fEvent).fDTimeSinceFirstEventSecondsScalOrMu = dDtInit;
00496 
00497             dDt     = (  (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock
00498                        - (Double_t)uLastScalerRefAllScalOrMu) / fPar->dReferenceClockFrequencyScalOrMu;
00499             (fOutputEvent->fEvent).fDTimeSinceLastEventSecondsScalOrMu = dDt;
00500 
00501             /* ScalOrMu */
00502             for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00503             {
00504                if( 0 != uLastScalerScalOrMu[uScalOrMuChanInd] &&
00505                    0 != fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00506                    uLastScalerScalOrMu[uScalOrMuChanInd] < fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00507                    0.0 < dDt  )
00508                {
00509                   (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] =
00510                         (  (Double_t)fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd]
00511                          - (Double_t)uLastScalerScalOrMu[uScalOrMuChanInd] ) / dDt ;
00512                   fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd], dDt );
00513                } // if correct dt and scaler increase
00514                   else
00515                   {
00516                      (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] = -1.0;
00517                   } // else of if correct dt and scaler increase
00518 
00519 
00520                uLastScalerScalOrMu[uScalOrMuChanInd]    = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00521                uLastScalerRefScalOrMu[uScalOrMuChanInd] = fCrateInputEvent->fScalOrMu.uReferenceClock;
00522             } // for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00523 
00524             for( UInt_t uScalOrMuDetInd = 0; uScalOrMuDetInd <  fPar->uNbDetectorsScalormu; uScalOrMuDetInd++)
00525             {
00526                (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] = 0.0;
00527                for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00528                   if( uScalOrMuDetInd == fPar->uDetectorScaler[uScalOrMuChanInd] && -1 < (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd] )
00529                      (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] += (fOutputEvent->fEvent).fDScalOrMuRate[uScalOrMuChanInd];
00530                if( 0.0 < (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd] &&
00531                    0.0 < dDt )
00532                   fDetectorsRate[uScalOrMuDetInd]->Fill( dDtInit, (fOutputEvent->fEvent).fDDetectorRate[uScalOrMuDetInd], dDt );
00533             }
00534             fScalOrMuRefClockEvolution->Fill(
00535                   (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00536                                         - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00537                   fCrateInputEvent->fScalOrMu.uReferenceClock - uLastScalerRefAllScalOrMu
00538                   );
00539             uLastScalerRefAllScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00540          } // else of if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00541    } // else of if( 0 == uInitialScalerRef )
00542 
00543    if( 0 < fCrateInputEvent->fTriglogReferenceClock && 0 < fCrateInputEvent->fScalOrMu.uReferenceClock)
00544    {
00545       fReferenceClockComparison->Fill( (Int_t)fCrateInputEvent->fTriglogReferenceClock -
00546             (Int_t)fCrateInputEvent->fScalOrMu.uReferenceClock);
00547    }
00548 #endif // #else #if SCALORMU_NB_SCAL == 16
00549 
00550    fOutputEvent->SetValid(kTRUE);
00551 }