tests/src/DisplayTrack.cpp

Go to the documentation of this file.

#include "TH3F.h"
#include "MapsTrackManager.hh"
#include "MapsTrack.hh"
#include "MapsSensor.hh"
#include "MapsException.hh"
#include <cmath>
#include <vector>
#include "TRandom2.h"
#include "TFile.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TApplication.h"
#include "TCanvas.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TThread.h"
#include "TStyle.h"
#include "TPaveText.h"
#include "TText.h"
#include "ToString.h"
#include "TVirtualViewer3D.h"
#include "TGeoBBox.h"
#include "Rtypes.h"
#include "TVirtualGeoPainter.h"
#include "TGLViewer.h"
#include <signal.h>

/** DisplayTrack.cpp
 * 
 * Use this to interactively display tracks on screen. 
 * Use of ROOT's OpenGL viewer is recommended.
 * 
 * Jamie Ballin, Imperial College London
 *              February 2008
 * 
 * j.ballin06@imperial.ac.uk
 */

TApplication* theApp;
TCanvas * c;
TVirtualViewer3D* v;
TGLViewer* viewer;

bool continueJob=true;

void signalHandler(int signal) {
        std::cerr << "Process "<< getpid() << " received signal "<< signal
                        << std::endl;
        continueJob=false;
}

void startSender(void* inA) {
        MapsTrackManager mtm2;
        char* input = static_cast<char*>(inA);
        mtm2.recreateFromRootFile(input);

        TH3F
                        * disp =
                                        new TH3F("hDisplay", "Event display;x;y;z", 100, -5.0, 5.0, 100, -5.0, 5.0, 64, 0, 64);
        disp->SetMarkerColor(2);
        disp->SetMarkerStyle(22);
        disp->SetMarkerSize(2.0);

        std::cout << "Iterating..." << std::endl;
        std::vector<MapsTrack*>& tracks = mtm2.getTracks();

        for (std::vector<MapsTrack*>::iterator it = tracks.begin(); it
                        != tracks.end(); it++) {
                MapsTrack* t = *it;
                t->eraseGlobalHits();
                std::pair<double, double> error(0.1, 0.1);
                t->setTrackError(error);
                disp->Reset();
                

                if (t->chiSqProb(0) > 0.05 && t->chiSqProb(1) > 0.05 && t->getHits().size() == 4) {
                        std::map<MapsSensor*, MapsSensor::physXY > hits =
                                        t->getGlobalHits();
                        diagnose(std::cout, *t);

                        for (std::map<MapsSensor*, MapsSensor::physXY >::const_iterator h =
                                        hits.begin(); h != hits.end(); ++h) {
                                MapsSensor::physXY theHit = (*h).second;
                                disp->Fill(theHit.first, theHit.second, (*h).first->zPosition()+1);
                        }
                        disp->Draw("ogl");
                        TPaveText tp(0.1, 0.1, 0.4, 0.4);
                        tp.AddText("Track diagnosis");
                        tp.AddText(("p_{x} = " + toString(t->chiSqProb(0))).c_str());
                        tp.AddText(("p_{y} = " + toString(t->chiSqProb(1))).c_str());
                        tp.AddText(("#theta = " + toString(t->theta())).c_str());
                        tp.Draw("ogl");
                        c->Modified();
                        c->Update();

                        std::cout << "Hit return to display next...\n";
                        std::string input;
                        std::getline(std::cin, input);

                }
        }

        std::cout << "Finished displaying events. Ctrl-C me. \n";
}

int main(int argc, const char **argv) {

        for (int d(0); d < argc; d++) {
                std::cout << argv[d] << "\n";
        }
        if (argc != 2) {
                std::cout << "Usage: DisplayTrack <input file>\n";
                return 0;
        }

        signal(SIGINT, signalHandler);
        signal(SIGTERM, signalHandler);

        std::cout << "Recreating from root file...\n";
        char input[100];
        strcpy(input, argv[1]);

        //mtm2.recreateFromRootFile(input);
        std::cout << "Constructing ROOT application..." << std::endl;
        theApp = new TApplication("App", 0, 0);
        gROOT->Reset();
        gStyle->SetCanvasPreferGL(kTRUE);
        gStyle->SetPalette(1);

        std::cout << "Starting worker thread..." << std::endl;

        c = new TCanvas("c", "The Hello Canvas", 600, 600);

        TThread* guiTh = new TThread("guiTh", startSender, input);
        guiTh->Run();

        std::cout << "Starting gui..." << std::endl;
        while (!gSystem->ProcessEvents() && continueJob) {
                //c->Modified();
                //c->Update();
        }

        std::cout << "Terminating..." << std::endl;

        delete guiTh;
        delete theApp;
}

---