KVFAZIADetector.h

 
#ifndef __KVFAZIADETECTOR_H
#define __KVFAZIADETECTOR_H
 
#include "KVDetector.h"
#include "KVSignal.h"
 
class KVFAZIADetector : public KVDetector
{
   friend class KVFAZIA;
 
    KVUniqueNameList fSignals;
 
   Int_t fBlock;
   Int_t fQuartet;
   Int_t fTelescope;
    Int_t fIdentifier;
    Int_t fIndex;
    Bool_t fIsRutherford;
 
   Double_t fQH1Threshold;
   Double_t fQ2Threshold;
   Double_t fQ3Threshold;
 
   Bool_t fIsFiredFromSignals;
 
   void init();   //initialisation method called by the constructors
   Bool_t SetProperties();
 
   Bool_t use_signal_for_raw_data_tree(const TString&) const override;
 
   KVDetectorSignal* set_psa_detector_signal_value(const TString& sig_type, const TString& psa_val, double val)
   {
      auto ds = GetDetectorSignal(Form("%s.%s",sig_type.Data(),psa_val.Data()));
      if(ds)
      {
         ds->SetValue(val);
         ds->SetFired();
      }
      else
         Warning("set_pas_detector_signal_value","%s::%s.%s signal not defined?",GetName(),sig_type.Data(),psa_val.Data());
      return ds;
   }
   KVDetectorSignal* SetFPGAEnergy(int sigid, Int_t idx /* Si: alway 0, CsI: 0=max 1=fast */, Double_t energy)
   {
 
      switch (sigid) {
         case KVSignal::kQH1:
            if (idx == 0) return set_psa_detector_signal_value("QH1","FPGAEnergy",energy);//SetQH1FPGAEnergy(energy);
            break;
         case KVSignal::kI1:
            break;
         case KVSignal::kQL1:
            break;
         case KVSignal::kQ2:
            if (idx == 0) return set_psa_detector_signal_value("Q2","FPGAEnergy",energy);//SetQ2FPGAEnergy(energy);
            break;
         case KVSignal::kI2:
            break;
         case KVSignal::kQ3:
            if (idx == 0) return set_psa_detector_signal_value("Q3","FPGAEnergy",energy);//SetQ3FPGAEnergy(energy);
            if (idx == 1) return set_psa_detector_signal_value("Q3","FastFPGAEnergy",energy);//SetQ3FastFPGAEnergy(energy);
            break;
      }
      return nullptr;
   }
   KVDetectorSignal* SetBaseLine(int sigid, Float_t baseline)
   {
 
      switch (sigid) {
         case KVSignal::kQH1:
            return set_psa_detector_signal_value("QH1","BaseLine",baseline);//SetQH1BaseLine(baseline);
            break;
         case KVSignal::kI1:
            break;
         case KVSignal::kQL1:
            break;
         case KVSignal::kQ2:
            return set_psa_detector_signal_value("Q2","BaseLine",baseline);//SetQ2BaseLine(baseline);
            break;
         case KVSignal::kI2:
            break;
         case KVSignal::kQ3:
            return set_psa_detector_signal_value("Q3","BaseLine",baseline);//SetQ3BaseLine(baseline);
            break;
      }
      return nullptr;
   }
   void SetPSAResults(const KVSignal* sig)
   {
 
      KVNameValueList psa_values;
      sig->GetPSAResults(psa_values);
      for(auto& val : psa_values)
      {
         set_psa_detector_signal_value(sig->GetType(),val.GetName(),val.GetDouble());
      }
 
   }
public:
   enum {                       //determine identification of the detector
      kSI1,
      kSI2,
      kCSI,
      kOTHER
   };
   KVFAZIADetector();
   KVFAZIADetector(const Char_t* type, const Float_t thick = 0.0);
   virtual ~KVFAZIADetector();
   void Copy(TObject& obj) const override;
   void   Clear(Option_t* opt = "") override;
   void   SetName(const char* name) override;
 
   static const Char_t* GetNewName(KVString oldname);
 
   Bool_t Fired(Option_t* opt = "any") const override;
 
   void SetSignal(TGraph* signal, const Char_t* signal_name);
   Bool_t HasSignal() const;
   KVSignal* GetSignal(const Char_t* name) const;
   KVSignal* GetSignalByType(const Char_t* type) const;
   KVSignal* GetSignal(Int_t idx) const;
   Int_t GetNumberOfSignals() const;
   const KVSeqCollection* GetListOfSignals() const;
   void ComputePSA();
 
   Int_t GetIdentifier() const
   {
      return fIdentifier;
   }
 
   Int_t GetBlockNumber() const
   {
      return fBlock;
   }
   Int_t GetIndex() const override
   {
      return fIndex;
   }
 
   Bool_t IsRutherford() const
   {
      return fIsRutherford;
   }
 
   Int_t GetQuartetNumber() const
   {
      return fQuartet;
   }
   Int_t GetTelescopeNumber() const
   {
      return fTelescope;
   }
 
   Double_t GetSetupParameter(const Char_t* parname);
 
   Int_t GetDetTag() const
   {
      return GetDetectorSignalValue("DetTag");
   }
   Int_t GetGTTag() const
   {
      return GetDetectorSignalValue("GTTag");
   }
   void SetDetTag(Int_t t)
   {
      SetDetectorSignalValue("DetTag", t);
   }
   void SetGTTag(Int_t t)
   {
      SetDetectorSignalValue("GTTag", t);
   }
 
   ClassDefOverride(KVFAZIADetector, 1) //Base class for FAZIA detector
};
 
#endif