KVMultiDetArray.h

 
#ifndef __KVMultiDetArray_H
#define __KVMultiDetArray_H
 
#include "KVGeoStrucElement.h"
#include "KVUniqueNameList.h"
#include "TGraph.h"
#include "TGeoManager.h"
#include "KVNucleus.h"
#include "KVDetector.h"
#include "KVGroupReconstructor.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 KVRangeTableGeoNavigator;
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 "MFMMesytecMDPPFrame.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;
 
    Bool_t fROOTGeometry;
 
    Int_t fFilterType;
 
    KVRangeTableGeoNavigator* fNavigator;
 
    KVUniqueNameList fTrajectories;
 
    KVNumberList fAcceptIDCodes;
    KVNumberList fAcceptECodes;
 
    TString fPartSeedCond;
 
    KVRawDataReader* fRawDataReader;
    Bool_t fHandledRawData;
 
    KVNameValueList fReconParameters;
 
   virtual void RenumberGroups();
   virtual void BuildGeometry()
   {
      AbstractMethod("BuildGeometry");
   }
   virtual void MakeListOfDetectors();
 
   virtual void SetExpectedDetectorSignalNames();
 
   virtual Int_t GetIDTelescopes(KVDetector*, 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);
 
   virtual void GetAlignedIDTelescopesForDetector(KVDetector* det, TCollection* list);
   virtual void GetIDTelescopesForGroup(KVGroup* grp, TCollection* tel_list);
   virtual void PrepareModifGroup(KVGroup* grp, KVDetector* dd);
   virtual void SetPresent(KVDetector* det, Bool_t present = kTRUE);
   virtual void SetDetecting(KVDetector* det, Bool_t detecting = kTRUE);
 
   void CalculateReconstructionTrajectories();
   virtual void DeduceIdentificationTelescopesFromGeometry();
   void AddTrajectory(KVGeoDNTrajectory* d)
   {
      fTrajectories.Add(d);
   }
   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);
 
   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 UShort_t GetBadIDCode()
   {
      return 14;
   }
   virtual UShort_t GetCoherencyIDCode()
   {
      return 6;
   }
   virtual UShort_t GetMultiHitFirstStageIDCode()
   {
      return 8;
   }
   UShort_t GetZminCode()
   {
      return GetIDCodeForParticlesStoppingInFirstStageOfTelescopes();
   }
   virtual UChar_t GetNormalCalibrationCode()
   {
      return 1;
   }
 
   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();
 
   virtual void Build(Int_t run = -1);
   virtual void CreateIDTelescopesInGroups();
 
   virtual void Clear(Option_t* opt = "");
 
   virtual KVTelescope* GetTelescope(const Char_t* name) const;
   virtual KVGroup* GetGroupWithDetector(const Char_t*);
   virtual KVGroup* GetGroup(const Char_t*) const;
   virtual KVGroup* GetGroupWithAngles(Float_t /*theta*/, Float_t /*phi*/)
   {
      return 0;
   }
   void RemoveGroup(KVGroup*);
   void RemoveGroup(const Char_t*);
   void ReplaceDetector(const Char_t* name, KVDetector* new_kvd);
 
   const KVSeqCollection* GetFiredDetectors() const
   {
      return &fFiredDetectors;
   }
 
   const KVSeqCollection* GetFiredSignals() const
   {
      return &fFiredSignals;
   }
 
   const KVSeqCollection* GetExtraRawDataSignals() const
   {
      return &fExtraRawDataSignals;
   }
 
   virtual void DetectEvent(KVEvent* event, KVReconstructedEvent* rec_event, const Char_t* detection_frame = "");
   virtual Int_t FilteredEventCoherencyAnalysis(Int_t round, KVReconstructedEvent* rec_event);
   virtual void GetDetectorEvent(KVDetectorEvent* detev, const TSeqCollection* fired_params = 0);
   virtual void ReconstructEvent(KVReconstructedEvent*, KVDetectorEvent*);
   KVNameValueList* DetectParticle_TGEO(KVNucleus* part);
   virtual KVNameValueList* DetectParticle(KVNucleus* part)
   {
      return DetectParticle_TGEO(part);
   }
   void DetectParticleIn(const Char_t* detname, KVNucleus* kvp);
 
   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");
 
   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()->GetDetectorsInFront()) {
            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;
   }
 
   virtual Double_t GetPunchThroughEnergy(const Char_t* detector, Int_t Z, Int_t A);
   virtual TGraph* DrawPunchThroughEnergyVsZ(const Char_t* detector, Int_t massform = KVNucleus::kBetaMass);
   virtual TGraph* DrawPunchThroughEsurAVsZ(const Char_t* detector, Int_t massform = KVNucleus::kBetaMass);
   virtual TGraph* DrawPunchThroughZVsVpar(const Char_t* detector, Int_t massform = KVNucleus::kBetaMass);
 
   virtual void SetROOTGeometry(Bool_t on = kTRUE);
   Bool_t IsROOTGeometry() const
   {
 
      if (!GetDetectors()->GetEntries()) return kFALSE;
      KVDetector* d = dynamic_cast<KVDetector*>(GetDetectors()->First());
      return d->ROOTGeo();
   }
   static TGeoHMatrix* GetVolumePositioningMatrix(Double_t distance, Double_t theta, Double_t phi,
         TGeoTranslation* postTrans = nullptr);
   void CalculateDetectorSegmentationIndex();
   virtual void AnalyseGroupAndReconstructEvent(KVReconstructedEvent* recev, KVGroup* grp);
   void SetGridsInTelescopes(UInt_t run);
   void FillListOfIDTelescopes(KVIDGraph* gr) const;
 
   void Draw(Option_t* option = "");
   const TSeqCollection* GetTrajectories() const
   {
      return &fTrajectories;
   }
 
   void CheckROOTGeometry()
   {
      if (!IsROOTGeometry()) SetROOTGeometry();
   }
   void MakeHistogramsForAllIDTelescopes(KVSeqCollection* list, Int_t dimension = 100);
   void FillHistogramsForAllIDTelescopes(KVSeqCollection* list);
   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);
   }
 
   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(KVNameValueList&);
 
   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 "";
   }
   static void SetMakeMultiDetectorPhysicsParametersOnly(Bool_t on = kTRUE)
   {
      fMakeMultiDetectorPhysicsParametersOnly = on;
   }
 
   ClassDef(KVMultiDetArray, 7) //Base class for multidetector arrays
};
 
R__EXTERN KVMultiDetArray* gMultiDetArray;
 
#endif