SignalWatcher.cpp

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <map>

#include "TCanvas.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TH1.h"
#include "TF1.h"
#include "TSpectrum.h"
#include "TBrowser.h"
#include "TMath.h"
#include "TVirtualFitter.h"
#include "TPavesText.h"
#include "TSystem.h"

#include "BashColor.h"
#include "LoupeOnPad.h"

#include "SignalWatcher.h"

using namespace std;


SignalWatcher::SignalWatcher(const char* name, const char *title) : SpectraViewerWatcher(name,title),
    fCurrentColor(0),
    ListOfCurrentGraphs(new TList()),
    fCurrentSignal(0),
    fTotShiftX(0.),
    fTotShiftY(0.),
    fTotScaleX(1.),
    fTotScaleY(1.),
    fLasteventType(0),
    fLasteventX(0),
    fLasteventY(0),
    fActiveShift(0),
    fActiveScale(0),
    fShiftFact(10),
    fScaleFact(0.05)
{
    ListOfCurrentGraphs->SetOwner(true);
    ListOfCurrentGraphs->SetName("ListOfGraphs");
}


void SignalWatcher::Init()
{
    for(int i=0 ; i<fNLib ; i++)
    {
        TList *l;
        l = new TList();
        l->SetOwner(true);
        l->SetName(Form("Lib_%d",i));
        ListOfCurrentGraphs->Add(l);
        for(int j=0 ; j<fNSg+1 ; j++)
        {
            MyGraph *myg;
            myg= new MyGraph();
            myg->SetWatcher(this);
            l->Add(myg);
        }
    }
}


SignalWatcher::~SignalWatcher()
{
    delete ListOfCurrentGraphs;
}


void SignalWatcher::Exec(const char */*option*/)
{

}


void SignalWatcher::ShowSignalsMap(int LibraryNbr, const char *option)
{
    TString opt = (TString)option;

    if(opt.Contains("a",TString::kIgnoreCase))
    {
        TString Name = fObservableTitle + "_" + fCrystalName;
        TString Title = "Mapping of the signals for crystal " + fCrystalName;

        fCanvas = CanvasVisu::BuildSegmentedCanvas(Name,Title);

        new LoupeOnPad(fCanvas);
        CanvasVisu::SetLoupe(false);

        fCanvas->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                         "SignalWatcher",
                         this,
                         "HandleMovement(Int_t, Int_t, Int_t, TObject*)");

    }
    else fCanvas = gPad->GetCanvas();

    if(fCanvas == 0x0) return;
    fCanvas->cd();

    this->UpdateGraphs("NoDraw");

    bool redraw = false;

    for(int i=0 ; i<fNSg+1 ; i++)
    {
        PadPos HistPosition = fHistPositionList[i];

        TPad *pad = (TPad*)fCanvas->cd(HistPosition.PadNmbr);

        MyGraph *Myg = (MyGraph*)((TList*)ListOfCurrentGraphs->At(LibraryNbr))->At(i);

        if(Myg==0x0) continue;

        TGraph *graph = (TGraph*)Myg->GetGraph();

        TPaveText *p = (TPaveText*)pad->GetListOfPrimitives()->FindObject("InfoPad");
        MyGraph *OldGraph = (MyGraph*)pad->GetListOfPrimitives()->FindObject(Myg->GetName());
        if(p) pad->GetListOfPrimitives()->Remove(p);

        if(OldGraph)
        {
            redraw = true;
            pad->GetListOfPrimitives()->Remove(OldGraph);
        }

        if(graph==0x0) continue;

        int col = 0;
        for(int k=0 ; k<pad->GetListOfPrimitives()->GetSize() ; k++)
        {
            if(pad->GetListOfPrimitives()->At(k)->InheritsFrom("MyGraph"))col++;
        }

        fCurrentColor = col;

        Myg->Draw(opt);

        if(p)p->Draw();
    }

    if(!redraw)this->UpdateGraphs(Form("Init_%d",LibraryNbr));
    else this->UpdateGraphs();
}


void SignalWatcher::GlobalAutoRange(const char *x_y)
{
    TString opt = x_y;
    opt.ToLower();

    double MinY = 100000., MaxY = -100000;
    double MinX = 100000., MaxX = -100000;

    bool OnlySeg = false;

    TString OptToToken = opt;
    TObjArray *token = OptToToken.Tokenize(" ");
    TObject *an_obj = 0x0;
    TIter it(token);
    while ( (an_obj = it.Next()) )
    {
        TString Name = an_obj->GetName();
        if(Name.Contains("seg")) OnlySeg = true;
    }

    for(int i=1 ; i<= fNPadsX*fNPadsY ; i++)
    {
        TPad *CurrentPad = (TPad*)fCanvas->cd(i);

        TPaveText *t = (TPaveText*)gPad->FindObject("InfoPad");
        if(!t) continue;
        else if(((TString)t->GetLine(1)->GetTitle()).Contains("Core") && OnlySeg) continue;

        TIter iter((TList*)CurrentPad->GetListOfPrimitives());
        TObject *o;
        TGraph *graph = 0x0;
        while( (o = iter()) )
        {
            if(o->InheritsFrom("MyGraph"))
            {
                graph = ((MyGraph*)o)->GetGraph();
                if(!graph) continue;

                double *x,*y;
                x = graph->GetX();
                y = graph->GetY();

                for(int j=0 ; j<graph->GetN() ; j++)
                {
                    if(x[j]<MinX) MinX = x[j];
                    if(x[j]>MaxX) MaxX = x[j];
                    if(y[j]<MinY) MinY = y[j];
                    if(y[j]>MaxY) MaxY = y[j];
                }
            }
        }
    }

    if(opt.Contains("y"))
    {
        double shift = TMath::Abs((MaxY-MinY)*0.05);
        SetRange(MinY-shift,MaxY+shift,"y");
    }
    if(opt.Contains("x")) SetRange(MinX,MaxX,"x");
}


void SignalWatcher::GoToEvent(int EvtNbr)
{
    this->RestoreModifs(false);

    fCurrentSignal = EvtNbr;

    if(fCurrentSignal<0) fCurrentSignal=0;

    int NMax = GetNEvents();

    if(fCurrentSignal>=NMax) fCurrentSignal = NMax-1;

    this->UpdateGraphs("NoDraw");

    this->ShiftAndScale(0.,0.,fTotScaleX,fTotScaleY,false);
    this->ShiftAndScale(fTotShiftX,fTotShiftY,1.,1.,false);

    GlobalAutoRange("xy");

    cout<<"Showing event number "<<fCurrentSignal<<" of watcher "<<GetName()<<endl;
}


void SignalWatcher::UpdateGraphs(const char *option)
{
    TString opt = (TString)option;

    for(int i=0 ; i<fNLib ; i++)
    {
        for(int j=0 ; j<fNSg+1 ; j++)
        {
            MyGraph *myg = (MyGraph*)((TList*)ListOfCurrentGraphs->At(i))->At(j);

            TGraph *NewGraph = GetGraph(i,j,fCurrentSignal);

            if(NewGraph == 0x0 || myg == 0x0) continue;

            if(opt == Form("Init_%d",i))
            {
                myg->SetLC(GetColor(fCurrentColor));
                myg->SetMC(GetColor(fCurrentColor));

                if(this->InheritsFrom("SignalWatcherTracesPsa") && i==1) myg->SetLS(2);

                myg->SetLW(2);
            }

            NewGraph->GetXaxis()->SetLabelSize(0.07);
            NewGraph->GetYaxis()->SetLabelSize(0.07);

            NewGraph->SetLineColor(myg->GetLineColor());
            NewGraph->SetLineStyle(myg->GetLineStyle());
            NewGraph->SetLineWidth(myg->GetLineWidth());

            NewGraph->SetMarkerColor(myg->GetMarkerColor());
            NewGraph->SetMarkerStyle(myg->GetMarkerStyle());
            NewGraph->SetMarkerSize(myg->GetMarkerSize());

            NewGraph->SetFillColor(myg->GetFillColor());
            NewGraph->SetFillStyle(myg->GetFillStyle());

            myg->SetGraph(NewGraph);
        }
    }

    if(!opt.Contains("NoDraw")) GlobalAutoRange("xy");
}


void SignalWatcher::ShiftAndScale(double XShift, double YShift, double XScale, double YScale, bool Store)
{

    if(XScale==0.) XScale = 1e-20;
    if(YScale==0.) YScale = 1e-20;

    for(int i=0 ; i<fNLib ; i++)
    {
        for(int j=0 ; j<fNSg+1 ; j++)
        {
            MyGraph *myg = (MyGraph*)((TList*)ListOfCurrentGraphs->At(i))->At(j);

            if(myg==0x0) continue;

            TGraph *Graph = myg->GetGraph();

            if(Graph==0x0) continue;

            double *X = Graph->GetX();
            double *Y = Graph->GetY();

            for(int k=0 ; k<Graph->GetN() ; k++)
            {
                X[k] = XScale * (X[k] + XShift);
                Y[k] = YScale * (Y[k] + YShift);
            }
        }
    }

    if(Store)
    {
        fTotScaleX = XScale*fTotScaleX;
        fTotShiftX = XScale*(fTotShiftX+XShift);

        fTotScaleY = YScale*fTotScaleY;
        fTotShiftY = YScale*(fTotShiftY+YShift);

        GlobalAutoRange("xy");
    }
}


void SignalWatcher::RestoreModifs(bool Store)
{
    ShiftAndScale(-fTotShiftX,-fTotShiftY,1./fTotScaleX,1./fTotScaleY,Store);

    if(Store) cout<<"Initial signal restored for wacher "<<GetName()<<endl;
}


void SignalWatcher::HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject *select)
{

//            cout<<endl;
//            cout<<"LasteventType = "<<fLasteventType<<" ; LasteventX = "<<fLasteventX<<" ; LasteventY = "<<fLasteventY<<endl;
//            cout<<"eventType = "<<eventType<<" ; eventX = "<<eventX<<" ; eventY = "<<eventY<<" ; ObjectName = "<<select->GetName()<<endl;
//            cout<<endl;

    fBashColor->SetInfoOut();

    if( eventType == kKeyPress )
    {
        SignalWatcher *SigWatch = 0x0;

        if(select->InheritsFrom("MyGraph"))
        {
            MyGraph *Myg = (MyGraph*)select;
            SigWatch = (SignalWatcher*)Myg->GetWatcher();
        }

        if((EKeySym)eventX == kKey_e && (EKeySym)eventY == kKey_e)
        {
            if((EKeySym)fLasteventX == kKey_n && (EKeySym)fLasteventY == kKey_n)
            {
                if(SigWatch) SigWatch->NextEvent();
            }
            else if((EKeySym)fLasteventX == kKey_p && (EKeySym)fLasteventY == kKey_p)
            {
                if(SigWatch) SigWatch->PreviousEvent();
            }
        }

        if((EKeySym)eventX == kKey_e-96 && (EKeySym)eventY == kKey_e)
        {
            TList *ListOfWatchers;
            ListOfWatchers = new TList();
            TList *ListOfMyGraphs = fCanvas->cd(1)->GetListOfPrimitives();
            for(int i=0 ; i<ListOfMyGraphs->GetSize() ; i++)
            {
                TObject *o = ListOfMyGraphs->At(i);
                MyGraph *MyG = 0x0;
                if(o->InheritsFrom("MyGraph")) MyG = (MyGraph*)o;
                if(MyG!=0x0 && MyG->GetWatcher()->InheritsFrom("SignalWatcher") && !ListOfWatchers->FindObject(MyG->GetWatcher())) ListOfWatchers->Add(MyG->GetWatcher());
            }

            if((EKeySym)fLasteventX == kKey_n-96 && (EKeySym)fLasteventY == kKey_n)
            {
                for(int i=0 ; i<ListOfWatchers->GetSize() ; i++) ((SignalWatcher*)ListOfWatchers->At(i))->NextEvent();
            }
            else if((EKeySym)fLasteventX == kKey_p-96 && (EKeySym)fLasteventY == kKey_p)
            {
                for(int i=0 ; i<ListOfWatchers->GetSize() ; i++) ((SignalWatcher*)ListOfWatchers->At(i))->PreviousEvent();
            }

            delete ListOfWatchers;
        }

        if((EKeySym)eventY == kKey_h && (EKeySym)fLasteventY == kKey_s) fActiveShift=1;

        if((EKeySym)eventY == kKey_x && (EKeySym)fLasteventY == kKey_h && fActiveShift==1 && SigWatch)
        {
            fLastSelect = SigWatch;
            fActiveShift=2;
            fActiveScale = 0;
            cout<<"Mode Xhift activated with shift factor at "<<fShiftFact<<endl;
        }

        if((EKeySym)eventY == kKey_y && (EKeySym)fLasteventY == kKey_h && fActiveShift==1 && SigWatch)
        {
            fLastSelect = SigWatch;
            fActiveShift=3;
            fActiveScale = 0;
            cout<<"Mode YShift activated with shift factor at "<<fShiftFact<<endl;
        }
        if(fActiveShift!=0 && (EKeySym)eventY == kKey_Shift)
        {
            if(fShiftFact == 1) fShiftFact = 10;
            else fShiftFact = 1;
            cout<<"Setting Shift factor at "<<fShiftFact<<endl;
        }
        if(fActiveShift!=0 && (EKeySym)eventY == kKey_Control)
        {
            if(fShiftFact == 100.) fShiftFact = 10;
            else fShiftFact = 100;
            cout<<"Setting Shift factor at "<<fShiftFact<<endl;
        }

        if((EKeySym)eventY == kKey_c && (EKeySym)fLasteventY == kKey_s) fActiveScale=1;

        if((EKeySym)eventY == kKey_x && (EKeySym)fLasteventY == kKey_c && fActiveScale==1 && SigWatch)
        {
            fLastSelect = SigWatch;
            fActiveScale=2;
            fActiveShift = 0;
            cout<<"Mode XScale activated with shift factor at "<<fScaleFact<<endl;
        }
        if((EKeySym)eventY == kKey_y && (EKeySym)fLasteventY == kKey_c && fActiveScale==1 && SigWatch)
        {
            fLastSelect = SigWatch;
            fActiveScale=3;
            fActiveShift = 0;
            cout<<"Mode YScale activated with shift factor at "<<fScaleFact<<endl;
        }
        if(fActiveScale!=0 && (EKeySym)eventY == kKey_Shift)
        {
            if(fScaleFact == 0.01) fScaleFact = 0.05;
            else fScaleFact = 0.01;
            cout<<"Setting Scale factor at "<<fScaleFact<<endl;
        }
        if(fActiveScale!=0 && (EKeySym)eventY == kKey_Control)
        {
            if(fScaleFact == 0.1) fScaleFact = 0.05;
            else fScaleFact = 0.1;
            cout<<"Setting Scale factor at "<<fScaleFact<<endl;
        }

        if((EKeySym)eventY == kKey_m && (EKeySym)fLasteventY == kKey_r)
        {
            if(SigWatch) SigWatch->RestoreModifs();
        }

        if((EKeySym)eventX == kKey_m-96 && (EKeySym)eventY == kKey_m)
        {
            TList *ListOfWatchers;
            ListOfWatchers = new TList();
            TList *ListOfMyGraphs = fCanvas->cd(1)->GetListOfPrimitives();
            for(int i=0 ; i<ListOfMyGraphs->GetSize() ; i++)
            {
                TObject *o = ListOfMyGraphs->At(i);
                MyGraph *MyG = 0x0;
                if(o->InheritsFrom("MyGraph")) MyG = (MyGraph*)o;
                if(MyG!=0x0 && MyG->GetWatcher()->InheritsFrom("SignalWatcher") && !ListOfWatchers->FindObject(MyG->GetWatcher())) ListOfWatchers->Add(MyG->GetWatcher());
            }

            if((EKeySym)fLasteventX == kKey_r-96 && (EKeySym)fLasteventY == kKey_r)
            {
                for(int i=0 ; i<ListOfWatchers->GetSize() ; i++) ((SignalWatcher*)ListOfWatchers->At(i))->RestoreModifs();
            }
            delete ListOfWatchers;
        }
    }

    if( (eventType == kWheelUp || eventType == kWheelDown ) && fLastSelect!=0x0 )
    {
        double fact = fShiftFact;
        if(eventType == kWheelDown) fact = -fShiftFact;
        if(fActiveShift==2) fLastSelect->ShiftX(fact);
        if(fActiveShift==3) fLastSelect->ShiftY(fact);
        fact = 1+fScaleFact;
        if(eventType == kWheelDown) fact = 1-fScaleFact;
        if(fActiveScale==2) fLastSelect->ScaleX(fact);
        if(fActiveScale==3) fLastSelect->ScaleY(fact);
    }

    if(eventY == 0 && eventX == 0 && ( fActiveShift || fActiveScale))
    {
        fActiveShift = 0;
        fActiveScale = 0;
        fLastSelect = 0x0;
        fShiftFact = 10;
        fScaleFact = 0.05;

        cout<<"Editor mode stoped !"<<endl;
    }

    fBashColor->ResetColor();

    fLasteventType = eventType;
    fLasteventX = eventX;
    fLasteventY = eventY;

}


SignalWatcherTracesPrepProd::SignalWatcherTracesPrepProd(const char* name, const char *title) : SignalWatcher(name,title)
{
    fNLib = 1;

    if(fObservableName.Contains("Prep")) fObservableTitle = "SigMap_Prep";
    else fObservableTitle = "SigMap_Prod";
    Init();
}


TGraph *SignalWatcherTracesPrepProd::GetGraph(int LibraryNbr, int SegNbr, int SigNbr)
{
    TGraph *graph = 0x0;

    TList *ListOfHists;

    LibraryNbr=0;

    ListOfHists = (TList*)fListOfLibrairies->At(SigNbr);
    graph = (TGraph*)ListOfHists->At(SegNbr);

    return graph;
}


SignalWatcherTracesPsa::SignalWatcherTracesPsa(const char* name, const char *title) : SignalWatcher(name,title)
{
    fNLib = 2;
    fObservableTitle = "SigMap_Psa";
    Init();
}


TGraph *SignalWatcherTracesPsa::GetGraph(int LibraryNbr, int SegNbr, int SigNbr)
{
    TGraph *graph = 0x0;

    TList *ListOfHists;

    ListOfHists = (TList*)fListOfLibrairies->At(2*SigNbr+LibraryNbr);
    graph = (TGraph*)ListOfHists->At(SegNbr);
    return graph;
}


void SignalWatcherTracesPsa::ShowTraces(const char *option,const char *Exp_Sim_Both)
{
    TString Opt = Exp_Sim_Both;
    Opt.ToLower();

    TString DrawOpt = option;
    DrawOpt.ToLower();


    if(Opt == "exp") SignalWatcher::ShowSignalsMap(0,option);
    if(Opt == "sim") SignalWatcher::ShowSignalsMap(1,option);

    if(Opt == "both")
    {
        SignalWatcher::ShowSignalsMap(0,option);
        SignalWatcher::ShowSignalsMap(1,DrawOpt.ReplaceAll("a",""));
    }
}


SignalWatcherAverSinglesPsa::SignalWatcherAverSinglesPsa(const char* name, const char *title) : SignalWatcher(name,title)
{
    fNLib = 2;
    fObservableTitle = "AverSingles_Psa";
    Init();
}


TGraph *SignalWatcherAverSinglesPsa::GetGraph(int LibraryNbr, int SegNbr, int SigNbr)
{
    TGraph *graph = 0x0;

    TList *ListOfHists;

    ListOfHists = (TList*)fListOfLibrairies->At(SigNbr+(fNSg+fNC)*LibraryNbr);
    graph = (TGraph*)ListOfHists->At(SegNbr);
    return graph;
}


void SignalWatcherAverSinglesPsa::ShowTraces(const char *option, const char *Exp_Sim_Both)
{
    TString Opt = Exp_Sim_Both;
    Opt.ToLower();

    TString DrawOpt = option;
    DrawOpt.ToLower();


    if(Opt == "exp") SignalWatcher::ShowSignalsMap(0,option);
    if(Opt == "sim") SignalWatcher::ShowSignalsMap(1,option);

    if(Opt == "both")
    {
        SignalWatcher::ShowSignalsMap(0,option);
        SignalWatcher::ShowSignalsMap(1,DrawOpt.ReplaceAll("a",""));
    }
}

ClassImp(SignalWatcher);
ClassImp(SignalWatcherTracesPrepProd);
ClassImp(SignalWatcherTracesPsa);
ClassImp(SignalWatcherAverSinglesPsa);