QGPulse.cc

Go to the documentation of this file.

#include "QGPulse.hh"
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>
#include "QChain.hh"
#include "QGCanvasWindow.hh"
#include "QGCutsFrame.hh"
#include "QGFileHandler.hh"
#include "QGPlotEditWindow.hh"
#include "QGPulseEditWindow.hh"
#include "QGPulseParametersFrame.hh"
#include "QGPlotFrame.hh"
#include "QGPlotStyleFrame.hh"
#include "QChannelRunData.hh"
#include "QGSessionHandler.hh"
#include "QSampleInfo.hh"
#include "TAxis.h"
#include "TCanvas.h"
#include "TPaveText.h"
#include "TDirectory.h"
#include "TEventList.h"
#include "TF1.h"
#include "TH1F.h"
#include "TMarker.h"
#include "TRootEmbeddedCanvas.h"
#include "TString.h"
#include "TTimeStamp.h"
 
ClassImp(QGPulse)
 
using std::cout;
using std::endl;
using std::flush;
using std::list;
using std::make_pair;
using std::multimap;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
using Diana::QVector;
 
list<QGPulse*> QGPulse::fPulses;
 
QGPulse::QGPulse() :
QGGraph(), 
fEventIndex(0), fEventList(new TEventList()), fNeedsReordering(true),
fStylePulse(new TGraph()), fUseADCUnits(false),fZeroOffset(false),fUnitary(false), fShowLegends(false), fSamplesLabel("")
{
    fPulses.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    SetEditable(kFALSE);
    MakeStylePlot();
    fEventData.push_back("Run");
    fEventData.push_back("EventNumber");
    fEventData.push_back("NsTime/1e9");
    fEventData.push_back("Channel");
    fEventData.push_back("IsSignal");
    fEventData.push_back("IsPulser");
}
 
QGPulse::QGPulse(const QGPulse &pulse) :
QGGraph(pulse), 
fEventData(pulse.fEventData), fEventIndex(pulse.fEventIndex), fEventList(new TEventList()), 
fNeedsReordering(pulse.fNeedsReordering), fOrderedEvents(pulse.fOrderedEvents), fOrderVariable(pulse.fOrderVariable), 
fStylePulse(new TGraph()), fUseADCUnits(pulse.fUseADCUnits), fZeroOffset(pulse.fZeroOffset), fUnitary(pulse.fUnitary), fShowLegends(pulse.fShowLegends),
fSamplesLabel(pulse.fSamplesLabel)
{
    *fEventList = *pulse.fEventList;
    fPulses.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    SetEditable(kFALSE);
    MakeStylePlot();
}
 
QGPulse::~QGPulse()
{
    if (fPlotEditWindow) {
        fPlotEditWindow->CloseWindow();
        fPlotEditWindow = 0;
    }
    if (find(fPulses.begin(), fPulses.end(), this) != fPulses.end()) {
        fPulses.erase(find(fPulses.begin(), fPulses.end(), this));
    }
    delete fStylePulse;
    
    // delete sample markers
    for (vector<TMarker*>::iterator marker = fSampleMarkers.begin();
         marker != fSampleMarkers.end();
         ++marker) {
        delete *marker;
    }
    fSampleMarkers.clear();
}
 
void QGPulse::AutoSetStyle()
{
    Color_t color = 4; // blue
    set<Color_t> existingColors;
    list<QGPulse*>::const_iterator plotIter;
    for (plotIter = fPulses.begin(); plotIter != fPulses.end(); ++plotIter) {
        existingColors.insert((*plotIter)->GetLineColor());
    }
    while (existingColors.count(color) != 0) {
        ++color;
        if (color == 5 || color == 10) { // yellow and white
            ++color;
        }
    }
    SetLineColor(color);
    MakeStylePlot();
}
 
void QGPulse::Display()
{
    Reset();
    if (NeedsReordering()) {
        Order();
        SetReorder(false);
    }
    bool isPulse = true;
    if (fEventIndex < fOrderedEvents.size()) {
        isPulse = GetPulseFromChain(fOrderedEvents[fEventIndex]);
    } else {
        SetPoints(0, 0, 0);
    }
 
    delete fHistogram;
    fHistogram = 0;
    if (fStylePulse) {
        fStylePulse->TAttFill::Copy(*this);
        fStylePulse->TAttLine::Copy(*this);
        fStylePulse->TAttMarker::Copy(*this);
    }
    string xAxisLabel = "Time (" + GetXUnits() + ")";
    string yAxisLabel = "Voltage (" + GetYUnits() + ")";
    GetXaxis()->SetTitle(xAxisLabel.c_str());
    GetYaxis()->SetTitle(yAxisLabel.c_str());
    GetYaxis()->SetTitleOffset(1.35);
    FillEventData();
    if (fCanvasWindow && isPulse) {
        bool drawSuperimpose = false;
        if (fSuperimpose) {
            if (fCanvasWindow->GetDrawnPlots().size() != 0) {
                if (typeid(*fCanvasWindow->GetDrawnPlots().back()) == typeid(*this)) {
                    drawSuperimpose = true;
                }
            }
        }
        if (drawSuperimpose) {
        
            fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
            if ( GetN() > 0) {
                Draw("L");
                DisplaySampleMarkers();
            }
            fCanvasWindow->RemoveFromDrawnPlots(this);
            fCanvasWindow->AddToDrawnPlots(this);
        } else {
            fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->Clear();
            if (isPulse && GetN() > 0) {
                Draw("AL");
                DisplaySampleMarkers();
            }
            fCanvasWindow->ClearDrawnPlots();
            fCanvasWindow->AddToDrawnPlots(this);
        }
        if(fShowLegends && fEventData.size() != 0){
            float topEdge = 1- fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->GetTopMargin() ; 
            float rightEdge = 1- fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->GetRightMargin()-0.01;
 
            int n = fEventData.size(); // n lines, each line is 0.05 NDC.
 
            TPaveText* eventTxt = new TPaveText(rightEdge *2/3, topEdge - 0.05*n , rightEdge, topEdge, "NDC");
            eventTxt->SetFillStyle(0); // transparent bkg.
            eventTxt->SetBorderSize(0); // no border
            eventTxt->SetTextAlign(13); //align left, bottom
            for (vector<string>::iterator tlIter = fEventData.begin(); tlIter != fEventData.end(); ++tlIter) {
                eventTxt->AddText((HumanizeEventData(*tlIter)).c_str());
            }
            eventTxt->Draw();
        }
        
        if (gPad) {
            gPad->Update();
        }
    }
    UpdatePulseEditWindow();
}
 
void QGPulse::DisplayEditWindow()
{
    if (!fPlotEditWindow) {
        fPlotEditWindow = new QGPulseEditWindow();
        fPlotEditWindow->SetPlot(this);
        
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kTRUE);
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        DrawStylePulse();
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kFALSE);
    }
}
 
void QGPulse::DisplaySampleMarkers()
{
    for (vector<TMarker*>::const_iterator marker = fSampleMarkers.begin();
         marker != fSampleMarkers.end();
         ++marker) {
        (*marker)->Draw();
    }
}
 
void QGPulse::DrawStylePulse()
{
    MakeStylePlot();
    TH1F *supportHistogram = new TH1F();
    supportHistogram->SetBit(kCanDelete, kTRUE);
    supportHistogram->SetStats(kFALSE);
    supportHistogram->SetBins(1, 0, 5);
    supportHistogram->GetYaxis()->SetRangeUser(0, 5);
    supportHistogram->Draw("AH");
    fStylePulse->Draw("L");
    if (gPad) {
        gPad->Update();
    }
}
 
void QGPulse::Duplicate()
{
    QGPulse *pulse = new QGPulse(*this);
    pulse->AutoSetStyle();
    pulse->DisplayEditWindow();
}
 
void QGPulse::Erase()
{
    if (fCanvasWindow) {
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
        fCanvasWindow->RemoveFromDrawnPlots(this);
        
        for (vector<TMarker*>::const_iterator marker = fSampleMarkers.begin();
             marker != fSampleMarkers.end();
             ++marker) {
             fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(*marker);
        }
        
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->Update();
        // check whether this was the first drawn plot and if so redraw remaining plots in order to have axes
    }
}
 
void QGPulse::FillEventData()
{
    if (fEventIndex < fOrderedEvents.size()) {
        vector<string>::iterator cutIter;
        for (cutIter = fEventData.begin(); cutIter != fEventData.end(); ++cutIter) {
            string::size_type beginPosition = cutIter->find_first_not_of(" ");
            if (beginPosition == string::npos) {
                *cutIter = cutIter->substr(beginPosition);
            }
            string::size_type endPosition = cutIter->find_first_of(" !=<>");
            if (endPosition != string::npos) {
                *cutIter = cutIter->substr(0, endPosition);
            }
            if (fCanvasWindow && fCanvasWindow->GetFileHandler() && fCanvasWindow->GetFileHandler()->IsFileOpen()) {
                QChain *chain = fCanvasWindow->GetFileHandler()->GetQChain();
                if (chain) {
                    chain->Draw(cutIter->c_str(), "", "goff", 1, fOrderedEvents[fEventIndex]);
                    if (chain->GetSelectedRows() == 1) {
                        stringstream ss;
                        if (*cutIter == "NsTime/1e9") {
                            ss.flags(std::ios::fixed);
                            ss.precision(3);
                        }
                        else if (cutIter->find("UnixTime") != string::npos){
                            ss.precision(13);
                        }
                        else {
                            ss.precision(6);
                        }
                        ss << " == " << chain->GetV1()[0] << flush;
                        cutIter->append(ss.str());
                    }
                }
            }
        }
    }
}
 
void QGPulse::Generate(QChain *chain)
{
    if (chain == 0) {
        if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
            if (fCanvasWindow->GetFileHandler()->IsFileOpen()) {
                chain = fCanvasWindow->GetFileHandler()->GetQChain();
            } else {
                cout << "Cannot generate the pulse because there is no file open" << endl;
            }
        }
    }
    if (chain) {
        chain->Draw(">>eventList", fCutsString.c_str()); // NOTE:  this will create a TEntryList in future versions of ROOT
        TEventList *eventList;
        gDirectory->GetObject("eventList", eventList);
        *fEventList = *eventList;
        delete eventList;
        Order();
    }
}
 
Int_t QGPulse::GetNumberOfEvents()
{
    return fEventList->GetN();
}
 
void QGPulse::GetParametersFromEditWindow()
{
    if (fPlotEditWindow) {
        if (QGPulseEditWindow *pulseEditWindow = dynamic_cast<QGPulseEditWindow*>(fPlotEditWindow)) {
            SetEventData(pulseEditWindow->GetEventDataFrame()->GetCuts());
            SetOrderVariable(pulseEditWindow->GetPulseParametersFrame()->GetOrderVariable());
            SetEventIndex(pulseEditWindow->GetPulseParametersFrame()->GetEventIndex());
            SetSuperimpose(pulseEditWindow->GetPulseParametersFrame()->IsSuperimposeSet());
            SetUseADCUnits(pulseEditWindow->GetPulseParametersFrame()->IsUseADCUnitsSet());
            SetZeroOffset(pulseEditWindow->GetPulseParametersFrame()->IsZeroOffsetSet());
            SetUnitary(pulseEditWindow->GetPulseParametersFrame()->IsUnitarySet());
            SetShowLegends(pulseEditWindow->GetPulseParametersFrame()->IsShowLegendsSet());
            SetSamplesLabel(pulseEditWindow->GetPulseParametersFrame()->GetSamplesLabel());
        } else {
            cout << "QGPulse::GetParametersFromEditWindow()        Warning:  dynamic_cast<QGPulseEditWindow*> failed" << endl;
        }
    }
}
 
bool QGPulse::GetPulseFromChain(Long64_t eventIndex)
{
    // delete existing sample markers
    for (vector<TMarker*>::iterator marker = fSampleMarkers.begin();
         marker != fSampleMarkers.end();
         ++marker) {
        delete *marker;
    }
    fSampleMarkers.clear();
    
    if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
        if (fCanvasWindow->GetFileHandler()->IsFileOpen()) {
            TObject* generic = fCanvasWindow->GetFileHandler()->GetGenericObject(eventIndex,fSamplesLabel);
            if(generic) {
                generic->Draw();
                return false;
            } else {
 
            const QVector& pulse = fCanvasWindow->GetFileHandler()->GetPulse(eventIndex,fSamplesLabel);
            const QChannelRunData *runData = fCanvasWindow->GetFileHandler()->GetChannelRunData(eventIndex);
            Double_t ADC2mV = 1;
            bool useADC2mV = false;
            Double_t samplingPeriod = 1;
            bool useSamplingPeriod = false;
            if (runData) {
                ADC2mV = runData->fADC2mV;
                useADC2mV = true;
                const Double_t samplingFrequency = runData->fSamplingFrequency;
                if (samplingFrequency != 0) {
                    samplingPeriod = 1.0 / samplingFrequency;
                    useSamplingPeriod = true;
                }
            }
            
            Double_t *V = new Double_t[pulse.Size()];
            Double_t *t = new Double_t[pulse.Size()];
            double amplitude;
            if(fUnitary) amplitude = pulse.GetMax()-pulse[0];
            for (Int_t i = 0; i < (Int_t)pulse.Size(); ++i) {
                V[i] = pulse[i];
                if(fZeroOffset) {
                    V[i] -= pulse[0];
                } 
                if(fUnitary && amplitude > 0) {
                    V[i] /= amplitude;
                } else if (!fUseADCUnits && useADC2mV) {
                    V[i] *= ADC2mV;
                }
                t[i] = i;
                if (!fUseADCUnits && useSamplingPeriod) {
                    t[i] *= samplingPeriod;
                }
            }
            if(fUnitary) {
                    SetYUnits("A.U.");
            }
            else if (!fUseADCUnits && useADC2mV) {
                    SetYUnits("mV");
            }
 
            else {
                    SetYUnits("ADC");
            }
            if (!fUseADCUnits && useSamplingPeriod) {
                SetXUnits("s");
            }
            else {
                SetXUnits("ADC");
            }
            SetPoints(pulse.Size(), t, V);
            
            // make marker for master sample
            const QSampleInfo& masterSample
                = fCanvasWindow->GetFileHandler()->GetMasterSample(eventIndex);
            Int_t index = masterSample.GetSampleIndex();
            if (index < (Int_t)pulse.Size()) {
                TMarker *marker = new TMarker();
                marker->SetMarkerStyle(23); // triangle, point down
                marker->SetX(t[index]);
                marker->SetY(V[index]);
                fSampleMarkers.push_back(marker);
            }
            
            // make sample markers for significant samples
            const vector<QSampleInfo>& significantSamples
                = fCanvasWindow->GetFileHandler()->GetSignificantSamples(eventIndex);
            for (vector<QSampleInfo>::const_iterator sample = significantSamples.begin();
                 sample != significantSamples.end();
                 ++sample) {
                Int_t index = sample->GetSampleIndex();
                if (index < (Int_t)pulse.Size()) {
                    TMarker *marker = new TMarker();
                    marker->SetMarkerStyle(23); // triangle, point down
                    if (sample->GetIsNoise()) {
                        marker->SetMarkerColor(kYellow);
                    }
                    else if (sample->GetIsPulser()) {
                        marker->SetMarkerColor(kRed);
                    }
                    else if (sample->GetIsSignal()) {
                        marker->SetMarkerColor(kGreen);
                    }
                    else if (sample->GetIsLED()) {
                        marker->SetMarkerColor(kMagenta);
                    }
                    else if (sample->GetIsReversed()) {
                        marker->SetMarkerStyle(22); // arrow up
                        marker->SetMarkerSize(1.5);   // a little bigger
                        marker->SetMarkerColor(kGreen+2);
                    }
                    else if (sample->GetIsVeto()) {
                        marker->SetMarkerStyle(29); // star
                        marker->SetMarkerSize(2);   // a little bigger
                        marker->SetMarkerColor(kOrange + 1);
                    }
                    marker->SetX(t[index]);
                    marker->SetY(V[index]);
                    fSampleMarkers.push_back(marker);
                }
            }
            
            delete [] V;
            delete [] t;
}
        }
    }
return true;
}
 
void QGPulse::MakeStylePlot()
{
    TF1 *styleFunction = new TF1("styleFunction", "1.2*TMath::Exp(-1.2*(x-1)) + 0.8*TMath::Exp(-0.4*(x-1)) - 2*TMath::Exp(-12*(x-1))", 0, 5);
    Int_t N = 50;
    fStylePulse->Set(N);
    for (Int_t i = 0; i < N; ++i) {
        Double_t x = 5.0/N*i;
        Double_t y = x < 1 ? 1.0 : 1.0 + 2.25*styleFunction->Eval(x);
        fStylePulse->SetPoint(i, x, y);
    }
    delete styleFunction;
    TAttFill::Copy(*fStylePulse);
    TAttLine::Copy(*fStylePulse);
    TAttMarker::Copy(*fStylePulse);
}
 
void QGPulse::Order()
{
    Int_t currentEventNumber = -1;
    if (fEventIndex < fOrderedEvents.size()) {
        currentEventNumber = fOrderedEvents[fEventIndex];
    }
    fEventIndex = 0;
    fOrderedEvents.clear();
    if (fOrderVariable == "") {
        for (Int_t index = 0; index < fEventList->GetN(); ++index) {
            fOrderedEvents.push_back(fEventList->GetEntry(index));
        }
    } else {
        if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
            if (fCanvasWindow->GetFileHandler()->IsFileOpen()) {
                fCanvasWindow->GetFileHandler()->GetQChain()->SetEventList(fEventList);
                fCanvasWindow->GetFileHandler()->GetQChain()->Draw(fOrderVariable.c_str(), "", "goff");
                fCanvasWindow->GetFileHandler()->GetQChain()->SetEventList(0);
                Double_t *orderVariableArray = fCanvasWindow->GetFileHandler()->GetQChain()->GetV1();
                multimap<Double_t, Long64_t> eventMap;
                Long64_t index;
                for (index = 0; index < fEventList->GetN(); ++index) {
                    eventMap.insert(make_pair(orderVariableArray[index], fEventList->GetEntry(index)));
                }
                multimap<Double_t, Long64_t>::const_iterator iter;
                index = 0;
                for (iter = eventMap.begin(); iter != eventMap.end(); ++iter, ++index) {
                    fOrderedEvents.push_back(iter->second);
                    if (iter->second == currentEventNumber) fEventIndex = index;
                }
            }
        }
    }
    SetReorder(false);
}
 
void QGPulse::SetEventIndex(Long_t index)
{
    if (0 <= index && index < fEventList->GetN()) {
        fEventIndex = index;
    } else {
        fEventIndex = 0;
    }
}
 
void QGPulse::SetName(const char *name)
{
    if (name) {
        string oldName = TGraph::GetName();
        string newName = name;
        if (newName != oldName) {
            if (IsNameInUse(name)) {
                TGraph::SetName(GeneratePlotName(newName).c_str());
            } else {
                TGraph::SetName(name);
            }
        }
    } else {
        TGraph::SetName(GeneratePlotName("Pulse").c_str());
    }
}
 
void QGPulse::SetOrderVariable(const string& orderVariable)
{
    if (fOrderVariable != orderVariable) {
        fOrderVariable = orderVariable;
        SetReorder();
    }
}
 
void QGPulse::SetProperty(const string& key, const string& value)
{
    QGPlot::SetProperty(key, value);
    TString valueTString(value);
    if (key == ORDER_VARIABLE_KEY) {
        SetOrderVariable(value);
    } else if (key == PULSE_VARIABLE_KEY) {
        SetSamplesLabel(value);
    } else if (key == EVENT_INDEX_KEY) {
        if (valueTString.IsFloat()) {
            SetEventIndex(valueTString.Atoi());
        }
    }
    else if (key == LINE_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetLineColor(valueTString.Atoi());
        }
    }
    else if (key == LINE_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetLineStyle(valueTString.Atoi());
        }
    }
    else if (key == LINE_WIDTH_KEY) {
        if (valueTString.IsFloat()) {
            SetLineWidth(valueTString.Atoi());
        }
    }
    else if (key == MARKER_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerColor(valueTString.Atoi());
        }
    }
    else if (key == MARKER_SIZE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerSize(valueTString.Atof());
        }
    }
    else if (key == MARKER_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerStyle(valueTString.Atoi());
        }
    }
}
 
void QGPulse::UpdatePulseEditWindow()
{
    if (QGPulseEditWindow *pulseEditWindow = dynamic_cast<QGPulseEditWindow*>(fPlotEditWindow)) {
        pulseEditWindow->UpdateEventData();
    }
}
 
string QGPulse::HumanizeEventData(string eventDatum)
{
    if(eventDatum.find("StartRunUnixTime") != string::npos){
        //Time stamp found, converted the rhs to time string
        string rhs = eventDatum.substr(eventDatum.find(" == ")+4);
        std::istringstream ss(rhs);
        long timeSeconds;
        ss >> timeSeconds;
        TTimeStamp timeStamp (timeSeconds, 0);
        eventDatum.erase(eventDatum.find(" == ")+4);
        eventDatum.append(timeStamp.AsString("s"));
    }
    
    size_t eventStamp = eventDatum.find("StartRunUnixTime+NsTime/1e9 ");
    if (eventStamp != string::npos)
        eventDatum.replace(eventStamp, 27, "Event Time Stamp");
    
    size_t runStamp = eventDatum.find("StartRunUnixTime ");
    if (runStamp != string::npos)
        eventDatum.replace(runStamp, 16, "Run Time Stamp");
 
    // " == " should always present by default. So no checking is needed.
    eventDatum.replace(eventDatum.find(" == "), 4, ": ");
 
    return eventDatum;
}