KVIDTelescope.h

/***************************************************************************
$Id: KVIDTelescope.h,v 1.33 2009/04/01 15:58:10 ebonnet Exp $
                          KVIDTelescope.h  -  description
                             -------------------
    begin                : Wed Jun 18 2003
    copyright            : (C) 2003 by J.D Frankland
    email                : frankland@ganil.fr
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef KVIDTELESCOPE_H
#define KVIDTELESCOPE_H
 
#include "KVBase.h"
#include "KVDetector.h"
#include "TGraph.h"
#include "KVParticleCondition.h"
#include <optional>
class KVReconstructedNucleus;
class KVGroup;
class KVIDGraph;
class KVIDGrid;
class KVMultiDetArray;
class KVIdentificationResult;
class TH2;
 
#include <KVUnownedList.h>
#include <unordered_map>
 
class KVIDTelescope: public KVBase {
 
 
   static TEnv* fgIdentificationBilan;
    UShort_t fIDCode;
 
protected:
    KVUnownedList fDetectors;
    KVGroup* fGroup;
    KVUnownedList fIDGrids;
   enum {
      kMassID = BIT(15),         //set if telescope is capable of mass identification i.e. isotopic resolution
      kReadyForID = BIT(16)         //set if telescope is ready and able for identification. set in Initialize()
   };
    Int_t fCalibStatus;
 
   void SetLabelFromURI(const Char_t* uri);
    std::unique_ptr<KVParticleCondition> fMassIDValidity;
   KVDetectorSignal* GetSignalFromGridVar(const KVString& var, const KVString& axe, KVString& det_labels);
   struct GraphCoords {
      KVDetectorSignal* fVarX;
      KVDetectorSignal* fVarY;
      KVString fDetLabelsX;
      KVString fDetLabelsY;
   };
    mutable std::unordered_map<KVIDGraph*, GraphCoords> fGraphCoords;
    KVList fMultiDetExpressions;
 
   KVIDGrid* newGrid(bool onlyZ);
   void addLineToGrid(KVIDGrid* gg, int zz, int aa, int npoints, std::optional<Double_t> einc_max = std::nullopt);
 
public:
 
   KVString GetDetectorLabelsForGridCoord(const KVString& axis) const;
 
   enum {
      kCalibStatus_OK,                    // fine, OK, all detectors calculated and functioning properly
      kCalibStatus_Calculated,        // one or more detectors not calibrated/functioning, energy loss calculated
      kCalibStatus_NoCalibrations,  // no calibrations available for any detectors
      kCalibStatus_Multihit,  // one or more detectors hit by more than one particle, energy loss calculated for this detector
      kCalibStatus_Coherency  // comparison of calculated and measured energy loss in one or more detectors reveals presence of other particles
   };
 
   KVIDTelescope();
   void init();
   virtual void AddDetector(KVDetector* d);
   const KVList* GetDetectors() const
   {
      return &fDetectors;
   }
   KVDetector* GetDetector(UInt_t n) const
   {
      if (n > GetSize() || n < 1) {
         Error("GetDetector(UInt_t n)", "n must be between 1 and %u",
               GetSize());
         return 0;
      }
      KVDetector* d = (KVDetector*) GetDetectors()->At((n - 1));
      return d;
   };
   KVDetector* GetDetector(const Char_t* name) const;
   Bool_t HasDetector(const KVDetector* d) const
   {
      return GetDetectorRank(d) > 0;
   }
   UInt_t GetDetectorRank(const KVDetector* kvd) const
   {
 
      return GetDetectors()->IndexOf(kvd) + 1;
   }
   UInt_t GetSize() const
   {
      return GetDetectors()->GetSize();
   }
 
   KVGroup* GetGroup() const;
   void SetGroup(KVGroup* kvg);
   UInt_t GetGroupNumber();
 
   virtual void Initialize(void);
 
   virtual Bool_t Identify(KVIdentificationResult*, Double_t x = -1., Double_t y = -1.);
 
   virtual Int_t GetCalibStatus() const
   {
      return fCalibStatus;
   }
 
   void Print(Option_t* opt = "") const override;
 
   void SetIDGrid(KVIDGraph*);
   KVIDGraph* GetIDGrid();
   KVIDGraph* GetIDGrid(Int_t);
   KVIDGraph* GetIDGrid(const Char_t*);
   const KVList* GetListOfIDGrids() const
   {
      return &fIDGrids;
   }
 
   virtual void RemoveGrids();
 
   virtual Double_t GetIDMapX(Option_t* opt = "");
   virtual Double_t GetIDMapY(Option_t* opt = "");
   virtual Double_t GetPedestalX(Option_t* opt = "");
   virtual Double_t GetPedestalY(Option_t* opt = "");
 
   Double_t GetIDGridXCoord(KVIDGraph*) const;
   Double_t GetIDGridYCoord(KVIDGraph*) const;
   void GetIDGridCoords(Double_t& X, Double_t& Y, KVIDGraph* grid, Double_t x = -1, Double_t y = -1)
   {
 
      Y = (y < 0. ? GetIDGridYCoord(grid) : y);
      X = (x < 0. ? GetIDGridXCoord(grid) : x);
   }
   void SetHasMassID(Bool_t yes = kTRUE)
   {
      SetBit(kMassID, yes);
   }
 
   Bool_t HasMassID() const
   {
      return TestBit(kMassID);
   }
 
   static KVIDTelescope* MakeIDTelescope(const Char_t* name);
 
   virtual Bool_t SetIdentificationParameters(const KVMultiDetArray*);
   virtual void RemoveIdentificationParameters();
 
   Bool_t LoadIdentificationParameters(const KVMultiDetArray* multidet, const TString& _filename = "");
   Bool_t ReadIdentificationParameterFiles(const KVMultiDetArray* multidet);
 
   virtual Bool_t IsReadyForID()
   {
      return TestBit(kReadyForID);
   };
 
   const Char_t* GetDefaultIDGridClass();
   KVIDGrid* CalculateDeltaE_EGrid(const KVNameValueList& AperZ, Int_t npoints = 30, Double_t xfactor = 1.);
   KVIDGrid* CalculateDeltaE_EGrid(const KVNumberList& Zrange, Int_t deltaMasse, Int_t npoints, Double_t lifetime = -10/*s*/, UChar_t massformula = 0, Double_t xfactor = 1.);
   KVIDGrid* CalculateDeltaE_EGrid(const KVNumberList& Zrange, Int_t npoints, Double_t Einc_max, UChar_t massformula = 0);
   KVIDGrid* CalculateDeltaE_EGrid(TH2* haa_zz, Bool_t Zonly, Int_t npoints);
   enum {
      kMeanDE_OK,       // all OK
      kMeanDE_XtooSmall,  // X-coordinate is smaller than smallest X-coordinate of ID line
      kMeanDE_XtooLarge,   // X-coordinate is larger than largest X-coordinate of ID line
      kMeanDE_NoIdentifier   // No identifier found for Z or (Z,A)
   };
   virtual Double_t GetMeanDEFromID(Int_t& status, Int_t Z, Int_t A = -1, Double_t Eres = -1.0);
   virtual UShort_t GetIDCode()
   {
      return fIDCode;
   }
 
   virtual void SetIDCode(UShort_t c)
   {
      fIDCode = c;
   }
 
   virtual Bool_t CheckTheoreticalIdentificationThreshold(KVNucleus* /*ION*/, Double_t /*EINC*/ = 0.0);
   virtual Bool_t CanIdentify(Int_t Z, Int_t /*A*/)
   {
      return (Z > 0);
   }
   virtual void SetIdentificationStatus(KVIdentificationResult* IDR, const KVNucleus*);
   Bool_t IsIndependent() const
   {
 
      return (GetSize() == 1 || (GetSize() == 2 && GetDetector(1)->GetNode()->GetNTraj() == 1
                                 && GetDetector(2)->GetNode()->GetNTraj() == 1));
   }
 
   static void OpenIdentificationBilan(const TString& path);
   void CheckIdentificationBilan(const TString& system);
 
   ClassDefOverride(KVIDTelescope, 5)   //A delta-E - E identification telescope
};
 
#endif