DigiSignal.h

Go to the documentation of this file.

#ifndef DIGISIGNAL_H
#define DIGISIGNAL_H

#include <TObject.h>
#include <TRef.h>
#include <map>
#include <vector>
#include <iostream>
#include "DigiScintHit.h"

class DigiPE;

class DigiSignal : public TObject
{
 public:
  enum EDigiPmtTruth {
    kUnknown          = 0x00,   // Can happen: known cause is 0 charge
                                // but random noise passes sparsification thresh.
    kGenuine          = 0x01,   // A real hit from real gosh-darn physics.
    kDarkNoise        = 0x02,   // Dark noise from the tube.
    kFibreLight       = 0x04,   // Random [singles] from a fibre. 
    kCrosstalk        = 0x08,   // A generic crosstalk hit.
    kCrosstalkOptical = 0x10,   // A crosstalk hit, specifically from
    kLeakFromNextBucket = 0x20,  // The next bucket leaked charge back to this one
    kLeakFromPrevBucket = 0x40,  // The prev bucket leaked charge forward to this one
    kAfterpulse         = 0x80   // This PE is an afterpulse
  };
  
  typedef Int_t                                 DigiPmtTruth_t;
  typedef std::vector<const DigiPE*>            PEList_t;
  typedef std::vector<TRef>                     HitList_t;
  typedef std::vector<Float_t>                  HitWeightList_t;

  DigiSignal();
  DigiSignal( Float_t charge, 
              PEList_t& pes,
              HitList_t& hits,
              HitWeightList_t& weights,
              DigiPmtTruth_t truth);
  DigiSignal( const DigiSignal& rhs );
  ~DigiSignal();

  // Getters.
  UInt_t               GetId()     const { return fSignalId; };
  Double_t             GetCharge() const { return fCharge; }; // in Munits
  const PEList_t&      GetPes()    const { return fPes; };
  const DigiPmtTruth_t GetTruth()  const { return fTruth; };

  // Some more pedantic get routines, to make code more readable.
  Int_t                GetNumPe()  const { return fNumPe; };

  UInt_t               GetNumberOfHits() const;
  const DigiScintHit*  GetHit( UInt_t hit ) const;
  Float_t              GetHitWeight( UInt_t hit ) const;
  Float_t              GetTotalHitWeight() const;
  const DigiScintHit*  GetBiggestHit() const;

  // Setters.
  void SetCharge(Double_t charge)         { fCharge = charge; };
  void AddDigiPE(const DigiPE* digipe); // Adds hits from the PE as well as the PE itself.
  void AddHit(const DigiScintHit* hitptr, Double_t weight = 0);  // Add just a hit.
  void SetTruth( DigiPmtTruth_t in)       { fTruth = in; };
  void SetTruthBit( DigiPmtTruth_t in )   { fTruth |= in; };
  void ClearTruthBit( DigiPmtTruth_t in ) { fTruth &= ( 0xFFFF - in ); };
  void Merge( DigiSignal& other) ; // Adds the other digiSignal to this one.

  // Printing.
  virtual void               Print(Option_t* option = "") const;
  virtual const char*        AsString(Option_t* option = "") const;
  friend  std::ostream& operator<<(std::ostream& os, const DigiSignal& s);
  virtual std::ostream&      FormatToOStream(std::ostream& os,
                                             Option_t *option="") const;

 private:  
  UInt_t         fSignalId;
  Float_t        fCharge; // in fC.
  PEList_t       fPes; // ! Temporary storage only
  Int_t          fNumPe;
  HitList_t       fHits;
  HitWeightList_t fHitWeights;
  DigiPmtTruth_t fTruth;  

  ClassDef(DigiSignal,4);
};


// Utility functions:
const char* AsString(DigiSignal::DigiPmtTruth_t truth);


// Inlines:
inline UInt_t
DigiSignal::GetNumberOfHits() const
{ 
  return fHits.size(); 
}

inline const DigiScintHit*  
DigiSignal::GetHit( UInt_t hit ) const
{ 
  return dynamic_cast<const DigiScintHit*>(fHits[hit].GetObject());
}

inline Float_t
DigiSignal::GetHitWeight( UInt_t hit ) const 
{
  return fHitWeights[hit];
}

inline Float_t
DigiSignal::GetTotalHitWeight( ) const
{
  return (Float_t) GetNumPe();
}



inline const DigiScintHit*
DigiSignal::GetBiggestHit() const
{ 
  UInt_t n = fHits.size();
  if(n==0) return 0;
  float biggest_weight = fHitWeights[0];
  UInt_t index =0;
  for(UInt_t i=0; i<n; i++) {
    if(fHitWeights[i] > biggest_weight) index = i;
  }

  return GetHit(index);
}


#endif

---