BmnSsdModule.h

Go to the documentation of this file.

 
#ifndef BMNSSDMODULE_H
#define BMNSSDMODULE_H 1
 
 
#include <map>
#include <set>
#include <vector>
#include "TF1.h"
#include "TRandom.h"
#include "BmnSsdCluster.h"
#include "BmnSsdDigi.h"
#include "BmnSsdSignal.h"
#include "BmnSsdElement.h"
#include "BmnSsdSensor.h"
 
class TClonesArray;
class BmnSsdPhysics;
 
 
class BmnSsdModule : public BmnSsdElement
{
 
  public:
 
 
    BmnSsdModule(UInt_t address = 0, TGeoPhysicalNode* node = nullptr,
                 BmnSsdElement* mother = nullptr);
 
 
    // Copy constructor and assignment operator not allowed
    BmnSsdModule(const BmnSsdModule&) = delete;
    BmnSsdModule& operator=(const BmnSsdModule&) = delete;
 
 
    virtual ~BmnSsdModule();
 
 
    Double_t AdcToCharge(UShort_t adcChannel);
 
 
    void AddCluster(BmnSsdCluster* cluster) { fClusters.push_back(cluster); }
 
 
    void AddSignal(UShort_t channel, Double_t time, Double_t charge,
                   Int_t index = 0, Int_t entry = 0, Int_t file = 0);
 
 
    void BufferStatus(Int_t& nofSignals,
                      Double_t& timeFirst, Double_t& timeLast);
 
 
    Int_t ChargeToAdc(Double_t charge);
 
 
    void ClearClusters() { fClusters.clear(); }
 
 
    Int_t FindHits(TClonesArray* hitArray, BmnEvent* event = NULL);
 
 
    static Int_t GetAddressFromName(TString name);
 
 
    Double_t GetDynamicRange() const { return fDynRange; }
 
 
    Double_t GetNoise() const { return fNoise; }
 
 
    Int_t GetNofAdcChannels() const { return fNofAdcChannels; }
 
 
    UShort_t GetNofChannels() const { return fNofChannels; };
 
 
    Int_t GetNofClusters() const { return fClusters.size(); }
 
 
    std::set<UShort_t> GetSetOfDeadChannels() const {return fDeadChannels;}
 
 
    Double_t GetTimeResolution() const { return fTimeResolution; }
 
 
    Double_t GetZeroNoiseRate() const { return fZeroNoiseRate; }
 
 
    void InitAnalogBuffer();
 
 
    Bool_t IsChannelActive(UShort_t channel) {
      return ( fDeadChannels.find(channel) == fDeadChannels.end() );
    }
 
 
    Bool_t IsSet() const { return fIsSet; }
 
 
    Int_t ProcessAnalogBuffer(Double_t readoutTime);
 
 
    void SetParameters(Double_t dynRange, Double_t threshold, Int_t nAdc,
                       Double_t timeResolution, Double_t deadTime,
                       Double_t noise, Double_t zeroNoiseRate,
                       Double_t fracDeadChannels = 0.);
 
 
    Int_t GenerateNoise(Double_t t1, Double_t t2);
 
 
    void SetDeadTime(Double_t dTime) { fDeadTime = dTime; }
 
 
    std::string ToString() const;
 
 
  private:
 
    UShort_t fNofChannels;       
    Double_t fDynRange;          
    Double_t fThreshold;         
    Int_t    fNofAdcChannels;    
    Double_t fTimeResolution;    
    Double_t fDeadTime;          
    Double_t fNoise;             
    Double_t fZeroNoiseRate;     
    Double_t fNoiseRate;         
    Bool_t   fIsSet;             
    std::set <UShort_t> fDeadChannels;    
    TF1* fNoiseCharge;        
 
    typedef std::multiset<BmnSsdSignal*, BmnSsdSignal::Before> sigset;
    std::map<UShort_t, sigset> fAnalogBuffer;
 
 
    std::vector<BmnSsdCluster*> fClusters;
 
 
    void Digitize(UShort_t channel, BmnSsdSignal* signal);
 
 
    virtual void InitDaughters();
 
 
    Int_t SetDeadChannels(Double_t percentOfDeadCh);
 
 
    ClassDef(BmnSsdModule, 2);
 
};
 
#endif /* BMNSSDMODULE_H */