source: JEM-EUSO/esaf_cc_at_lal/packages/simulation/detector/tools/include/PixelEffMapBuilder.hh @ 114

// $Id$
// Author: Dmitry V.Naumov   2011/04/27

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

#ifndef __PIXELEFFMAPBUILDER_HH__
#define __PIXELEFFMAPBUILDER_HH__

#include "euso.hh"
#include "EsafConfigurable.hh"
#include <TString.h>
#include <TObject.h>
#include <TSystem.h>

class OpticalSystem;
class IdealFocalSurface;
class Detector;
class VirtualDetectorTransportManager;
class Photon;
class EusoElectronics;
class TFile;
class TH2F;
class TCanvas;
class TTree;
class TLegend;
class TLegendEntry;
class TSeqCollection;
class TPolyLine;
class ERunParameters;
class EsafSpectrum;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// PixelEffMapBuilder                                                         //
//                                                                            //
// <brief class description>                                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

class PixelEffMapBuilder : public EsafConfigurable, public EsafMsgSource {
public:
  PixelEffMapBuilder(TString s="");
  virtual ~PixelEffMapBuilder();

  class Header : public TObject {
        public:
        Header() : fBinsThetaFoV(-1), fBinsPhiFoV(-1), fPhPerBunch(-1), fEfficiencyThreshold(0),
                   fThetaFoVMin(-1), fThetaFoVMax(-1), fPhiFoVMin(-1), fPhiFoVMax(-1), fNpixels(0),
                   fPhotonsTraced(0), fLastProcessedBinTheta(-1), fLastProcessedBinPhi(-1),
                   fAllProcessed(kFALSE), fDisplayPixels(0), fHistoLegend(0),
                   fLegendEntryPhotons(0), fLegendEntryPixels(0), fLegendEntryTheta(0), fLegendEntryPhi(0), fRunPars(0) {}
        Int_t fBinsThetaFoV;                            // number of  bins per Theta_FoV
        Int_t fBinsPhiFoV;                              // number of  bins per Phi_FoV
        Int_t fPhPerBunch;                              // number of photons per bunch
        Float_t fEfficiencyThreshold;                   // minimum allowed efficiency of pixel to be saved
        Float_t fThetaFoVMin;                           // minimum Theta_FoV
        Float_t fThetaFoVMax;                           // maximum Theta_FoV
        Float_t fPhiFoVMin;                             // minimum Phi_FoV
        Float_t fPhiFoVMax;                             // maximum Phi_FoV
        Int_t fNpixels;                                 // number of pixels hitted by photons
        Int_t fPhotonsTraced;                           // total number of traced photons
        Int_t fLastProcessedBinTheta;                   // last bin in Theta traced
        Int_t fLastProcessedBinPhi;                     // last bin in Phi traced
        Bool_t fAllProcessed;                           // true if all pixels were processed
        TH2F* fDisplayPixels;                           // histo to display pixels filling
        TLegend* fHistoLegend;                          // legend of histo (fDisplayPixels)
        TLegendEntry* fLegendEntryPhotons;              // legend about number of photons
        TLegendEntry* fLegendEntryPixels;               // legend about number of pixels
        TLegendEntry* fLegendEntryTheta;                // legend about Theta_FoV
        TLegendEntry* fLegendEntryPhi;                  // legend about Phi_FoV
        map<Int_t, TPolyLine* > fPixelLines;            // pixel's lines
        ERunParameters *fRunPars;                       // ERunParameters object
        vector <Int_t> fProcessedPixels;                // pixels with efficiency above the threshold
        map <Int_t, vector<Int_t> > fTreeMap;           // map <UID, entries in TTree>
        ClassDef(Header,1)
  };

  class PixelsMap: public TObject {
        public:
        PixelsMap() {}
        map <Int_t, TH2F*> fHiredPixels;                // map <Pixel UID, TH2F* (Theta,Phi)> at given Theta_FoV,Phi_FoV
        ClassDef(PixelsMap,1)
  };
  // this class below is used as container for the TTree with UID vs PixelHistos structure:
  // TBrach of UID
  // TBranch of PixelHistos
  class PixelHistos: public TObject {
    public:
      PixelHistos() {}
      vector <TH2F*> fEffThetaPhi;                      // vector of histos with efficiencies as functions of Theta_FoV,Phi_FoV
      ClassDef(PixelHistos,1);
  };
  Bool_t ProcessAll();
  Bool_t MakeUID_Histos_Tree();

private:
  Bool_t OpenRoot();
  Bool_t CloseRoot();
  Bool_t CheckMemory();
  Bool_t MakeHeader();
  Bool_t SaveInfo();
  Bool_t ProcessPortion(Float_t&,Float_t&,Float_t&,Float_t&);
  void   RandomPosOnLense(Double_t &, Double_t &, Double_t &);
  void   SetupLastBins(Int_t&, Int_t&);
  void   DisplayPixelsFilling(Float_t&, Float_t&);
  void   DisplayPixelsFillingPolyLine(Float_t&, Float_t&);
  TPolyLine* GetPixelLine( Int_t uid, Bool_t& drawn);

  Detector *fDetector;                        // detector
  VirtualDetectorTransportManager *fTransporter;  // photons transporter
  EusoElectronics *fElectronics;                  // electronics

  TFile*  fFile;                                  // output file
  Header* fHeader;                                // Header object to be saved into root output file
  PixelsMap* fPixelsMap;                          // map of pixels with number of entries for the given Theta,Phi
  OpticalSystem* fOpticalSystem;                  // Optical System object
  Photon* fPhoton;                                // photon object used for simulation
  TString fFileName;                              // output file name

  MemInfo_t meminfo;                              // memory usage object
  TCanvas* fCanvas;                               // canvas for histo to display pixels filling

  Int_t fThetaIndexCurrent;                       // current value of Theta_FoV index (0,fBinsThetaFoV)
  Int_t fPhiIndexCurrent;                         // current value of Phi_FoV index (0,fBinsPhiFoV)
  TTree *fTreePrompt;                             // TTree corresponding to 'prompt' problem: Light to Pixels
  EsafSpectrum* fSpectrum;                        // Fluo spectrum
  TH2F* fThetaPhiHisto;                           // histo with theta,phi within (theta,theta+delta theta) and (phi,phi + delta phi)
  ClassDef(PixelEffMapBuilder,0)
  EsafConfigClass(Tools,PixelEffMapBuilder)
};

#endif  /* __PIXELEFFMAPBUILDER_HH__ */