Subversion Repositories f9daq

// Simple macro showing capabilities of triple slider

//Authors: Bertrand Bellenot, Ilka Antcheva

#include "TGButton.h"

#include "TRootEmbeddedCanvas.h"

#include "TGLayout.h"

#include "TF1.h"

#include "TMath.h"

#include "TCanvas.h"

#include "TGTextEntry.h"

#include "TGNumberEntry.h"

#include "TGLabel.h"

#include "TGTripleSlider.h"

#include "TGFrame.h"

#include "TGTab.h"

#include "TGButton.h"

#include "TGSlider.h"

#include "TGComboBox.h"

#include <TGFileDialog.h>

#include "DrsChannel.h"

#include "drs.h"

enum ETestCommandIdentifiers {

        HId1,

        HId2,

        HId3,

        VId1,

        VId2,

        VId3,

        CFId1,

        HCId1,

        HCId2,

        HSId1,

        VSId1,

        StartId

};

const char *filetypesdat[] = {

        "data files",    "*.dat",

        "Text files",    "*.[tT][xX][tT]",

        0,               0

};

const char *filetypesini[] = {

        "configuration files",    "*.ini",

        0,               0

};

TRootEmbeddedCanvas *fCanvas;

class TChannel {

private:

        TGTripleHSlider     *fTimingSlider;

        TGTripleHSlider     *fThresholdSlider;

        TGLayoutHints       *fBly, *fBfly1, *fBfly2, *fBfly3;

public:

        TChannel( TGCompositeFrame *p, int ch);

        ~TChannel();

        TGTextEntry         *fTeh[7];

        TGTextBuffer        *fTbh[7];

        TGCheckButton       *fEdge;

        void DoText(const char *text);

        void DoSlider();

        void HandleButtons();

        ClassDef(TChannel, 0)

};

TChannel::~TChannel(){

}

TChannel::TChannel( TGCompositeFrame *p, int ch){

        //--- layout for the frame: place at bottom, right aligned

        fBfly1 = new TGLayoutHints(kLHintsTop | kLHintsCenterX, 5, 5, 5, 5);

        fBfly2 = new TGLayoutHints(kLHintsTop | kLHintsLeft,    5, 5, 5, 5);

        fBfly3 = new TGLayoutHints(kLHintsTop | kLHintsRight,   5, 5, 5, 5);

        fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);

        TGVerticalFrame *fHframe1 = new TGVerticalFrame(p, 0, 0, 0);

        TGHorizontalFrame * fThresholdFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);

        //TGLabel *fLChannel = new TGLabel(fThresholdFrame, tmp);

        TGLabel *fLThreshold = new TGLabel(fThresholdFrame, "Threshold:");

        fThresholdSlider = new TGTripleHSlider(fThresholdFrame, 190, kDoubleScaleBoth, VSId1,

                                               kHorizontalFrame,

                                               p->GetDefaultFrameBackground(),

                                               kFALSE, kFALSE, kFALSE, kFALSE);

        fThresholdSlider->Connect("PointerPositionChanged()", "TChannel",  this, "DoSlider()");

        fThresholdSlider->Connect("PositionChanged()", "TChannel", this, "DoSlider()");

        fThresholdSlider->SetRange(-1,1);

        //fThresholdFrame->AddFrame(fLChannel, fBfly2);

        fThresholdFrame->AddFrame(fLThreshold, fBfly2);

        fThresholdFrame->AddFrame(fThresholdSlider, fBly);

        TGHorizontalFrame * fTimeWinFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);

        fEdge = new TGCheckButton(fTimeWinFrame, "&Positive Edge", HCId2);

        fEdge->SetState(kButtonUp);

        fEdge->SetToolTipText("Pointer position relative to slider position");

        TGLabel *fLTiming = new TGLabel(fTimeWinFrame, "Time Window:");

        fTimingSlider = new TGTripleHSlider(fTimeWinFrame, 190, kDoubleScaleBoth, HSId1,

                                            kHorizontalFrame,

                                            p->GetDefaultFrameBackground(),

                                            kFALSE, kFALSE, kFALSE, kFALSE);

        fTimingSlider->Connect("PointerPositionChanged()", "TChannel",  this, "DoSlider()");

        fTimingSlider->Connect("PositionChanged()", "TChannel", this, "DoSlider()");

        fTimingSlider->SetRange(0,200);

        fHframe1->Resize(200, 25);

        fEdge->Connect("Clicked()", "TChannel", this,

                       "HandleButtons()");

        fTimeWinFrame->AddFrame(fEdge, fBfly2);

        fTimeWinFrame->AddFrame(fLTiming, fBfly2);

        fTimeWinFrame->AddFrame(fTimingSlider, fBly);

        fHframe1->AddFrame(fThresholdFrame, fBly);

        fHframe1->AddFrame(fTimeWinFrame, fBly);

        TGHorizontalFrame *fNumbersFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);

        for (int i=0; i<7; i++)

                fTeh[i] = new TGTextEntry(fNumbersFrame, fTbh[i] = new TGTextBuffer(5), HId1+i);

        fTeh[0]->SetToolTipText("Minimum (left) Value of Slider");

        fTeh[1]->SetToolTipText("Pointer Position Value");

        fTeh[2]->SetToolTipText("Maximum (right) Value of Slider");

        fTeh[3]->SetToolTipText("Signal Cut 0");

        fTeh[4]->SetToolTipText("Signal Threshold");

        fTeh[5]->SetToolTipText("Signal Cut 1");

        fTeh[6]->SetToolTipText("Constant Fraction Ratio");

        for (int i=0; i<7; i++) {

                fTbh[i]->AddText(0, "0.0");

                fTeh[i]->Connect("TextChanged(char*)", "TChannel", this,

                                 "DoText(char*)");

        }

        fNumbersFrame->Resize(100, 25);

        for (int i=0; i<7; i++) { fNumbersFrame->AddFrame(fTeh[i], fBfly2); }

        fHframe1->AddFrame(fNumbersFrame, fBly);

        p->AddFrame(fHframe1, fBly);

        fTimingSlider->SetPosition(60,120);

        fTimingSlider->SetPointerPosition(65);

        fThresholdSlider->SetPosition(-0.5,0.5);

        fThresholdSlider->SetPointerPosition(0.25);

        char buf[32];

        sprintf(buf, "%.3f", fTimingSlider->GetMinPosition());

        fTbh[0]->Clear();

        fTbh[0]->AddText(0, buf);

        sprintf(buf, "%.3f", fTimingSlider->GetPointerPosition());

        fTbh[1]->Clear();

        fTbh[1]->AddText(0, buf);

        sprintf(buf, "%.3f", fTimingSlider->GetMaxPosition());

        fTbh[2]->Clear();

        fTbh[2]->AddText(0, buf);

        sprintf(buf, "%.3f", fThresholdSlider->GetMinPosition());

        fTbh[3]->Clear();

        fTbh[3]->AddText(0, buf);

        sprintf(buf, "%.3f", fThresholdSlider->GetPointerPosition());

        fTbh[4]->Clear();

        fTbh[4]->AddText(0, buf);

        sprintf(buf, "%.3f", fThresholdSlider->GetMaxPosition());

        fTbh[5]->Clear();

        fTbh[5]->AddText(0, buf);

        sprintf(buf, "0.25");

        fTbh[6]->Clear();

        fTbh[6]->AddText(0, buf);

}

class TDrsGui: public TGMainFrame {

private:

        TGLayoutHints       *fLcan;

        TGComboBox *fTrgch;

        TGVerticalFrame   *fHframe0;

        TGTextButton *fStart;

        TGTextButton *fSelect;

        TGTextEntry *fFile;

        TGNumberEntry *fNeve;

        TGNumberEntry *fUpdFrq;

        TGTextBuffer        *fFileText;

        TChannel * fChannel[4];

        TGLayoutHints       *fBly;

public:

        TDrsGui();

        virtual ~TDrsGui();

        void CloseWindow();

        void StartAnalysis();

        void HandleAction();

        void LoadIni();

        ClassDef(TDrsGui, 0)

};

void TDrsGui::StartAnalysis(){

        const int nch=4;

        DrsChannel c[nch];

        for (int i=0; i<nch; i++) {

                c[i].cfrac = atof(fChannel[i]->fTbh[6]->GetString());

                c[i].threshold = atof( fChannel[i]->fTbh[4]->GetString());

                c[i].twin[0] = atof( fChannel[i]->fTbh[0]->GetString());

                c[i].twin[1] = atof( fChannel[i]->fTbh[2]->GetString());

                c[i].adcgate[0] = atof( fChannel[i]->fTbh[1]->GetString());;

                c[i].adcgate[1] = c[i].adcgate[0] + c[i].twin[1]-c[i].twin[0];

                c[i].vcut[0] = atof( fChannel[i]->fTbh[3]->GetString());

                c[i].vcut[1] = atof( fChannel[i]->fTbh[5]->GetString());

                c[i].edge = fChannel[i]->fEdge->GetState();

                printf("Ch.%d :",i);

                for (int j=0; j<7; j++) printf("\t%f", atof( fChannel[i]->fTbh[j]->GetString()));

                printf("%d\n", fChannel[i]->fEdge->GetState() );

        }

        printf("File: %s\n", fFileText->GetString()  );

        int nev=fNeve->GetIntNumber();

        int updfrq=fUpdFrq->GetIntNumber();;

        int trgch=fTrgch->GetSelected();

        drs * d = new drs(fFileText->GetString(), nch, c, trgch, nev, updfrq  );

}

void TDrsGui::LoadIni(){

        static TString dir(".");

        TGFileInfo fi;

        fi.fFileTypes = filetypesini;

        fi.fIniDir    = StrDup(dir);

        printf("fIniDir = %s\n", fi.fIniDir);

        new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);

        printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);

        dir = fi.fIniDir;

        FILE *fp= fopen(fi.fFilename,"r");

        float f[10];

        int j=0;

        const int ndim=400;

        char line[ndim];

        int edge=0;

        int ch=0;

        float cfrac=1;

        while (fgets(line,ndim,fp)!=NULL) {

                if (line[0]=='#' ) continue;

                printf("%d***********\n",j++);

                sscanf(line,"%d%d%f%f%f%f%f%f%f",&ch,&edge,&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6]);

                printf("%d\t%d\t",ch, edge);

                for (int i=0; i<7; i++) {

                        char buf[20];

                        sprintf(buf, "%.3f", f[i]);

                        fChannel[ch]->fTbh[i]->Clear();

                        fChannel[ch]->fTbh[i]->AddText(0, buf);

                        fChannel[ch]->fTeh[i]->SetCursorPosition(fChannel[ch]->fTeh[i]->GetCursorPosition());

                        fChannel[ch]->fTeh[i]->Deselect();

                        gClient->NeedRedraw(fChannel[ch]->fTeh[i]);

                        printf("%2.2f\t",f[i]);

                }

                if (!edge) fChannel[ch]->fEdge->SetState(kButtonUp);

                else fChannel[ch]->fEdge->SetState(kButtonDown);

                printf("\n");

        }

        fclose(fp);

}

void TDrsGui::HandleAction(){

        static TString dir(".");

        TGFileInfo fi;

        fi.fFileTypes = filetypesdat;

        fi.fIniDir    = StrDup(dir);

        printf("fIniDir = %s\n", fi.fIniDir);

        new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);

        printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);

        dir = fi.fIniDir;

        //char buf[32];

        //sprintf(buf, "%.3f", fTimingSlider->GetMinPosition());

        fFileText->Clear();

        fFileText->AddText(0,fi.fFilename);

        /*

           fCanvas->GetCanvas()->Modified();

              fCanvas->GetCanvas()->Update();

         */

        fFile->SetCursorPosition(fFile->GetCursorPosition());

        fFile->Deselect();

        gClient->NeedRedraw(fFile);

}

//______________________________________________________________________________

TDrsGui::TDrsGui() : TGMainFrame(gClient->GetRoot(), 100, 100)

{

        SetCleanup(kDeepCleanup);

        // Create an embedded canvas and add to the main frame, centered in x and y

        // and with 30 pixel margins all around

        /*

           fCanvas = new TRootEmbeddedCanvas("Canvas", this, 600, 400);

           fLcan = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 10, 10, 10);

           //AddFrame(fCanvas, fLcan);

           fCanvas->GetCanvas()->SetFillColor(33);

           fCanvas->GetCanvas()->SetFrameFillColor(41);

           fCanvas->GetCanvas()->SetBorderMode(0);

           fCanvas->GetCanvas()->SetGrid();

           fCanvas->GetCanvas()->SetLogy();

         */

        fHframe0 = new TGVerticalFrame(this, 0, 0, 0);

        fHframe0->Resize(200, 50);

        //--- layout for buttons: top align, equally expand horizontally

        fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);

        TGHorizontalFrame *fStartFrame = new TGHorizontalFrame(fHframe0, 0, 0, 0);

        char tmp[20];

        // combo box widget

        fTrgch = new TGComboBox(fStartFrame,50);

        for (int i = 0; i < 4; i++) {

                sprintf(tmp, "Ch %i", i);

                fTrgch->AddEntry(tmp, i);

        }

        fTrgch->Resize(50, 20);

        fTrgch->Select(0);

        TGLabel *fLTrgch = new TGLabel(fStartFrame, "Trg Channel:");

        fNeve = new TGNumberEntry(fStartFrame,  5000, 5,999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative );

        TGLabel *fLNeve = new TGLabel(fStartFrame, "Number of events:");

        fUpdFrq = new TGNumberEntry(fStartFrame,  50, 5,999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative );

        TGLabel *fLUpdFrq = new TGLabel(fStartFrame, "Update Frequency:");

        fStartFrame->AddFrame(fLTrgch, fBly);

        fStartFrame->AddFrame(fTrgch, fBly);

        fStartFrame->AddFrame(fLNeve, fBly);

        fStartFrame->AddFrame(fNeve, fBly);

        fStartFrame->AddFrame(fLUpdFrq, fBly);

        fStartFrame->AddFrame(fUpdFrq, fBly);

        fHframe0->AddFrame(fStartFrame, fBly);

        TGHorizontalFrame *fH = new TGHorizontalFrame(fHframe0, 0, 0, 0);

        fStart =  new TGTextButton(fH, "Start");

        fStart->Connect("Clicked()", "TDrsGui", this, "StartAnalysis()");

        fSelect =  new TGTextButton(fH, "Select Analysis File");

        fSelect->Connect("Clicked()", "TDrsGui", this, "HandleAction()");

        fFile = new TGTextEntry(fH, fFileText = new TGTextBuffer(5), 1);

        TGTextButton * fLoadIni =  new TGTextButton(fH, "Load Ini File");

        fLoadIni->Connect("Clicked()", "TDrsGui", this, "LoadIni()");

        fH->AddFrame(fSelect, fBly);

        fH->AddFrame(fFile, fBly);

        fH->AddFrame(fLoadIni, fBly);

        fH->AddFrame(fStart, fBly);

        fHframe0->AddFrame(fH, fBly);

        AddFrame(fHframe0, fBly);

        //--------- create the Tab widget

        TGTab *fTab = new TGTab(fHframe0, 300, 300);

        TGLayoutHints *fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);

        for (int ich=0; ich<4; ich++) {

                char tmp[255];

                sprintf(tmp,"Channel %d:",ich);

                TGCompositeFrame *tf = fTab->AddTab(tmp);

                fChannel[ich]= new TChannel( tf, ich);

        }

        fHframe0->AddFrame(fTab, fBly);

        // Set main frame name, map sub windows (buttons), initialize layout

        // algorithm via Resize() and map main frame

        SetWindowName("DRS Analysis");

        MapSubwindows();

        Resize(GetDefaultSize());

        MapWindow();

}

//______________________________________________________________________________

TDrsGui::~TDrsGui()

{

        // Clean up

        Cleanup();

}

//______________________________________________________________________________

void TDrsGui::CloseWindow()

{

        // Called when window is closed via the window manager.

        delete this;

}

//______________________________________________________________________________

void TChannel::DoText(const char * /*text*/)

{

        // Handle text entry widgets.

        TGTextEntry *te = (TGTextEntry *) gTQSender;

        Int_t id = te->WidgetId();

        switch (id) {

        case HId1:

                fTimingSlider->SetPosition(atof(fTbh[0]->GetString()),

                                           fTimingSlider->GetMaxPosition());

                break;

        case HId2:

                fTimingSlider->SetPointerPosition(atof(fTbh[1]->GetString()));

                break;

        case HId3:

                fTimingSlider->SetPosition(fTimingSlider->GetMinPosition(),

                                           atof(fTbh[2]->GetString()));

                break;

        case VId1:

                fThresholdSlider->SetPosition(atof(fTbh[3]->GetString()),

                                              fThresholdSlider->GetMaxPosition());

                break;

        case VId2:

                fThresholdSlider->SetPointerPosition(atof(fTbh[4]->GetString()));

                break;

        case VId3:

                fThresholdSlider->SetPosition(fThresholdSlider->GetMinPosition(),

                                              atof(fTbh[5]->GetString()));

                break;

        default:

                break;

        }

        /*

           fCanvas->GetCanvas()->Modified();

           fCanvas->GetCanvas()->Update();

         */

}

//______________________________________________________________________________

void TChannel::DoSlider()

{

        // Handle slider widgets.

        char buf[32];

        float values[6]={

                fTimingSlider->GetMinPosition(),fTimingSlider->GetPointerPosition(),fTimingSlider->GetMaxPosition(),

                fThresholdSlider->GetMinPosition(),fThresholdSlider->GetPointerPosition(),fThresholdSlider->GetMaxPosition()

        };

        for (int i=0; i<6; i++) {

                sprintf(buf, "%.3f", values[i]);

                fTbh[i]->Clear();

                fTbh[i]->AddText(0, buf);

                fTeh[i]->SetCursorPosition(fTeh[i]->GetCursorPosition());

                fTeh[i]->Deselect();

                gClient->NeedRedraw(fTeh[i]);

        }

        /*

           fCanvas->GetCanvas()->Modified();

           fCanvas->GetCanvas()->Update();

         */

}

//______________________________________________________________________________

void TChannel::HandleButtons()

{

        // Handle different buttons.

        TGButton *btn = (TGButton *) gTQSender;

        Int_t id = btn->WidgetId();

        switch (id) {

        case HCId1:

                // fTimingSlider->SetConstrained(fTrigger->GetState());

                break;

        case HCId2:

                fTimingSlider->SetRelative(fEdge->GetState());

                break;

        default:

                break;

        }

}

void drsgui()

{

        new TDrsGui();

}