KVMultiDetArray.h

 
#ifndef __KVMultiDetArray_H
#define __KVMultiDetArray_H
 
#include "KVGeoStrucElement.h"
#include "KVUniqueNameList.h"
#include "TGeoManager.h"
#include "KVDetector.h"
#include "KVGroupReconstructor.h"
#include "KVDetectorSignalTrace.h"
#include <KVFileReader.h>
#include <KVGeoDNTrajectory.h>
#include <KVUnownedList.h>
class KVIDGraph;
class KVTarget;
class KVTelescope;
class KVIDTelescope;
class KVReconstructedEvent;
class KVDetectorEvent;
class KVGroup;
class KVNameValueList;
class KVReconstructedNucleus;
class KVList;
class KVGeoNavigator;
class KVUpDater;
class KVRawDataReader;
#ifdef WITH_BUILTIN_GRU
class KVGANILDataReader;
#endif
#ifdef WITH_MFM
class MFMCommonFrame;
class MFMMergeFrameManager;
class KVMFMDataFileReader;
class MFMEbyedatFrame;
class MFMBufferReader;
#ifdef WITH_MESYTEC
#include "MFMMesytecFrame.h"
#endif
#endif
#ifdef WITH_PROTOBUF
class KVProtobufDataReader;
#endif
class KVExpSetUp;
class KVExpDB;
class KVDBTable;
class KVDBRun;
 
class KVMultiDetArray : public KVGeoStrucElement {
 
   friend class KVGeoImport;
   friend class KVExpSetUp;
 
protected:
 
   static Bool_t fCloseGeometryNow;
   static Bool_t fBuildTarget;
   static Bool_t fMakeMultiDetectorSetParameters;
   static Bool_t fMakeMultiDetectorPhysicsParametersOnly;
   static Int_t  fMakeMultiDetectorRunNumber;
 
    KVTarget* fTarget;
   enum {
      kIsRemoving = BIT(14),     //flag set during call to RemoveLayer etc.
      kParamsSet = BIT(15),      //flag set when SetParameters called
      kIsBuilt = BIT(16),        //flag set when Build() is called
      kIsBeingDeleted = BIT(17), //flag set when dtor is called
      kIDParamsSet = BIT(18),    //flag set when SetRunIdentificationParameters called
      kCalParamsSet = BIT(19)    //flag set when SetRunCalibrationParameters called
   };
 
    TList* fStatusIDTelescopes;
    TList* fCalibStatusDets;
 
    KVDetectorEvent* fHitGroups;
    KVSeqCollection* fIDTelescopes;
    KVUniqueNameList fFiredDetectors;
    KVUniqueNameList fExtraRawDataSignals;
    KVUnownedList fFiredSignals;
    TString fDataSet;
    UInt_t fCurrentRun;
    KVUpDater* fUpDater;
 
    Bool_t fSimMode;
 
    Int_t fFilterType;
 
    std::unique_ptr<KVGeoNavigator> fNavigator;
 
    KVUniqueNameList fTrajectories;
 
    KVNumberList fAcceptIDCodes;
    KVNumberList fAcceptECodes;
 
    TString fPartSeedCond;
 
    KVRawDataReader* fRawDataReader;
    Bool_t fHandledRawData;
 
    KVNameValueList fReconParameters;
 
   virtual void RenumberGroups();
 
   virtual void SetExpectedDetectorSignalNames();
 
   Int_t GetIDTelescopes(KVGeoDetectorNode*, KVDetector*, TCollection* list);
 
   virtual void SetIDCodeForIDTelescope(KVIDTelescope*) const
   {
   }
 
   int try_all_doubleID_telescopes(KVDetector* de, KVDetector* e, TCollection* l);
   bool try_a_doubleIDtelescope(TString uri, KVDetector* de, KVDetector* e, TCollection* l);
   bool try_upper_and_lower_doubleIDtelescope(TString uri, KVDetector* de, KVDetector* e, TCollection* l);
   int try_all_singleID_telescopes(KVDetector* d, TCollection* l);
   bool try_a_singleIDtelescope(TString uri, KVDetector* d, TCollection* l);
   bool try_upper_and_lower_singleIDtelescope(TString uri, KVDetector* d, TCollection* l);
   virtual void set_up_telescope(KVDetector* de, KVDetector* e, KVIDTelescope* idt, TCollection* l);
   virtual void set_up_single_stage_telescope(KVDetector* det, KVIDTelescope* idt, TCollection* l);
   Bool_t check_idtelescope_in_allowed_list(const TString& plugin);
 
   void CalculateReconstructionTrajectories();
   virtual void DeduceIdentificationTelescopesFromGeometry();
   void AddTrajectory(KVGeoDNTrajectory* d)
   {
      fTrajectories.Add(d);
   }
   virtual void AssociateTrajectoriesAndNodes();
   void DeduceGroupsFromTrajectories();
 
#ifdef WITH_MFM
   virtual Bool_t handle_raw_data_event_mfmfile(MFMBufferReader&);
   virtual Bool_t handle_raw_data_event_mfmmergeframe(const MFMMergeFrameManager&);
   virtual Bool_t handle_raw_data_event_mfmframe(const MFMCommonFrame&);
   virtual Bool_t handle_raw_data_event_mfmframe_ebyedat(const MFMEbyedatFrame&);
#ifdef WITH_MESYTEC
   virtual Bool_t handle_raw_data_event_mfmframe_mesytec_mdpp(const MFMMesytecMDPPFrame&);
#endif
#endif
#ifdef WITH_PROTOBUF
   virtual Bool_t handle_raw_data_event_protobuf(KVProtobufDataReader&);
#endif
#ifdef WITH_BUILTIN_GRU
   virtual Bool_t handle_raw_data_event_ebyedat(KVGANILDataReader&);
#endif
   void add_and_set_detector_signal(KVDetector* det, KVString detname, Double_t sig_data, KVString sig_type);
   template<typename TraceData>
   void add_and_set_detector_signal_trace(KVDetector* det, const std::vector<TraceData>& traces, double time_resolution)
   {
 
      auto det_signal = dynamic_cast<KVDetectorSignalTrace*>(det->GetDetectorSignal("SignalTrace"));
      if (!det_signal) {
         det_signal = det->AddDetectorSignalTrace();
      }
      det_signal->SetTrace(traces, time_resolution);
      det_signal->SetFired();
   }
 
   virtual void PerformClosedROOTGeometryOperations();
 
   virtual void copy_fired_parameters_to_recon_param_list();
 
   TString GetFileName(KVExpDB*, const Char_t* meth, const Char_t* keyw);
   std::unique_ptr<KVFileReader> GetKVFileReader(KVExpDB* db, const Char_t* meth, const Char_t* keyw);
   void ReadCalibrationFiles(KVExpDB* db);
   void ReadCalibFile(const Char_t* filename, KVExpDB* db, KVDBTable* calib_table);
   void ReadOoODetectors(KVExpDB* db);
   void ReadAbsentDetectors(KVExpDB* db);
 
   virtual void set_detector_thicknesses(const TString&);
 
public:
   void prepare_to_handle_new_raw_data();
   KVNameValueList& GetReconParameters()
   {
      return fReconParameters;
   }
   const KVNameValueList& GetReconParameters() const
   {
      return fReconParameters;
   }
   virtual void SetReconParametersInEvent(KVReconstructedEvent*) const;
   void CreateGeoManager(Double_t dx = 500, Double_t dy = 500, Double_t dz = 500)
   {
      if (!gGeoManager) {
 
         new TGeoManager(GetName(), Form("%s geometry for dataset %s", GetName(), fDataSet.Data()));
 
         TGeoMaterial* matVacuum = gGeoManager->GetMaterial("Vacuum");
         if (!matVacuum) {
            matVacuum = new TGeoMaterial("Vacuum", 0, 0, 0);
            matVacuum->SetTitle("Vacuum");
         }
         TGeoMedium* Vacuum = gGeoManager->GetMedium("Vacuum");
         if (!Vacuum) Vacuum = new TGeoMedium("Vacuum", 1, matVacuum);
         TGeoVolume* top = gGeoManager->MakeBox("WORLD", Vacuum,  dx, dy, dz);
         gGeoManager->SetTopVolume(top);
      }
 
   }
   void SetGeometry(TGeoManager*);
   TGeoManager* GetGeometry() const;
   KVGeoNavigator* GetNavigator() const;
   void SetNavigator(KVGeoNavigator* geo);
 
   enum EFilterType {
      kFilterType_Geo,
      kFilterType_GeoThresh,
      kFilterType_Full
   };
   KVMultiDetArray();
   KVMultiDetArray(const Char_t* name, const Char_t* type = "");
   virtual ~KVMultiDetArray();
 
   void SetFilterType(Int_t t)
   {
      fFilterType = t;
   }
   void init();
 
   KVGroup* GetGroup(const Char_t* name) const
   {
      return (KVGroup*)GetStructure("GROUP", name);
   }
   KVGroup* GetGroup(Int_t number) const
   {
      return (KVGroup*)GetStructure("GROUP", number);
   }
   virtual void Build(Int_t run = -1);
 
   void Clear(Option_t* opt = "") override;
 
   const KVSeqCollection* GetFiredDetectors() const
   {
      return &fFiredDetectors;
   }
 
   const KVSeqCollection* GetFiredSignals() const
   {
      return &fFiredSignals;
   }
 
   const KVSeqCollection* GetExtraRawDataSignals() const
   {
      return &fExtraRawDataSignals;
   }
 
   virtual void GetDetectorEvent(KVDetectorEvent* detev, const TSeqCollection* fired_params = 0);
 
   KVIDTelescope* GetIDTelescope(const Char_t* name) const;
   KVSeqCollection* GetListOfIDTelescopes() const
   {
      return fIDTelescopes;
   }
   KVUniqueNameList GetIDTelescopeTypes();
   KVSeqCollection* GetIDTelescopesWithType(const Char_t* type);
   void SetDetectorThicknesses();
 
   virtual void SetTarget(KVTarget* target)
   {
 
      fTarget = target;
   }
   KVTarget* GetTarget()
   {
      return fTarget;
   }
 
   virtual Double_t GetTargetEnergyLossCorrection(KVReconstructedNucleus*);
 
   Bool_t IsRemoving()
   {
      return TestBit(kIsRemoving);
   }
 
   virtual Bool_t IsBuilt() const
   {
      return TestBit(kIsBuilt);
   }
   static KVMultiDetArray* MakeMultiDetector(const Char_t* dataset_name, Int_t run = -1, TString classname = "KVMultiDetArray", KVExpDB* db = nullptr);
 
   Bool_t IsBeingDeleted()
   {
      return TestBit(kIsBeingDeleted);
   }
   KVUpDater* GetUpDater();
   virtual void SetParameters(UInt_t n, Bool_t physics_parameters_only = kFALSE);
   virtual void SetRunIdentificationParameters(UShort_t n);
   virtual void SetRunCalibrationParameters(UShort_t n);
 
   Bool_t ParamsSet()
   {
      return TestBit(kParamsSet);
   }
   Bool_t IDParamsSet()
   {
      return (TestBit(kIDParamsSet) || ParamsSet());
   }
   Bool_t CalParamsSet()
   {
      return (TestBit(kCalParamsSet) || ParamsSet());
   }
   UInt_t GetCurrentRunNumber() const
   {
      return fCurrentRun;
   }
   void SetCurrentRunNumber(UInt_t r)
   {
      fCurrentRun = r;
   }
 
   virtual void SetIdentifications();
   virtual void InitializeIDTelescopes();
   Bool_t ReadGridsFromAsciiFile(const Char_t*) const;
 
   virtual Double_t GetTotalSolidAngle(void) const
   {
 
      Double_t SA = 0;
      TIter it(GetDetectors());
      KVDetector* d;
      while ((d = (KVDetector*)it())) {
         if (!d->GetNode()->GetNDetsInFront()) {
            SA += d->GetSolidAngle();
         }
      }
      return SA;
   }
 
   TList* GetStatusOfIDTelescopes();
   TList* GetCalibrationStatusOfDetectors();
   void PrintStatusOfIDTelescopes();
   void PrintCalibStatusOfDetectors();
 
 
   virtual void SetSimMode(Bool_t on = kTRUE)
   {
      fSimMode = on;
      GetDetectors()->R__FOR_EACH(KVDetector, SetSimMode)(on);
   }
   Bool_t IsSimMode() const
   {
      return fSimMode;
   }
 
   static TGeoHMatrix* GetVolumePositioningMatrix(Double_t distance, Double_t theta, Double_t phi,
         TGeoTranslation* postTrans = nullptr);
   void SetGridsInTelescopes(UInt_t run);
   void FillListOfIDTelescopes(KVIDGraph* gr) const;
 
   void Draw(Option_t* option = "") override;
   const TSeqCollection* GetTrajectories() const
   {
      return &fTrajectories;
   }
 
   void MakeHistogramsForAllIDTelescopes(KVSeqCollection* list, Int_t dimension = 100);
   void CalculateIdentificationGrids();
 
   void SetDetectorTransparency(Char_t);
   virtual void FillDetectorList(KVReconstructedNucleus* rnuc, KVHashList* DetList, const KVString& DetNames);
 
   virtual void AcceptParticleForAnalysis(KVReconstructedNucleus*) const;
   const KVNumberList& GetAcceptedIDCodes() const
   {
      return fAcceptIDCodes;
   }
   const KVNumberList& GetAcceptedECodes() const
   {
      return fAcceptECodes;
   }
   void AcceptIDCodes(const KVNumberList& codelist)
   {
 
      fAcceptIDCodes = codelist;
   }
   virtual void AcceptAllIDCodes()
   {
 
      AcceptIDCodes("");
   }
   void AcceptECodes(const KVNumberList& codelist)
   {
 
 
      fAcceptECodes = codelist;
   }
   virtual void AcceptAllECodes()
   {
 
      AcceptECodes("");
   }
 
   virtual KVMultiDetArray* GetArray(const Char_t*) const
   {
      return const_cast<KVMultiDetArray*>(this);
   }
   virtual const KVSeqCollection* GetArrays() const
   {
      return nullptr;
   }
 
   void RecursiveTrajectoryClustering(KVGeoDetectorNode* N, KVUniqueNameList& tried_trajectories, KVUniqueNameList& multitraj_nodes, KVUniqueNameList& detectors_of_group);
   virtual const Char_t* GetPartSeedCond() const
   {
      return fPartSeedCond;
   }
   virtual void SetPartSeedCond(const Char_t* cond)
   {
      fPartSeedCond = cond;
   }
   virtual KVGroupReconstructor* GetReconstructorForGroup(const KVGroup*) const;
   Int_t GetNumberOfGroups() const
   {
      std::unique_ptr<KVSeqCollection> glist(GetStructureTypeList("GROUP"));
      return glist->GetEntries();
   }
 
   virtual void InitialiseRawDataReading(KVRawDataReader*);
   virtual Bool_t HandleRawDataEvent(KVRawDataReader*);
#ifdef WITH_MFM
   Bool_t HandleRawDataBuffer(MFMBufferReader&);
#endif
   Bool_t HandledRawData() const
   {
      return fHandledRawData;
   }
   virtual void SetRawDataFromReconEvent(const KVReconstructedEvent&);
 
   TString GetDataSet() const
   {
      return fDataSet;
   }
 
   virtual void MakeCalibrationTables(KVExpDB*);
   virtual void SetCalibratorParameters(KVDBRun*, const TString& = "");
   void CheckStatusOfDetectors(KVDBRun*, const TString& = "");
   virtual void SetDetectorParametersForRun(KVDBRun*, const TString& = "");
 
   virtual Int_t GetIDCodeForParticlesStoppingInFirstStageOfTelescopes() const
   {
      return 5;
   }
   virtual TString GetIDCodeMeaning(Int_t) const
   {
      return "";
   }
   virtual TString GetECodeMeaning(Int_t) const
   {
      return "";
   }
   virtual Short_t GetBadIDCode() const
   {
      return 14;
   }
   virtual Short_t GetCoherencyIDCode() const
   {
      return 6;
   }
   virtual Short_t GetMultiHitFirstStageIDCode() const
   {
      return 8;
   }
   Short_t GetZminCode() const
   {
      return GetIDCodeForParticlesStoppingInFirstStageOfTelescopes();
   }
   virtual UChar_t GetNormalCalibrationCode() const
   {
      return 1;
   }
   virtual UChar_t GetNoCalibrationCode() const
   {
      return 0;
   }
   virtual UChar_t GetCalculatedCalibrationCode() const
   {
      return 2;
   }
   static void SetMakeMultiDetectorPhysicsParametersOnly(Bool_t on = kTRUE)
   {
      fMakeMultiDetectorPhysicsParametersOnly = on;
   }
 
   ClassDefOverride(KVMultiDetArray, 7) //Base class for multidetector arrays
};
 
R__EXTERN KVMultiDetArray* gMultiDetArray;
 
#endif