KeyWatchers.C

Go to the documentation of this file.

#include <iostream>
#include <iomanip>

#include "TH2.h"
#include "TH1.h"
#include "TCanvas.h"
#include "TPad.h"
#include "TStyle.h"
#include "TPaveStats.h"
#include "TPaveText.h"
#include "TSystem.h"
#include "TDatime.h"
#include "BufferIO.h"

#include "AgataCompositeFrame.h"
#include "AgataKeyFactory.h"
#include "PSAFrame.h"
#include "BashColor.h"

#include "KeyWatchers.h"

KeyWatcher::KeyWatcher( const char * name, const char * title, TDirectory *sp_dir, TDirectory *tag_dir):
    Watcher(name,title,sp_dir,tag_dir),
    CanvasVisu(name,title),
    fBashColor(new BashColor()),
    fNevts(0),
    fNBackwardTS(0),
    fNBackwardInBackwardTS(0),
    fNRepeatedEvts(0),
    fFrame(0x0),
    fNNullTS(0),
    FirstTimeStamp(0),
    FirstEventNumber(0),
    LastTimeStamp(0),
    LastGoodTimeStamp(0),
    lastEventNumber(0),
    fLastFillSec(0),
    fLastFillMin(0),
    fLastFillH(0)
{
    fHistInSec = MakeTH1<TH1F>((TString)name+"_1hour",(TString)title+" on 1 hour (1bin=100#mus)",36000,0,3600);
    fHistInMin = MakeTH1<TH1F>((TString)name+"_12hour",(TString)title+" on 12 hour (1bin=6s)",7200,0,720);
    fHistInH = MakeTH1<TH1F>((TString)name+"_2days",(TString)title+" on 2 days (1bin=6min)",480,0,48);

    fHistInSec0 = MakeTH1<TH1F>((TString)name+"_1hour_0",(TString)title+" on 1 hour for 0 values (1bin=100#mus)",36000,0,3600);
    fHistInMin0 = MakeTH1<TH1F>((TString)name+"_12hour_0",(TString)title+" on 12 hour for 0 values (1bin=6s)",7200,0,720);
    fHistInH0 = MakeTH1<TH1F>((TString)name+"_2days_0",(TString)title+" on 2 days for 0 values (1bin=6min)",480,0,48);

    fHistInSecMetaSync = MakeTH1<TH1F>((TString)name+"_1hour_MetaSync",(TString)title+" on 1 hour for meta sync frames (1bin=100#mus)",36000,0,3600);
    fHistInMinMetaSync = MakeTH1<TH1F>((TString)name+"_12hour_MetaSync",(TString)title+" on 12 hour for meta sync frames (1bin=6s)",7200,0,720);
    fHistInHMetaSync = MakeTH1<TH1F>((TString)name+"_2days_MetaSync",(TString)title+" on 2 days for meta sync frames (1bin=6min)",480,0,48);

    const int NMess = 10;
    fHistMessageType = MakeTH1<TH1I>("MessageType","Message type",NMess,0,NMess);
    TString labels[NMess] = {"event:data","event:data:psa","","data:tracked","data:psa","data:ranc0","data:ccrystal","data:crystal","conf:global","meta:sync"};
    for(int i=0 ; i<NMess ; i++) fHistMessageType->GetXaxis()->SetBinLabel(i+1,labels[i]);

    fHistFold = MakeTH1<TH1I>("CrystalFold","CrystalFold",20,0,20);

    fHistDTPSA = MakeTH1<TH1I>("TimeStampSpreadPSA","Time stamp spread in the event:data:psa frame",190,0,1900);

    fHistDTEvent = MakeTH1<TH1I>("TS_vamos-TS_agata","Time stamp spread in the event:data frame",600,-3000,3000);

    fHistDTPerCrystal = MakeTH2<TH2I>("TimeStampSpreadPerCrystal","Time stamp spread in the event:data:psa frame per crystal ID",50,0,50,190,0,1900);

    fHistDTEventPerCrystal = MakeTH2<TH2I>("Tvamos-TAgata_per_crystal","Time VAMOS - Time AGATA per crystal",50,0,50,600,-3000,3000);


    fBufferToRead = new BufferIO();

    NextCycleSec = 3600.;
    NextCycleMin = 720.;
    NextCycleH = 48.;

    IsDumpKeysActive = false;
    fDumpKeyFile = 0x0;
}

Bool_t KeyWatcher::SetTrigger( ADF::DFTrigger *trigger )
{
    if ( ! Watcher::SetTrigger(trigger) ){
        fFrame = 0x0;
        return false;
    }

    // set the unique frame to be watched
    fFrame = GetTrigger()->GetInputSharedFP();

    if ( dynamic_cast<AgataFrameTrigger *> (GetTrigger())) {
        fPSAFrame = (dynamic_cast<AgataFrameTrigger *> (GetTrigger()))->AddUtility("data:psa",ConfAgent::theGlobalAgent());
    }

    return true;
}


void KeyWatcher::ShowTSDist(const char *option)
{
    TString opt = (TString)option;
    TCanvas *c = 0x0;

    opt.ToLower();

    if(opt.Contains("same")) c = (TCanvas*)gPad->GetCanvas();
    else
    {
        TString Name = (TString)GetName() + "_TSDist";
        TString Title = (TString)GetTitle() + " time stamp distribution";
        c = CanvasVisu::NewCanvas(Name,Title);
        c->Divide(1,3,0.001,0.001);
    }

    if(c == 0x0) return;

    int col = 0;
    for(int k=0 ; k<c->cd(1)->GetListOfPrimitives()->GetSize() ; k++)
    {
        if(c->cd(1)->GetListOfPrimitives()->At(k)->InheritsFrom("TH1"))col++;
    }

    double topmarg = 0.00667084;
    double rightmarg = 0.00200251;
    double leftmarg = 0.0373055;
    double bottommarg = 0.155235;

    TH1F *hnormal[3] = {fHistInSec,fHistInMin,fHistInH};
    TH1F *h0[3] = {fHistInSec0,fHistInMin0,fHistInH0};
    TH1F *hMeta[3] = {fHistInSecMetaSync,fHistInMinMetaSync,fHistInHMetaSync};

    TH1F **h;
    opt.ReplaceAll(" ","");
    opt.ToLower();
    if(opt.Contains("0"))
    {
        h = h0;
        opt.ReplaceAll("0","");
    }
    if(opt.Contains("meta",TString::kIgnoreCase))
    {
        h = hMeta;
        opt.ReplaceAll("meta","");
    }
    else h = hnormal;

    TString titles[3] = {"Time [1h] (s)","Time [12h] (min)","Time [2d] (h)"};

    for(int i=0 ; i<3 ; i++)
    {
        c->cd(i+1);

        gPad->SetRightMargin(rightmarg);
        gPad->SetTopMargin(topmarg);
        gPad->SetLeftMargin(leftmarg);
        gPad->SetBottomMargin(bottommarg);

        TH1F *htemp = h[i];

        htemp->SetLineColor(GetColor(col));
        htemp->Draw(opt);

        if(!opt.Contains("same"))
        {
            htemp->GetXaxis()->SetTitle(titles[i]);
            htemp->GetXaxis()->SetTitleSize(0.08);
            htemp->GetXaxis()->SetLabelSize(0.08);
            htemp->GetXaxis()->SetTitleOffset(0.91);

            htemp->GetYaxis()->SetTitle("Rate (Counts/s)");
            htemp->GetYaxis()->SetTitleSize(0.08);
            htemp->GetYaxis()->SetLabelSize(0.08);
            htemp->GetYaxis()->SetTitleOffset(0.25);


            htemp->SetStats(0);
        }
        gPad->Modified();
        gPad->Update();
    }
}

void KeyWatcher::Exec(Option_t * /*option*/)
{
    AgataKey *MainKey = (AgataKey*)fFrame->GetFrame()->GetKey();

    ULong64_t fTimestamp = MainKey->GetTimeStamp();

    TString MessageType = AgataKeyFactory::theFactory()->GetMessage(MainKey->GetMessage());

    fNevts++;

    if(MessageType=="conf:global" || MessageType=="meta:sync")
    {
        fHistMessageType->Fill(MessageType,1);


        fHistInSecMetaSync->Fill(fLastFillSec,10);
        fHistInMinMetaSync->Fill(fLastFillMin,10./60.);
        fHistInHMetaSync->Fill(fLastFillH,10./3600.);

        return;
    }

    if(fTimestamp==0)
    {
        fHistInSec0->Fill(fLastFillSec,10);
        fHistInMin0->Fill(fLastFillMin,10./60.);
        fHistInH0->Fill(fLastFillH,10./3600.);

        fNNullTS++;
        return;
    }

    if(FirstTimeStamp==0)
    {
        TTask *FD = ((TTask*)gROOT->GetListOfTasks()->FindObject("FD"));
        TList *ListOfTasks = 0x0;
        if(FD) ListOfTasks = FD->GetListOfTasks();
        KeyWatcher *UnivKey = 0x0;
        TIter it(ListOfTasks);
        TObject *o = 0x0;
        while( (o=it.Next()) )
        {
            if(((TString)o->GetName()).Contains("Univ"))
            {
                UnivKey = (KeyWatcher*)o;
                break;
            }
        }

        if(UnivKey && ! ((TString)GetName()).Contains("Keys_Univ"))
        {
            FirstTimeStamp = UnivKey->GetFirstTS();
            FirstEventNumber = UnivKey->GetFirstEN();
        }
        else
        {
            FirstTimeStamp = fTimestamp;
            FirstEventNumber = MainKey->GetEventNumber();
        }

        LastGoodTimeStamp = FirstTimeStamp;
    }

    double TSinSec = fmod((fTimestamp-FirstTimeStamp)*10*1e-9,3600);
    double TSinMin = fmod((fTimestamp-FirstTimeStamp)*10*1e-9/60.,720);
    double TSinH = fmod((fTimestamp-FirstTimeStamp)*10*1e-9/3600.,48);


    if(LastTimeStamp!=0 && TMath::Abs(((double)fTimestamp-(double)LastTimeStamp)*10*1e-9 > 3600.))
        return;

    if((fTimestamp-FirstTimeStamp)*10*1e-9 > NextCycleSec)
    {
        fHistInSec->Reset();
        fHistInSec0->Reset();
        fHistInSecMetaSync->Reset();
        NextCycleSec += 3600.;
    }
    if((fTimestamp-FirstTimeStamp)*10*1e-9/60. > NextCycleMin)
    {
        fHistInMin->Reset();
        fHistInMin0->Reset();
        fHistInMinMetaSync->Reset();
        NextCycleMin += 720.;
    }
    if((fTimestamp-FirstTimeStamp)*10*1e-9/3600. > NextCycleH)
    {
        fHistInH->Reset();
        fHistInH0->Reset();
        fHistInHMetaSync->Reset();
        NextCycleH += 48.;
    }

    if(fTimestamp>LastTimeStamp && fTimestamp > LastGoodTimeStamp)
    {
        LastGoodTimeStamp = fTimestamp;
    }

    if(fTimestamp<LastTimeStamp)
    {
        if(TMath::Abs(((double)fTimestamp-(double)FirstTimeStamp)*10*1e-9 < 1.))
        {
//            Print();
//            ResetStats();
        }
        else
        {
//            fBashColor->SetWarningOut();
//            cout<<GetName()<<endl;
//            cout<<"Warning, this time stamp has been already seen !!!"<<endl;
//            fBashColor->ResetColor();

//            cout<<"Last time stamp seen      : "<<LastTimeStamp<<" ==> "<<fLastFillSec<<" s"<<endl;
//            cout<<"Current time stamp        : "<<fTimestamp<<" ==> "<<TSinSec<<" s"<<endl;
//            cout<<"shift of "<<((double)fTimestamp-(double)LastTimeStamp)*10*1e-9<<" s"<<endl;
//            cout<<"LastGoodTimeStamp = "<<LastGoodTimeStamp<<endl<<endl;

            fNBackwardTS++;

            if(LastTimeStamp<LastGoodTimeStamp) fNBackwardInBackwardTS++;
        }
    }
    else
    {
        fHistInSec->Fill(TSinSec,10);
        fHistInMin->Fill(TSinMin,10./60.);
        fHistInH->Fill(TSinH,10./3600.);
    }

    if(fTimestamp < LastGoodTimeStamp)
    {
        fNRepeatedEvts++;
    }

    fLastFillSec = TSinSec;
    fLastFillMin = TSinMin;
    fLastFillH = TSinH;

    LastTimeStamp = fTimestamp;

    lastEventNumber = MainKey->GetEventNumber();

    if(IsDumpKeysActive) MainKey->GetRealBuffer()->Export(fDumpKeyFile,MainKey->GetKeyLength());

    if(!fHistMessageType->GetXaxis()->FindBin(MessageType))
        cout<<"WARNING ! Unknown message type : "<<MessageType<<endl;
    else fHistMessageType->Fill(MessageType,1);

    UInt_t length, current, eventnumber, message; ULong64_t timestamp; TString SubMess;

    ADF::Frame *AgataFrame = fFrame->GetFrame();

    const BufferIO *buf_temp = AgataFrame->GetRealBuffer();

    fBufferToRead->SetOffset();

    fBufferToRead->Import((*buf_temp),MainKey->GetFrameLength());

    fBufferToRead->SetOffset();

    fBufferToRead->SetEffectiveSize(MainKey->GetFrameLength()-20u);

    double DTEvent = 0.;
    double DTEventPC[50];
    ULong64_t TimeAGATA=0;
    ULong64_t TimeAGATAPC[50];
    for(int i=0 ; i<50 ; i++) TimeAGATA = 0;
    ULong64_t TimeVamos=0;
    bool IsVamos = false;
    bool IsAGATA = false;

    if ( MessageType.Contains("event") )
    {
        int Fold = 0;
        bool is_a_start = false;

        fBufferToRead->SetOffset();

        while ( fBufferToRead->FreeSize() > 20u )
        {
            current = fBufferToRead->Offset();

            const char *adress = fBufferToRead->CurrentAddress();

            (*fBufferToRead) >> length >> message >> eventnumber >> timestamp ;
            SubMess = AgataKeyFactory::theFactory()->GetMessage(message);

            //            cout<<"\E[30;1m";
            //            cout<<MainKey->GetTimeStamp()<<endl;
            //            cout<<((AgataKey*)fFrame->GetFrame()->GetKey())->GetTimeStamp()<<endl;
            //            cout<<SubMess<<" "<<timestamp<<" "<<eventnumber<<endl;
            //            cout<<"\E[m";

            if ( SubMess.Contains("UnknownKey") ) { // an unknown key
                is_a_start = false;
            }
            else is_a_start = true;

            if ( is_a_start )
            { // a known key has been found

                if(!fHistMessageType->GetXaxis()->FindBin(SubMess)) cout<<"WARNING ! Unknown sub-message type : "<<SubMess<<endl;
                else
                {
                    fHistMessageType->Fill(SubMess,1);
                    if(SubMess=="event:data:psa")
                    {
                        UInt_t sublength, subcurrent, subeventnumber, submessage; ULong64_t subtimestamp; TString SubSubMess;

                        UInt_t TotSubLenght = 20;
                        subcurrent = fBufferToRead->SetOffset(current + 20u);

                        while ( TotSubLenght<length )
                        {
                            const char *subadress = fBufferToRead->CurrentAddress();

                            (*fBufferToRead) >> sublength >> submessage >> subeventnumber >> subtimestamp ;

                            SubSubMess = AgataKeyFactory::theFactory()->GetMessage(submessage);

                            fHistMessageType->Fill(SubSubMess,1);

                            if(SubSubMess == "data:psa")
                            {
                                Fold++;
                                double DTPsa = (subtimestamp-timestamp)*10;
                                fHistDTPSA->Fill(DTPsa);

                                fPSAFrame->GetFrame()->Copy(subadress,sublength);
                                fPSAFrame->GetFrame()->Read();

                                PSAInterface *data = GetDataPointer<PSAInterface>(fPSAFrame);
                                UInt_t crysal_id = data->GetUID();

                                fHistDTPerCrystal->Fill(crysal_id,DTPsa);

                                TimeAGATAPC[crysal_id] = subtimestamp;
                            }

                            TotSubLenght += sublength;

                            fBufferToRead->SetOffset( subcurrent + sublength );

                            subcurrent+=sublength;
                        }
                        if(MessageType=="event:data")
                        {
                            TimeAGATA = timestamp;
                            IsAGATA = true;
                            //                            double DTEvent = (timestamp-fTimestamp)*10;
                            //                            fHistDTEvent->Fill(-DTEvent);
                        }
                    }
                    if(SubMess=="data:ranc0" && MessageType=="event:data")
                    {
                        TimeVamos = timestamp;
                        IsVamos = true;
                        //                        double DTEvent = (timestamp-fTimestamp)*10;
                        //                        fHistDTEvent->Fill(DTEvent);
                    }
                    if(SubMess=="data:psa")
                    {
                        Fold++;
                        double DTPsa = (timestamp-fTimestamp)*10;
                        fHistDTPSA->Fill(DTPsa);

                        fPSAFrame->GetFrame()->Copy(adress,length);
                        fPSAFrame->GetFrame()->Read();

                        PSAInterface *data = GetDataPointer<PSAInterface>(fPSAFrame);
                        UInt_t crysal_id = data->GetUID();

                        fHistDTPerCrystal->Fill(crysal_id,DTPsa);
                    }
                }
                fBufferToRead->SetOffset( current + length );
            }
            else
            {
                fBufferToRead->SetOffset( current + 4u );
            }
        }

        fHistFold->Fill(Fold);
    }

    if(IsVamos&&IsAGATA)
    {
        DTEvent = (double)(TimeVamos*1.-TimeAGATA*1.)*10;
        fHistDTEvent->Fill(DTEvent);
        for(int i=0 ; i<50 ; i++)
        {
            if(TimeAGATAPC[i]!=0)
            {
                DTEventPC[i] = (TimeVamos*1.-TimeAGATAPC[i]*1.)*10;
                fHistDTEventPerCrystal->Fill(i,DTEventPC[i]);
            }
        }
    }
}

void KeyWatcher::ResetTo(const char *option)
{
    TString opt = option;

    if(opt.Contains("1") || opt.Contains("all"))
    {
        fHistInSec->Reset();
        fHistInSec0->Reset();
        fHistInSecMetaSync->Reset();
    }
    if(opt.Contains("2") || opt.Contains("all"))
    {
        fHistInMin->Reset();
        fHistInMin0->Reset();
        fHistInMinMetaSync->Reset();
    }
    if(opt.Contains("3") || opt.Contains("all"))
    {
        fHistInH->Reset();
        fHistInH0->Reset();
        fHistInHMetaSync->Reset();
    }

    TCanvas *c = gPad->GetCanvas();
    for(int k=0 ; k<c->GetListOfPrimitives()->GetSize() ; k++)
    {
        TPad *pad = (TPad*)c->cd(k);
        if(pad)
        {
            pad->Modified();
            pad->Update();
        }
    }

    FirstTimeStamp = LastTimeStamp;
}

void KeyWatcher::ShowMessageType()
{

    TString Name = fName + "_MessType";
    TString Title = fTitle + " Message Type";

    TCanvas *c = CanvasVisu::NewCanvas(Name,Title);

    c->Divide(2,2,0.001,0.001);

    c->cd(1);

    double topmarg = 0.0560089;
    double rightmarg = 0.01455;
    double leftmarg = 0.0747608;
    double bottommarg = 0.0962985;

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);

    fHistMessageType->SetBit(TH1::kNoTitle);
    fHistMessageType->GetYaxis()->SetTitle("Counts");
    fHistMessageType->GetYaxis()->SetTitleSize(0.05);
    fHistMessageType->GetYaxis()->SetLabelSize(0.05);
    fHistMessageType->GetYaxis()->SetTitleOffset(0.8);

    fHistMessageType->GetXaxis()->SetTitleSize(0.05);
    fHistMessageType->GetXaxis()->SetLabelSize(0.05);

    fHistMessageType->Draw();
    gPad->Modified();
    gPad->Update();

    TPaveStats *st = (TPaveStats*)fHistMessageType->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
    }

    c->cd(2);

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);

    fHistFold->SetBit(TH1::kNoTitle);
    fHistFold->GetYaxis()->SetTitle("Counts");
    fHistFold->GetYaxis()->SetTitleSize(0.05);
    fHistFold->GetYaxis()->SetLabelSize(0.05);
    fHistFold->GetYaxis()->SetTitleOffset(0.8);

    fHistFold->GetXaxis()->SetTitle("Fold");
    fHistFold->GetXaxis()->SetTitleSize(0.05);
    fHistFold->GetXaxis()->SetLabelSize(0.05);

    fHistFold->Draw();
    gPad->Modified();
    gPad->Update();

    st = (TPaveStats*)fHistFold->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
    }

    c->cd(3)->Divide(1,2,0.001,0.001);

    topmarg = 0.0119154;
    rightmarg = 0.00310682;
    leftmarg = 0.0660825;
    bottommarg = 0.175578;

    c->cd(3)->cd(1);

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);
    gPad->SetLogy();

    fHistDTPSA->SetBit(TH1::kNoTitle);
    fHistDTPSA->GetYaxis()->SetTitle("Counts");
    fHistDTPSA->GetYaxis()->SetTitleSize(0.09);
    fHistDTPSA->GetYaxis()->SetLabelSize(0.08);
    fHistDTPSA->GetYaxis()->SetTitleOffset(0.4);

    fHistDTPSA->GetXaxis()->SetTitle("#DeltaT Psa (ns)");
    fHistDTPSA->GetXaxis()->SetTitleSize(0.09);
    fHistDTPSA->GetXaxis()->SetLabelSize(0.08);

    fHistDTPSA->Draw();
    gPad->Modified();
    gPad->Update();

    st = (TPaveStats*)fHistDTPSA->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
        st->SetX1NDC(0.743455);
        st->SetY1NDC(0.672483);
    }
    c->cd(3)->cd(2);

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);
    gPad->SetLogy();

    fHistDTEvent->SetBit(TH1::kNoTitle);
    fHistDTEvent->GetYaxis()->SetTitle("Counts");
    fHistDTEvent->GetYaxis()->SetTitleSize(0.09);
    fHistDTEvent->GetYaxis()->SetLabelSize(0.08);
    fHistDTEvent->GetYaxis()->SetTitleOffset(0.4);

    fHistDTEvent->GetXaxis()->SetTitle("#DeltaT Event (ns)");
    fHistDTEvent->GetXaxis()->SetTitleSize(0.09);
    fHistDTEvent->GetXaxis()->SetLabelSize(0.08);

    fHistDTEvent->Draw();
    gPad->Modified();
    gPad->Update();

    st = (TPaveStats*)fHistDTEvent->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
        st->SetX1NDC(0.743455);
        st->SetY1NDC(0.672483);
    }

    c->cd(4)->Divide(1,2,0.001,0.001);
    c->cd(4)->cd(1);

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);
    gPad->SetLogz();

    fHistDTPerCrystal->SetBit(TH1::kNoTitle);
    fHistDTPerCrystal->GetYaxis()->SetTitle("#DeltaT Psa (ns)");
    fHistDTPerCrystal->GetYaxis()->SetTitleSize(0.09);
    fHistDTPerCrystal->GetYaxis()->SetLabelSize(0.08);
    fHistDTPerCrystal->GetYaxis()->SetTitleOffset(0.4);

    fHistDTPerCrystal->GetXaxis()->SetTitle("Crystal ID");
    fHistDTPerCrystal->GetXaxis()->SetTitleSize(0.09);
    fHistDTPerCrystal->GetXaxis()->SetLabelSize(0.08);

    fHistDTPerCrystal->Draw("col");
    gPad->Modified();
    gPad->Update();

    st = (TPaveStats*)fHistDTPerCrystal->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
    }

    c->cd(4)->cd(2);

    gPad->SetRightMargin(rightmarg);
    gPad->SetTopMargin(topmarg);
    gPad->SetLeftMargin(leftmarg);
    gPad->SetBottomMargin(bottommarg);
    gPad->SetLogz();

    fHistDTEventPerCrystal->SetBit(TH1::kNoTitle);
    fHistDTEventPerCrystal->GetYaxis()->SetTitle("#DeltaT VAMOS - AGATA (ns)");
    fHistDTEventPerCrystal->GetYaxis()->SetTitleSize(0.09);
    fHistDTEventPerCrystal->GetYaxis()->SetLabelSize(0.08);
    fHistDTEventPerCrystal->GetYaxis()->SetTitleOffset(0.4);

    fHistDTEventPerCrystal->GetXaxis()->SetTitle("Crystal ID");
    fHistDTEventPerCrystal->GetXaxis()->SetTitleSize(0.09);
    fHistDTEventPerCrystal->GetXaxis()->SetLabelSize(0.08);

    fHistDTEventPerCrystal->Draw("col");
    gPad->Modified();
    gPad->Update();

    st = (TPaveStats*)fHistDTEventPerCrystal->FindObject("stats");
    if(st)
    {
        st->SetX2NDC(1-rightmarg);
        st->SetY2NDC(1-topmarg);
    }

}

void KeyWatcher::DumpKeys(bool ActiveDump)
{
    if( !IsDumpKeysActive && ActiveDump)
    {
        std::ostringstream filename;
        int fCurrentFileNumber = 0;
        filename << (TString)GetName() + "_" << std::setfill('0') << std::setw(4) << fCurrentFileNumber << ".keys";

        while(gSystem->IsFileInIncludePath(filename.str().data()))
        {
            filename.str("");
            filename << (TString)GetName() + "_" << std::setfill('0') << std::setw(4) << fCurrentFileNumber++ << ".keys";
        }

        fDumpKeyFile = ::fopen(filename.str().data(),"wb");
        fFileName = filename.str();

        fBashColor->SetInfoOut();
        cout<<"Keys will be dumped in the file : "<<fFileName<<endl;
    }
    else if( IsDumpKeysActive && !ActiveDump )
    {
        if ( fDumpKeyFile ) ::fclose(fDumpKeyFile);
        fDumpKeyFile = 0x0;

        fBashColor->SetInfoOut();
        cout<<"Dumped-keys file : "<<fFileName<<" is close !"<<endl;
    }
    else if( IsDumpKeysActive && ActiveDump )
    {
        fBashColor->SetWarningOut();
        cout<<"Keys dumping already active"<<endl;
    }
    else if( !IsDumpKeysActive && !ActiveDump )
    {
        fBashColor->SetWarningOut();
        cout<<"Keys dumping is not active"<<endl;
    }

    IsDumpKeysActive = ActiveDump;

    fBashColor->ResetColor();
}

void KeyWatcher::Print(const char * /* option */ ) const
{
    std::cout<<std::endl;
    int size = 3 + 3 + ((TString)GetName()).Length() + 5 + ((TString)GetTitle()).Length() + 3 + 3;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;
    std::cout<<"***   "<<GetName()<<" --- "<<GetTitle()<<"   ***"<<std::endl;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;

    std::cout<<"Number of treated events : "<<fNevts<<std::endl;

    for(int i=fHistMessageType->GetXaxis()->GetNbins() ; i>0 ; i--)
    {
        Int_t N = (Int_t)fHistMessageType->GetBinContent(i);
        TString label = fHistMessageType->GetXaxis()->GetBinLabel(i);
        if(N!=0) std::cout<<"  ---> "<<label<<" : "<<N<<endl;
    }

    fBashColor->SetErrorOut();
    if(fNNullTS>0)               std::cout<<"Number of empty Timestamps                : "<<fNNullTS<<std::endl;
    if(fNBackwardTS>0)           std::cout<<"Number of backward timestamps             : "<<fNBackwardTS<<std::endl;
    if(fNBackwardInBackwardTS>0) std::cout<<"Number of backward in backward timestamps : "<<fNBackwardInBackwardTS<<std::endl;
    if(fNRepeatedEvts>0)         std::cout<<"Number of repeated timestamps             : "<<fNRepeatedEvts<<std::endl;
    if(fNBackwardTS>0)           std::cout<<"Mean number of repeated TS per backward   : "<<(double)fNRepeatedEvts/(double)fNBackwardTS<<std::endl;
    fBashColor->SetInfoOut();

    std::cout<<std::endl;
    std::cout<<"First Timestamp          : "<<FirstTimeStamp<<std::endl;
    std::cout<<"Last Timestamp           : "<<LastTimeStamp<<std::endl;
    std::cout<<"First Event number       : "<<FirstEventNumber<<std::endl;
    std::cout<<"Last Event number        : "<<lastEventNumber<<std::endl;

    double TotalTimeInS = (LastTimeStamp-FirstTimeStamp)*10.*1e-9;
    int TH = (int)(TotalTimeInS/3600.);
    int TMin = (int)((TotalTimeInS/3600.-TH)*60.);
    int TSec = (int)(((TotalTimeInS/3600.-TH)*60.-TMin)*60.);

    std::cout<<"Elapsed time (s)         : "<<TotalTimeInS<<" ( "<<TH<<"h"<<TMin<<"'"<<TSec<<"'' )"<<std::endl;

    fBashColor->ResetColor();
}

void KeyWatcher::ResetStats()
{
    NextCycleSec = 3600.;
    NextCycleMin = 720.;
    NextCycleH = 48.;

    fHistInSec->Reset();
    fHistInSec0->Reset();
    fHistInSecMetaSync->Reset();
    fHistInMin->Reset();
    fHistInMin0->Reset();
    fHistInMinMetaSync->Reset();
    fHistInH->Reset();
    fHistInH0->Reset();
    fHistInHMetaSync->Reset();

    fNNullTS = 0;
    fNBackwardTS = 0;
    fNBackwardInBackwardTS = 0;
    fNRepeatedEvts = 0;
    fNBackwardTS = 0;

    FirstTimeStamp = 0;
    LastTimeStamp = 0;
    FirstEventNumber = 0;
    lastEventNumber = 0;
    LastGoodTimeStamp = 0;

    fNevts = 0;

    fHistMessageType->Reset();
}



ClassImp(KeyWatcher);