Universita' di GenovaINFN Sezione di Genova  
AIRWATCH / EUSO Genova

EFocalSurface3DPainter - source file

// $Id: EFocalSurface3DPainter.cc,v 1.5 2005/11/02 02:02:31 thea Exp $
// Author: Alessandro Thea   2005/07/13

/*****************************************************************************
 * ESAF: Euso Simulation and Analysis Framework                              *
 *                                                                           *
 *  Id: EFocalSurface3DPainter                                               *
 *  Package: <packagename>                                                   *
 *  Coordinator: <coordinator>                                               *
 *                                                                           *
 *****************************************************************************/

//_____________________________________________________________________________
//
// EFocalSurface3DPainter
//
// <extensive class description>
//
//   Config file parameters
//   ======================
//
//   <parameter name>: <parameter description>
//   -Valid options: <available options>
//

#include "EFocalSurface3DPainter.hh"

#include "EEvent.hh"
#include "EDetector.hh"
#include "ERunParameters.hh"
#include "EFee.hh"
#include "EPmtData.hh"
#include "ESystemOfUnits.hh"
#include "Etypes.hh"

#include <map>
#include <TPolyMarker3D.h>
#include <TPolyLine3D.h>
#include <TMath.h>
#include <TView.h>
#include <TGaxis.h>
#include <TAxis3D.h>
#include <TLatex.h>
#include <TPad.h>
#include <TPave.h>

ClassImp(EFocalSurface3DPainter)

using namespace std;
using namespace sou;
using namespace TMath;

//_____________________________________________________________________________
 EFocalSurface3DPainter::EFocalSurface3DPainter() {
    //
    // Constructor
    //

    Constructor();
}

//_____________________________________________________________________________
 EFocalSurface3DPainter::EFocalSurface3DPainter( EEvent* ev ) {
    //
    // Constructor
    //

    Constructor();
    Load(ev);
}
//_____________________________________________________________________________
 EFocalSurface3DPainter::EFocalSurface3DPainter( EDetector* det, ERunParameters* runpars ) {
    //
    // Constructor
    //

    Constructor();
    Load(det, runpars);
}
//_____________________________________________________________________________
 EFocalSurface3DPainter::~EFocalSurface3DPainter() {
    //
    // Destructor
    //

    Clear();
    SafeDelete(fSignals);
    SafeDelete(fHits);
    SafeDelete(fPixels);
}

//______________________________________________________________________________
 void EFocalSurface3DPainter::Constructor() {
    //
    //
    //

    fDetector = 0;
    fRunPars = 0;

    fAlpha           = 2.;
    fMarkerStyle     = 20;
    fMaxMarkerSize   = 2.;
    fMinMarkerSize   = .3;
    fMinMarkerColor  = 51;
    fNumMarkerColors = 50;
    fBackgroundColor = kBlack; 
    
    fDrawCode = kCodeHits;
    
    fNumMarkers     = 0;
    fNumPixels      = 0;

    fSignals = new TObjArray;
    fHits = new TObjArray;
    fPixels = new TObjArray;

    fXmin = fXmax = fYmin = fYmax = fTmin = fTmax = 0;
    fCmin = fCmax = 0;

    Int_t ndiv = 7;
    fAxis3D = new TAxis3D;
    fAxis3D->SetNdivisions(ndiv,"X");
    fAxis3D->SetNdivisions(ndiv,"Y");
    fAxis3D->SetXTitle("x [mm]");
    fAxis3D->SetYTitle("y [mm]");
    fAxis3D->SetZTitle("t [#mus]");
    fAxis3D->GetXaxis()->SetTitleColor(kWhite);
    fAxis3D->GetXaxis()->SetTitleOffset(1.5);
    fAxis3D->GetXaxis()->SetTitleFont(42);
    fAxis3D->GetXaxis()->SetLabelFont(52);
    fAxis3D->GetYaxis()->SetTitleColor(kWhite);
    fAxis3D->GetYaxis()->SetTitleOffset(1.5);
    fAxis3D->GetYaxis()->SetTitleFont(42);
    fAxis3D->GetYaxis()->SetLabelFont(52);
    fAxis3D->GetZaxis()->SetTitleColor(kWhite);
    fAxis3D->GetZaxis()->SetTitleOffset(1.5);
    fAxis3D->GetZaxis()->SetTitleFont(42);
    fAxis3D->GetZaxis()->SetLabelFont(52);

    fLabel = new TLatex;
    fLabel->SetNDC();
    fLabel->SetTextColor(kWhite);
    fLabel->SetTextFont(42);

    fAxis = new TGaxis;
    fAxis->SetLineColor(kWhite);
    fAxis->SetLineWidth(2);
    fAxis->SetLabelColor(kWhite);
    fAxis->SetLabelFont(52);
    fAxis->SetTitle("Counts");
    fAxis->SetTitleOffset(0.);
    fAxis->SetTextColor(kWhite);
    fAxis->SetTextFont(52);

}

//______________________________________________________________________________
 void EFocalSurface3DPainter::Clear( Option_t* opt  ) {
    //
    // Clear
    //

    if ( fSignals ) fSignals->Clear();
    if ( fHits ) fHits->Delete();
    if ( fPixels ) fPixels->Delete();
}

//______________________________________________________________________________
 void EFocalSurface3DPainter::Load( EEvent* ev ) {

    if ( !ev ) {
        Info("EFocalSurface3DPainter","Event is not defined. Painter made zombie.");
        MakeZombie();
        return;
    }
    
    Load(ev->GetDetector(), ev->GetRunPars());
}

//______________________________________________________________________________
 void EFocalSurface3DPainter::Load( EDetector* det, ERunParameters* runpars) {

    if ( !det || !runpars ) {
        Info("EFocalSurface3DPainter","Either Event or RunParameters is not defined. Painter made zombie.");
        MakeZombie(); 
        return;
    }

    fDetector = det;
    fRunPars = runpars;

    Int_t numPoints = 0;
    fCmax = -kMaxInt;
    fCmin =  kMaxInt;
    Double_t thres = 0;
    fMeanThres = 0;

    std::map<Int_t,Int_t> pixels;
    TPolyLine3D* px;

   if ( !fDetector->GetNumFee() ) {
        Info("Load","No EFee in EDetector object. Painter made zombie.");
        MakeZombie();
        return;
    }

    for(Int_t i(0); i<det->GetNumFee(); i++) {
        EFee *dfee = det->GetFee(i);
        Int_t uid =  dfee->GetChUId();
        Double_t rate = runpars->GetNightGlowRateByUId(uid)/microsecond
            *runpars->GetPmtData().GetGtuLength();

        Int_t nCounts;
        switch ( fDrawCode ) {
            case kCodeSigs:
                thres = 0;
                nCounts = dfee->GetNumSignals();
                break;
            case kCodeHits:
            default:
                thres = rate+fAlpha*Sqrt(rate);
                nCounts = dfee->GetNumHits()-Nint(Ceil(thres));
                break;
        }
        fMeanThres += thres/det->GetNumFee();

        if ( nCounts > 0 ) {

            numPoints++;

            fCmin = Min(fCmin,nCounts);
            fCmax = Max(fCmax,nCounts);

            if ( !pixels.count(uid) )
                pixels[uid] = 0;



            pixels[uid] += nCounts;
        }
    }

    TPolyMarker3D* p;// = new TPolyMarker3D(numSig);

    fXmin = fYmin = fTmin = kHuge;
    fXmax = fYmax = fTmax = -kHuge;


    TVector3 pos;
    for(Int_t i(0); i<det->GetNumFee(); i++) {
        EFee *dfee = det->GetFee(i);
        Int_t uid =  dfee->GetChUId();
        Double_t rate = runpars->GetNightGlowRateByUId(uid)/microsecond
            *runpars->GetPmtData().GetGtuLength();

        Int_t nCounts, nSignals;
        switch ( fDrawCode ) {
            case kCodeSigs:
                thres = 0;
                nCounts = nSignals = dfee->GetNumSignals();
                break;
            case kCodeHits:
            default:
                thres = rate+fAlpha*Sqrt(rate);
                nCounts = dfee->GetNumHits()-Nint(Ceil(thres));
                nSignals = dfee->GetNumSignals();
                break;
        }

        if ( nCounts > 0 ) {
            Double_t time =  2.5*dfee->GetGtu();
            pos = runpars->PixelCenter(uid);

            p = new TPolyMarker3D(1,fMarkerStyle);
            p->SetPoint(0,pos.X(),pos.Y(),time);
            fHits->Add(p);
            if ( nSignals )
                fSignals->Add(p);



            Float_t size = fMinMarkerSize+(fMaxMarkerSize-fMinMarkerSize)*
                (nCounts-fCmin)/(Float_t)(fCmax-fCmin);
            Color_t color = (Color_t)(fMinMarkerColor+((fNumMarkerColors-1)*
                        (nCounts-fCmin)/(Float_t)(fCmax-fCmin)));

            p->SetMarkerSize(size);
            p->SetMarkerColor(color);

            fXmin = Min(fXmin, pos.X());
            fYmin = Min(fYmin, pos.Y());
            fTmin = Min(fTmin, time);
            fXmax = Max(fXmax, pos.X());
            fYmax = Max(fYmax, pos.Y());
            fTmax = Max(fTmax, time);
        }
    }

    map<Int_t,Int_t>::iterator it;
    for(it = pixels.begin(); it != pixels.end(); it++){

        Double_t x[5], y[5], z[5];
        for(Int_t iCorner(0); iCorner<4; iCorner++){
            TVector3 dummy = runpars->PixelCorner(it->first,iCorner);
            x[iCorner] = dummy.X();
            y[iCorner] = dummy.Y();
            z[iCorner] = fTmin;

        }
        x[4] = x[0];
        y[4] = y[0];
        z[4] = z[0];

        px = new TPolyLine3D(5,x,y,z);
        px->SetBit(kCanDelete);
        px->SetLineColor(kWhite);
        fPixels->Add(px);
    }

    const EPmtData& data = fRunPars->GetPmtData();

    if ((fXmax-fXmin) < data.GetPadSide()) {
        Double_t x = (fXmax-fXmin)/2.;
        fXmax = x+data.GetPadSide();
        fXmin = x-data.GetPadSide();
    }

    if ((fYmax-fYmin) < data.GetPadSide()) {
        Double_t y = (fYmax-fYmin)/2.;
        fYmax= y+data.GetPadSide();
        fYmin = y-data.GetPadSide();
    }

    if ((fTmax-fTmin) < data.GetGtuLength()/microsecond) {
        Double_t t = (fTmax-fTmin)/2.;
        fTmax = t+data.GetGtuLength()/microsecond;
        fTmin = t-data.GetGtuLength()/microsecond;
    }

}



//______________________________________________________________________________
 void EFocalSurface3DPainter::Draw( Option_t* option ) {
    
    TString opt(option);

   Bool_t has_pad = (gPad==0)?kFALSE:kTRUE;
    if (!gPad) {
        if (!gROOT->GetMakeDefCanvas()) return;
        (gROOT->GetMakeDefCanvas())();
    }

    if ( !opt.Contains("same")) gPad->Clear();

    AppendPad(option);

    TView *view = gPad->GetView();
    if (!view) {
        view = new TView(11);
//        view->SetAutoRange(kTRUE);
//        Paint("range");
//        view->SetAutoRange(kFALSE);
    }

    view->SetRange(fXmin,fYmin,fTmin,fXmax,fYmax,fTmax);
    gPad->SetFillColor(fBackgroundColor);

    if ( has_pad) gPad->Modified();

    if (!view->IsPerspective()) view->SetPerspective();

//    fAxis3D->Draw();

}
//______________________________________________________________________________;
 void EFocalSurface3DPainter::Paint( Option_t* ) {

    if ( IsModified() ) Update();
    
    TView *view = gPad->GetView();
    if (!view) {
        view = new TView(11);
//        view->SetAutoRange(kTRUE);
//        Paint("range");
//        view->SetAutoRange(kFALSE);
        view->SetRange(fXmin,fYmin,fTmin,fXmax,fYmax,fTmax);
        if (!view->IsPerspective()) view->SetPerspective();

    }

    // background
    TPave pave;
    pave.SetBorderSize(0);
    pave.SetFillColor(fBackgroundColor);
    pave.PaintPave(gPad->GetUxmin(),gPad->GetUymin(),gPad->GetUxmax(),gPad->GetUymax());

    TIter nextPx(fPixels); 
    TIter nextMk(fHits); 

    while ( TObject* obj = nextPx()) obj->Paint();
    while ( TObject* obj = nextMk()) obj->Paint();

    fLabel->SetText(0.05,0.05,Form("Average Treshold %.3f",fMeanThres));
    fLabel->Paint();

    Double_t pXmin = 0.83*(gPad->GetUxmax()-gPad->GetUxmin())+gPad->GetUxmin(); 
    Double_t pXmax = 0.88*(gPad->GetUxmax()-gPad->GetUxmin())+gPad->GetUxmin();
    Double_t pYmin = 0.1*(gPad->GetUymax()-gPad->GetUymin())+gPad->GetUymin(); 
    Double_t pYmax = 0.9*(gPad->GetUymax()-gPad->GetUymin())+gPad->GetUymin();

    Double_t cmin, cmax;
    cmin = fCmin;
    cmax = fCmax;
    Int_t ndiv = 10;

    fAxis->PaintAxis(pXmax,pYmin,pXmax,pYmax,cmin,cmax,ndiv,"+L");

    Float_t w = (pXmax-pXmin);
    Float_t h = (pYmax-pYmin)/fNumMarkerColors;

    for( Int_t i(0); i < fNumMarkerColors; i++) {
        pave.SetFillColor(i+fMinMarkerColor); 
        pave.PaintPave(pXmax-w,pYmin+i*h,pXmax,pYmin+(i+1)*h,0);
    }

    fAxis3D->Paint();


}


//______________________________________________________________________________
 void EFocalSurface3DPainter::Update() {
    Clear();
    Load( fDetector, fRunPars );

    Modified(kFALSE);
}

//______________________________________________________________________________
 Int_t EFocalSurface3DPainter::DistancetoPrimitive(Int_t px, Int_t py) {
    //
    //
    //
    
    Int_t dist = 999999;

    TIter nextMk(fSignals);
    while(TObject* obj = nextMk() )
        dist = Min(dist,obj->DistancetoPrimitive(px,py));

    TIter nextPx(fPixels);
    while(TObject* obj = nextPx() )
        dist = Min(dist,obj->DistancetoPrimitive(px,py));
    
    return dist;
}

About Us | EUSO Official Website | Web pages created by Roberto Pesce and Alessandro Thea - Last Update Wed Nov 16 16:57:39 2005 Wed Nov 16 16:29:22 2005