ROCsoft: beamtime/gsi-aug12/get4v10/go4/SCALERS/TScalersProc.cxx (r4864/r3846) 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 #if SCALORMU_NB_SCAL != 16
00086    fReferenceClockComparison = MakeTH1('I', "ScalOrMu/RefClkComp",
00087          "Comparison of the reference clocks in Triglog and Scalormu", 100000, -50000, 50000.);
00088    fTriglogRefClockEvolution = MakeTH1('I', "Triglog/TrloRefClkEvo",
00089          "Evolution of the reference clock in Triglog", 3600, 0, 3600.);
00090    fScalOrMuRefClockEvolution = MakeTH1('I', "ScalOrMu/SomRefClkEvo",
00091          "Evolution of the reference clock in ScalOrMu", 3600, 0, 3600.);
00092    //~ TGo4Log::Info("**** TScalersProc: Instance %s created", name );
00093 #endif
00094 }
00095 
00096 
00097 TScalersProc::~TScalersProc()
00098 {
00099    cout << "**** TScalersProc: Delete instance " << endl;
00100 
00101 }
00102 
00103 void TScalersProc::InitEvent(TGo4EventElement* outevnt)
00104 {
00105    // first assign input event:
00106    // since input event object is never discarded within processor lifetime,
00107    // we just search for subevent by name once to speed up processing
00108 
00109    if(fCrateInputEvent==0)
00110         {
00111       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Calibration"));
00112       if(btevent)
00113       {
00114          fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
00115       }
00116       else
00117       {
00118          fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(GetInputEvent());
00119       }
00120       if(fCrateInputEvent==0) {
00121          GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: no input event TMbsCrateEvent!!! STOP GO4");
00122       }
00123    } // if(fCrateInputEvent==0)
00124    if(fTriglogInputEvent==0)
00125    {
00126       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Calibration"));
00127       if(btevent)
00128       {
00129          fTriglogInputEvent=dynamic_cast<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
00130       }
00131 
00132       if(fTriglogInputEvent==0) {
00133          GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: input event is/has not a TTriglogEvent!!! STOP GO4");
00134       }
00135    } // if(fTriglogInputEvent==0)
00136    // then assign output event
00137    // since output event object is never discarded within processor lifetime,
00138    // we just search for subevent by name once to speed up processing
00139    if(fOutputEvent==0)
00140    {
00141       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
00142       if(btevent)
00143       {
00144          fOutputEvent=dynamic_cast<TScalersEvent*>(btevent->GetSubEvent("SCALERS"));
00145       }
00146       else
00147       {
00148 
00149          fOutputEvent= dynamic_cast<TScalersEvent*>(outevnt);
00150       }
00151       if(fOutputEvent==0) {
00152         GO4_STOP_ANALYSIS_MESSAGE("**** TScalersProc: Fatal error: output event is not a TScalersEvent!!! STOP GO4");
00153       }
00154       else {
00155          //     BuildEvent(dynamic_cast<TGo4MbsSubEvent*>(btevent->GetSubEvent("MBSCRATE")));
00156       }
00157    }
00158 }
00159 
00160 void TScalersProc::FinalizeEvent()
00161 {
00162    Double_t dDt = 0.0;
00163    Double_t dDtInit = 0.0;
00164 
00165    if (fTriglogInputEvent && fTriglogInputEvent->IsValid())
00166    {
00167       for( UInt_t uBit=0; uBit < 16; uBit++)
00168       {
00169          if(((UInt_t)fTriglogInputEvent->fVulomTriggerPattern>>uBit)&0x00000001)
00170          {
00171             fTriggerPattern->Fill(uBit);
00172          } // if(((UInt_t)fTriglogInputEvent->fVulomTriggerPattern>>uBit)&0x00000001)
00173       } // for( UInt_t uBit=0; uBit < 16; uBit++)
00174    } // if (fTriglogInputEvent && fTriglogInputEvent->IsValid())
00175 
00176 #if SCALORMU_NB_SCAL == 16
00177    // Oct 12
00178 
00179    if( 0 == uInitialScalerRef )
00180    {
00181       /* Reference */
00182       uInitialScalerRef = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00183       dInitialCycleSize = ((Double_t)0xFFFFFFFF - (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel])
00184                            /fPar->dReferenceClockFrequency;
00185 
00186       /* Triglog */
00187       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00188          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00189       {
00190          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00191          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00192       }
00193 
00194       /* ScalOrMu */
00195       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00196       {
00197          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00198          uLastScalerRefScalOrMu[uScalOrMuChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00199       }
00200       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00201    }
00202    else if( fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel] < uInitialScalerRef)
00203    {
00204       /* Reference */
00205       uInitialScalerRef = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00206       uScalerRefCycle++;
00207 
00208       /* Triglog */
00209       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00210          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00211       {
00212          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00213          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00214       }
00215 
00216       /* ScalOrMu */
00217       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00218       {
00219          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00220          uLastScalerRefScalOrMu[uScalOrMuChanInd]= fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00221       }
00222       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00223    } // else if( fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel] < uInitialScalerRef)
00224    else
00225    {
00226       dDtInit = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00227                  - (Double_t)uInitialScalerRef) / fPar->dReferenceClockFrequency
00228                  + ( 0 < uScalerRefCycle ? dInitialCycleSize : 0.0)
00229                  + ( 1 < uScalerRefCycle ? (Double_t)(uScalerRefCycle-1)*((Double_t)0xFFFFFFFF/fPar->dReferenceClockFrequency): 0.0) ;
00230       fOutputEvent->fDTimeSinceFirstEventSecondsTriglog= dDtInit;
00231 
00232       dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00233                  - (Double_t)uLastScalerRefAll) / fPar->dReferenceClockFrequency;
00234       fOutputEvent->fDTimeSinceLastEventSecondsTriglog= dDt;
00235       uLastScalerRefAll = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00236 
00237       /* Triglog */
00238       for( UInt_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00239          for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00240          {
00241             // Check if we are on the reference clock channel
00242             if( uTriglogScalerInd == fPar->uReferenceClockScaler&&
00243                   uTriglogChanInd == fPar->uReferenceClockChannel )
00244             {
00245 
00246                if( 0 == uInitialMilliTime && 0 == uInitialMbsTime )
00247                {
00248                   uInitialMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00249                   uInitialMbsTime    = fTriglogInputEvent->fMbsTimeSecs;
00250                   uLastMbsMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00251                   uLastMbsTime       = fTriglogInputEvent->fMbsTimeSecs;
00252                } // if initial time
00253                else
00254                {
00255                   dDt = (  ((Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0)
00256                         - ((Double_t)uLastMbsTime + (Double_t)uLastMbsMilliTime/1000.0 ) + 0.0 );
00257                   if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00258                       0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00259                       uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00260                       0. < dDt  )
00261                   {
00262                      fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00263                            (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00264                             - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00265 
00266                      fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill(
00267                         (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00268                       - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00269                       fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00270                   } // if correct dt and scaler increase
00271                      else
00272                      {
00273                         fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00274 //                        fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill(
00275 //                                  (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00276 //                              - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0), 0.0);
00277                      } // else of if correct dt and scaler increase
00278 
00279 
00280                   uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00281                   uLastMbsMilliTime = fTriglogInputEvent->fMbsTimeMillisec;
00282                   uLastMbsTime      = fTriglogInputEvent->fMbsTimeSecs;
00283                } // else of if initial time
00284 
00285                continue;
00286             } // if this channel is our refrence clock scaler
00287 /*
00288             dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00289                        - (Double_t)uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]) / fPar->dReferenceClockFrequency;
00290 */
00291             if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00292                 0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00293                 uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00294                // dDtMbs < 0.01 &&
00295                 0. < dDt  )
00296             {
00297                fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00298                      (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00299                       - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00300                fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit,
00301                      fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00302             } // if correct dt and scaler increase
00303                else
00304                {
00305                   fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00306 //                  fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit, 0.0);
00307                } // else of if correct dt and scaler increase
00308 
00309 
00310             uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]    = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00311             uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd] = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00312          } // for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00313 
00314       /* ScalOrMu */
00315       for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00316       {
00317          /*
00318          dDt     = (  (Double_t)fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel]
00319                     - (Double_t)uLastScalerRefScalOrMu[uScalOrMuChanInd]) / fPar->dReferenceClockFrequency;
00320                     */
00321          if( 0 != uLastScalerScalOrMu[uScalOrMuChanInd] &&
00322              0 != fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00323              uLastScalerScalOrMu[uScalOrMuChanInd] < fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00324              0.0 < dDt  )
00325          {
00326             fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] =
00327                   (  (Double_t)fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd]
00328                    - (Double_t)uLastScalerScalOrMu[uScalOrMuChanInd] ) / dDt ;
00329             fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd], dDt );
00330          } // if correct dt and scaler increase
00331             else
00332             {
00333                fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] = -1.0;
00334 //               fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, 0.0);
00335             } // else of if correct dt and scaler increase
00336 
00337 
00338          uLastScalerScalOrMu[uScalOrMuChanInd]    = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00339          uLastScalerRefScalOrMu[uScalOrMuChanInd] = fTriglogInputEvent->fVulomScaler[fPar->uReferenceClockScaler][fPar->uReferenceClockChannel];
00340       } // for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00341 
00342       for( UInt_t uScalOrMuDetInd = 0; uScalOrMuDetInd <  fPar->uNbDetectorsScalormu; uScalOrMuDetInd++)
00343       {
00344          fOutputEvent->fDDetectorRate[uScalOrMuDetInd] = 0.0;
00345          for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00346             if( uScalOrMuDetInd == fPar->uDetectorScaler[uScalOrMuChanInd] && -1 < fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] )
00347                fOutputEvent->fDDetectorRate[uScalOrMuDetInd] += fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd];
00348       }
00349    } // else of (else if scaler ref made a loop) of if( 0 == uInitialScalerRef )
00350 #else // #if SCALORMU_NB_SCAL == 16
00351    // Starting Nov 12
00352    if( 0 == uInitialScalerRefTriglog && 0 == uInitialScalerRefScalOrMu )
00353    {
00354       /* Reference */
00355       uInitialScalerRefTriglog = fCrateInputEvent->fTriglogReferenceClock;
00356       dInitialCycleSizeTriglog = ( (Double_t)0xFFFFFFFF - (Double_t)fCrateInputEvent->fTriglogReferenceClock )
00357                                /fPar->dReferenceClockFrequency;
00358       uScalerRefCycleTriglog   = 0;
00359       uInitialScalerRefScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00360       dInitialCycleSizeScalOrMu = ( (Double_t)0xFFFFFFFF - (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock )
00361                                   /fPar->dReferenceClockFrequencyScalOrMu;
00362       uScalerRefCycleScalOrMu   = 0;
00363 
00364       /* Triglog */
00365       for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00366          for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00367       {
00368          uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00369          uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= uInitialScalerRefTriglog;
00370       }
00371 
00372       /* ScalOrMu */
00373       for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00374       {
00375          uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00376          uLastScalerRefScalOrMu[uScalOrMuChanInd]= uInitialScalerRefScalOrMu;
00377       }
00378 
00379       uLastScalerRefAllTriglog  = uInitialScalerRefTriglog;
00380       uLastScalerRefAllScalOrMu = uInitialScalerRefScalOrMu;
00381 
00382       if( 0 == uInitialMilliTime && 0 == uInitialMbsTime )
00383       {
00384          uInitialMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00385          uInitialMbsTime    = fTriglogInputEvent->fMbsTimeSecs;
00386          uLastMbsMilliTime  = fTriglogInputEvent->fMbsTimeMillisec;
00387          uLastMbsTime       = fTriglogInputEvent->fMbsTimeSecs;
00388       } // if initial time
00389    }
00390    else
00391    {
00392       if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00393       {
00394          /* Reference */
00395          uInitialScalerRefTriglog = fCrateInputEvent->fTriglogReferenceClock;
00396          uScalerRefCycleTriglog++;
00397 
00398          /* Triglog */
00399          for( Int_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00400             for( Int_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00401          {
00402             uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]   = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00403             uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd]= uInitialScalerRefTriglog;
00404          }
00405          uLastScalerRefAllTriglog    = uInitialScalerRefTriglog;
00406       } // if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00407          else
00408          {
00409             dDtInit = (  (Double_t)fCrateInputEvent->fTriglogReferenceClock
00410                        - (Double_t)uInitialScalerRefTriglog) / fPar->dReferenceClockFrequencyTriglog
00411                        + ( 0 < uScalerRefCycleTriglog ? dInitialCycleSizeTriglog : 0.0)
00412                        + ( 1 < uScalerRefCycleTriglog ?
00413                              (Double_t)(uScalerRefCycleTriglog-1)*((Double_t)0xFFFFFFFF
00414                                    /fPar->dReferenceClockFrequencyTriglog):
00415                              0.0) ;
00416             fOutputEvent->fDTimeSinceFirstEventSecondsTriglog = dDtInit;
00417 
00418             dDt     = (  (Double_t)fCrateInputEvent->fTriglogReferenceClock
00419                        - (Double_t)uLastScalerRefAllTriglog) / fPar->dReferenceClockFrequencyTriglog;
00420             fOutputEvent->fDTimeSinceLastEventSecondsTriglog = dDt;
00421 
00422             /* Triglog */
00423             for( UInt_t uTriglogScalerInd = 0; uTriglogScalerInd < NUM_SCALERS; uTriglogScalerInd++)
00424                for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00425                {
00426                   if( 0 != uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] &&
00427                       0 != fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00428                       uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] < fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd] &&
00429                      // dDtMbs < 0.01 &&
00430                       0. < dDt  )
00431                   {
00432                      fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] =
00433                            (  (Double_t)fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd]
00434                             - (Double_t)uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd] ) / dDt ;
00435                      fScalerRate[uTriglogScalerInd][uTriglogChanInd]->Fill( dDtInit,
00436                            fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd], dDt );
00437                   } // if correct dt and scaler increase
00438                      else
00439                      {
00440                         fOutputEvent->fDTriglogRate[uTriglogScalerInd][uTriglogChanInd] = -1.0;
00441                      } // else of if correct dt and scaler increase
00442 
00443 
00444                   uLastScalerTriglog[uTriglogScalerInd][uTriglogChanInd]    = fTriglogInputEvent->fVulomScaler[uTriglogScalerInd][uTriglogChanInd];
00445                   uLastScalerRefTriglog[uTriglogScalerInd][uTriglogChanInd] = fCrateInputEvent->fTriglogReferenceClock;
00446                } // for( UInt_t uTriglogChanInd = 0; uTriglogChanInd < N_SCALERS_CH; uTriglogChanInd++)
00447 
00448             fTriglogRefClockEvolution->Fill(
00449                   (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00450                                         - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00451                   fCrateInputEvent->fTriglogReferenceClock - uLastScalerRefAllTriglog
00452                   );
00453             uLastScalerRefAllTriglog = fCrateInputEvent->fTriglogReferenceClock;
00454          } // else of if( fCrateInputEvent->fTriglogReferenceClock < uInitialScalerRefTriglog)
00455       if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00456       {
00457          /* Reference */
00458          uInitialScalerRefScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00459          uScalerRefCycleScalOrMu++;
00460 
00461          /* ScalOrMu */
00462          for( Int_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00463          {
00464             uLastScalerScalOrMu[uScalOrMuChanInd]   = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00465             uLastScalerRefScalOrMu[uScalOrMuChanInd]= uInitialScalerRefScalOrMu;
00466          }
00467          uLastScalerRefAllScalOrMu = uInitialScalerRefScalOrMu;
00468       } // if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00469          else
00470          {
00471             dDtInit = (  (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock
00472                        - (Double_t)uInitialScalerRefScalOrMu) / fPar->dReferenceClockFrequencyScalOrMu
00473                        + ( 0 < uScalerRefCycleScalOrMu ? dInitialCycleSizeScalOrMu : 0.0)
00474                        + ( 1 < uScalerRefCycleScalOrMu ?
00475                              (Double_t)(uScalerRefCycleScalOrMu-1)*((Double_t)0xFFFFFFFF
00476                                    /fPar->dReferenceClockFrequencyScalOrMu):
00477                              0.0) ;
00478             fOutputEvent->fDTimeSinceFirstEventSecondsScalOrMuRate = dDtInit;
00479 
00480             dDt     = (  (Double_t)fCrateInputEvent->fScalOrMu.uReferenceClock
00481                        - (Double_t)uLastScalerRefAllScalOrMu) / fPar->dReferenceClockFrequencyScalOrMu;
00482             fOutputEvent->fDTimeSinceLastEventSecondsScalOrMuRate = dDt;
00483 
00484             /* ScalOrMu */
00485             for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00486             {
00487                if( 0 != uLastScalerScalOrMu[uScalOrMuChanInd] &&
00488                    0 != fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00489                    uLastScalerScalOrMu[uScalOrMuChanInd] < fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd] &&
00490                    0.0 < dDt  )
00491                {
00492                   fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] =
00493                         (  (Double_t)fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd]
00494                          - (Double_t)uLastScalerScalOrMu[uScalOrMuChanInd] ) / dDt ;
00495                   fScalOrMuRate[uScalOrMuChanInd]->Fill( dDtInit, fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd], dDt );
00496                } // if correct dt and scaler increase
00497                   else
00498                   {
00499                      fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] = -1.0;
00500                   } // else of if correct dt and scaler increase
00501 
00502 
00503                uLastScalerScalOrMu[uScalOrMuChanInd]    = fCrateInputEvent->fScalOrMu.uScaler[uScalOrMuChanInd];
00504                uLastScalerRefScalOrMu[uScalOrMuChanInd] = fCrateInputEvent->fScalOrMu.uReferenceClock;
00505             } // for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00506 
00507             for( UInt_t uScalOrMuDetInd = 0; uScalOrMuDetInd <  fPar->uNbDetectorsScalormu; uScalOrMuDetInd++)
00508             {
00509                fOutputEvent->fDDetectorRate[uScalOrMuDetInd] = 0.0;
00510                for( UInt_t uScalOrMuChanInd = 0; uScalOrMuChanInd < SCALORMU_NB_SCAL; uScalOrMuChanInd++)
00511                   if( uScalOrMuDetInd == fPar->uDetectorScaler[uScalOrMuChanInd] && -1 < fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd] )
00512                      fOutputEvent->fDDetectorRate[uScalOrMuDetInd] += fOutputEvent->fDScalOrMuRate[uScalOrMuChanInd];
00513             }
00514             fScalOrMuRefClockEvolution->Fill(
00515                   (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
00516                                         - ( (Double_t)uInitialMbsTime + (Double_t)uInitialMilliTime/1000.0),
00517                   fCrateInputEvent->fScalOrMu.uReferenceClock - uLastScalerRefAllScalOrMu
00518                   );
00519             uLastScalerRefAllScalOrMu = fCrateInputEvent->fScalOrMu.uReferenceClock;
00520          } // else of if( fCrateInputEvent->fScalOrMu.uReferenceClock < uInitialScalerRefScalOrMu)
00521    } // else of if( 0 == uInitialScalerRef )
00522 
00523    if( 0 < fCrateInputEvent->fTriglogReferenceClock && 0 < fCrateInputEvent->fScalOrMu.uReferenceClock)
00524    {
00525       fReferenceClockComparison->Fill( (Int_t)fCrateInputEvent->fTriglogReferenceClock -
00526             (Int_t)fCrateInputEvent->fScalOrMu.uReferenceClock);
00527    }
00528 #endif // #else #if SCALORMU_NB_SCAL == 16
00529 
00530    fOutputEvent->SetValid(kTRUE);
00531 }