source: JEM-EUSO/esaf_cc_at_lal/packages/simulation/detector/electronics/include/Photomultiplier.hh @ 114

// ESAF : Euso Simulation and Analysis Framework
// class PMT
// $Id: Photomultiplier.hh 2604 2006-03-20 21:51:35Z thea $
// 10-4-2001 M.P. created
// 26-3-2003 A.T. modified to become the base virtual class for all PMT
// Simulate a multi-anode pmt

#ifndef __PHOTOMULTIPLIER_HH_
#define __PHOTOMULTIPLIER_HH_

#include <vector>

#include "euso.hh"
#include "PmtSignal.hh"
#include "Photon.hh"
#include "PmtGeometry.hh"
#include "EsafConfigurable.hh"
#include "EsafMsgSource.hh"

#define MAX_PMT_CHANNELS 64

class FrontEndChip;
class MacroCell;
class ElementaryCell;

typedef Int_t ChannelUniqueId;

enum PmtState {kPmtIdle, kPmtFilling, kPmtDone };

class Photomultiplier : public EsafConfigurable, public EsafMsgSource {
protected:
    Photomultiplier( Int_t , PmtGeometry* );
public:
    virtual ~Photomultiplier();
   
    EsafConfigClass(Electronics,Photomultiplier)
       
    // return parameters for this kind of pmt
    static Double_t GetQuantum() {return fgQuantum;}
    static Double_t GetGain() {return fgGain;}
    static Double_t GetGainSigma() {return fgGainSigma;}
    static Double_t GetWidth() {return fgWidth;}
    static Double_t GetGtuLength() {return fgGtuLength;}
    static Double_t GetDarkNoiseRate() {return fgDarkNoiseRate;}

    // static reset class variables
    static void ResetClass();

    // Pmt identifier
    inline Int_t Id() const {return fId;}

    // unique id handlers
    // set first unique id associated to this pmt
    inline void SetStartUniqueId(ChannelUniqueId start) {Geometry()->SetStartUniqueId(start);}

    // get unique id for a given channel
    ChannelUniqueId GetUniqueId(Int_t ch) const;

    // get first unique id belonging to this pmt
    inline ChannelUniqueId GetStartUniqueId() const {return Geometry()->GetStartUniqueId();}

    // get last unique id belonging to this pmt
    inline ChannelUniqueId GetLastUniqueId() const {return Geometry()->GetLastUniqueId();}

    // get channel number (from 0 to pmtsize) given a unique id
    // returns -1 does not exist
    Int_t GetChannel(ChannelUniqueId id) const {return Geometry()->GetChannel(id);}

    // Pmt Status: can be kPmtIdle (after startup or reset), kPmtFilling
    // (after an Add call but before Simulate()) and kPmtDone (after Simulate)
    inline PmtState Status() const {return fState;}

    // number of PMT anodes
    virtual Int_t NumChan() const { return Geometry()->NumPads();} 

    // returns true if n is a valid channel
    // channels run from 0 to NumChan()-1
    virtual Bool_t isValid(Int_t n) const 
    { if ( n>=0 && n<NumChan() ) return kTRUE; else return kFALSE;}

    // add a photon hit
    // the information is just stored. Simulation is done in Simulate()
    // return true if a signal was generated
    // return false is photon was lost
    // TO BE UNDERSTOOD:: reflection on the photocathode ????
    virtual Bool_t Add( Photon& );

    // simulation of the photons 
    // the releated front end chip is filled with the charge
    // signals with the right amplitude and time
    void Simulate();

    // reset ( delete all hits from the internal buffer )
    virtual void Reset();

    // pointer to the attached front end chip
    inline FrontEndChip* FrontEnd() { return fFrontEnd; }

    // pointer to attached Geometry
    virtual PmtGeometry* Geometry() const { return fGeometry;}

    // set macrocell pointer
    inline void SetCell(MacroCell* c) {fCell=c;}
    inline MacroCell* Cell() {return fCell;}

    // set elementary cell pointer
    inline void SetElemCell(ElementaryCell *p) { fEC=p; }
    inline ElementaryCell* ElemCell() { return fEC; }

    // attach a FrontEnd chip to this pmt 
    void SetFrontEnd(FrontEndChip*, Int_t, Int_t );

    Int_t FEChannel(Int_t n);

    inline Bool_t IsEmpty() const {return fEmpty;}
    inline void SetEmpty(Bool_t val) { fEmpty=val; }

    // start and end time
    inline Double_t GetStartTime() const {return fStartTime;}
    inline Double_t GetEndTime() const {return fEndTime;}

    // list of signals
    inline vector<PmtSignal*>& Signals(Int_t ch) { return *(fPmtHits[ch]);}

    // physically release the memory allocated by the arrays of this object
    virtual Bool_t ClearMemory();
protected:
    PmtState fState;                         // state of the PMT 
    inline void SetState(PmtState val) {fState=val;}

    Int_t fId;                               // this pmt id number
    ChannelUniqueId fStartUniqueId;          // unique id of first channel

    map<Int_t,Int_t> fFeMap;                 // mapping between pmt and front end channels

    FrontEndChip* fFrontEnd;                 // pointer to its front end chip 
    PmtGeometry* fGeometry;                  // pointer to the geometry object
    MacroCell* fCell;                        // pointer to the macrocell
    ElementaryCell* fEC;                     // pointer to the elementary cell 

    virtual void BuildFrontEndMap(Int_t, Int_t);    // helper function to map pmt and front end

    // a map associating to each channel a vector that is a list of pointers to PmtSignals
    map<Int_t, vector<PmtSignal*>* > fPmtHits;

    Bool_t fEmpty;

    Double_t fStartTime, fEndTime;

    // add function for electronic test only
    virtual void AddTest(Double_t,Int_t);

    static Double_t fgQuantum;               // quantum efficiency
    static Double_t fgGain;                  // nominal gain
    static Double_t fgGainSigma;             // gain spread
    static Double_t fgWidth;                 // time width
    static Double_t fgDarkNoiseRate;         // darknoise [microsec^-1]
    static Double_t fgGtuLength;             // gtu length in ns

    friend class ElecTestDetTransManager;

    ClassDef(Photomultiplier,0)
};

#endif