DetectorPropertiesStandard.h

Go to the documentation of this file.

// \file DetectorPropertiesStandard.h
//
// \brief service to contain information about detector electronics, etc
//
// \author brebel@fnal.gov
// 
// Separation of service from Detector info class:
// jpaley@fnal.gov
#ifndef DETINFO_DETECTORPROPERTIESSTD_H
#define DETINFO_DETECTORPROPERTIESSTD_H

// LArSoft libraries
#include "larcorealg/Geometry/GeometryCore.h"
#include "larcorealg/CoreUtils/ProviderPack.h"
#include "lardataalg/DetectorInfo/LArProperties.h"
#include "lardataalg/DetectorInfo/DetectorClocks.h"
#include "lardataalg/DetectorInfo/DetectorProperties.h"

// framework libraries
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/types/Sequence.h"
#include "fhiclcpp/types/Table.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/OptionalAtom.h"

// C/C++ standard libraries
#include <set>

namespace detinfo{
  
  class DetectorPropertiesStandard : public DetectorProperties {
    public:
      using providers_type = lar::ProviderPack<
        geo::GeometryCore,
        detinfo::LArProperties,
        detinfo::DetectorClocks
        >;
       
      struct Configuration_t {
        using Name = fhicl::Name;
        using Comment = fhicl::Comment;
        
        fhicl::Sequence<double> Efield { Name("Efield"), Comment(
          "electric field in front of each wire plane (the last one is the big one!) [kV/cm]")
          };
    
        fhicl::Atom<double      > Electronlifetime         {
          Name("Electronlifetime"        ),
          Comment("electron lifetime in liquid argon [us]")
        };
        fhicl::Atom<double      > Temperature              {
          Name("Temperature"             ),
          Comment("argon temperature [K]")
        };
        fhicl::Atom<double      > ElectronsToADC           {
          Name("ElectronsToADC"          ),
          Comment("conversion factor: (ADC counts)/(ionization electrons)")
        };
        fhicl::Atom<unsigned int> NumberTimeSamples        {
          Name("NumberTimeSamples"       ),
          Comment("number of TPC readout TDC clock ticks per event")
        };
        fhicl::Atom<unsigned int> ReadOutWindowSize        {
          Name("ReadOutWindowSize"       ),
          Comment("number of TPC readout TDC clock ticks per readout window")
        };
        
        // The following are not really "optional": the ones for the views which
        // are present are mandatory.
        fhicl::OptionalAtom<double      > TimeOffsetU              {
          Name("TimeOffsetU"             ),
          Comment("tick offset subtracted to to convert spacepoint coordinates to hit times on view U")
        };
        fhicl::OptionalAtom<double      > TimeOffsetV              {
          Name("TimeOffsetV"             ),
          Comment("tick offset subtracted to to convert spacepoint coordinates to hit times on view V")
        };
        fhicl::OptionalAtom<double      > TimeOffsetZ              {
          Name("TimeOffsetZ"             ),
          Comment("tick offset subtracted to to convert spacepoint coordinates to hit times on view Z")
        };
        fhicl::OptionalAtom<double      > TimeOffsetY              {
          Name("TimeOffsetY"             ),
          Comment("tick offset subtracted to to convert spacepoint coordinates to hit times on view Y")
        };
        fhicl::OptionalAtom<double      > TimeOffsetX              {
          Name("TimeOffsetX"             ),
          Comment("tick offset subtracted to to convert spacepoint coordinates to hit times on view X")
        };
        
        fhicl::Atom<double      > SternheimerA             {
          Name("SternheimerA"),
          Comment("parameter a of Sternheimer correction delta = 2log(10) x - cbar + { a (x1-x)^k } theta(x1-x), x = log10(p/m)")
        };
        fhicl::Atom<double      > SternheimerK             {
          Name("SternheimerK"),
          Comment("parameter k of Sternheimer correction delta = 2log(10) x - cbar + { a (x_1-x)^k } theta(x1-x), x = log10(p/m)")
        };
        fhicl::Atom<double      > SternheimerX0            {
          Name("SternheimerX0"),
          Comment("minimum x = log10(p/m) for the application of Sternheimer correction")
        };
        fhicl::Atom<double      > SternheimerX1            {
          Name("SternheimerX1"),
          Comment("parameter x_1 of Sternheimer correction delta = 2log(10) x - cbar + { a (x_1-x)^k } theta(x1-x), x = log10(p/m)")
        };
        fhicl::Atom<double      > SternheimerCbar             {
          Name("SternheimerCbar"),
          Comment("parameter cbar of Sternheimer correction delta = 2log(10) x - cbar + { a (x_1-x)^k } theta(x1-x), x = log10(p/m)")
        };

        fhicl::Atom<bool> SimpleBoundary { Name("SimpleBoundaryProcess" ), Comment("") };
      
      }; // Configuration_t
 
      DetectorPropertiesStandard();
      DetectorPropertiesStandard(fhicl::ParameterSet const& pset, 
                         const geo::GeometryCore* geo,
                         const detinfo::LArProperties* lp,
                         const detinfo::DetectorClocks* c,
                         std::set<std::string> const& ignore_params = {}
                         );
      DetectorPropertiesStandard(fhicl::ParameterSet const& pset,
                         providers_type providers,
                         std::set<std::string> const& ignore_params = {});
      DetectorPropertiesStandard(DetectorPropertiesStandard const&) = delete;
      virtual ~DetectorPropertiesStandard() = default;
      
      void ValidateAndConfigure(
        fhicl::ParameterSet const& p,
        std::set<std::string> const& ignore_params = {}
        );

      
      void Configure(Configuration_t const& config);
      
      Configuration_t ValidateConfiguration(
        fhicl::ParameterSet const& p,
        std::set<std::string> const& ignore_params = {}
        );

      bool Update(uint64_t ts);
      bool UpdateClocks(const detinfo::DetectorClocks* clks);
      
      void Setup(providers_type providers);
        
      void SetGeometry(const geo::GeometryCore* g) { fGeo = g; }
      void SetLArProperties(const detinfo::LArProperties* lp) { fLP = lp; }
      void SetDetectorClocks(const detinfo::DetectorClocks* clks) { fClocks = clks; }

      void SetNumberTimeSamples(unsigned int nsamp) { fNumberTimeSamples=nsamp;}
      // Accessors.

      virtual double Efield(unsigned int planegap=0) const override; 

      virtual double DriftVelocity(double efield=0., double temperature=0.) const override;  
      
      virtual double BirksCorrection(double dQdX) const override;
      virtual double ModBoxCorrection(double dQdX) const override;

      virtual double ElectronLifetime() const override { return fElectronlifetime; }   //< microseconds
      
      
      virtual double Density(double temperature) const override;                          
      
      // need to provide a definition, since the override above hides the inherited one
      virtual double Density() const override { return Density(Temperature()); }
      
      virtual double Temperature()                   const override { return fTemperature; }
      
      virtual double Eloss(double mom, double mass, double tcut) const override;
      
      virtual double ElossVar(double mom, double mass) const override;

      virtual double       SamplingRate()      const override { return fTPCClock.TickPeriod() * 1.e3; }
      virtual double       ElectronsToADC()    const override { return fElectronsToADC; }
      virtual unsigned int NumberTimeSamples() const override { return fNumberTimeSamples; }
      virtual unsigned int ReadOutWindowSize() const override { return fReadOutWindowSize; }
      virtual int          TriggerOffset()     const override;
      virtual double       TimeOffsetU()       const override{ return fTimeOffsetU; };
      virtual double       TimeOffsetV()       const override { return fTimeOffsetV; };
      virtual double       TimeOffsetZ()       const override{ return fTimeOffsetZ; };
      virtual double       TimeOffsetY()       const override{ return fTimeOffsetY; };

      virtual double       ConvertXToTicks(double X, int p, int t, int c) const override;
      virtual double       ConvertXToTicks(double X, geo::PlaneID const& planeid) const override
        { return ConvertXToTicks(X, planeid.Plane, planeid.TPC, planeid.Cryostat); }
      virtual double       ConvertTicksToX(double ticks, int p, int t, int c) const override;
      virtual double       ConvertTicksToX(double ticks, geo::PlaneID const& planeid) const override
        { return ConvertTicksToX(ticks, planeid.Plane, planeid.TPC, planeid.Cryostat); }

      virtual double       GetXTicksOffset(int p, int t, int c) const override;
      virtual double       GetXTicksOffset(geo::PlaneID const& planeid) const override
        { return GetXTicksOffset(planeid.Plane, planeid.TPC, planeid.Cryostat); }
      virtual double       GetXTicksCoefficient(int t, int c) const override;
      virtual double       GetXTicksCoefficient(geo::TPCID const& tpcid) const override
        { return GetXTicksCoefficient(tpcid.TPC, tpcid.Cryostat); }
      virtual double       GetXTicksCoefficient() const override;

      // The following methods convert between TDC counts (SimChannel time) and
      // ticks (RawDigit/Wire time).
      virtual double       ConvertTDCToTicks(double tdc) const override;
      virtual double       ConvertTicksToTDC(double ticks) const override;
      

      virtual bool SimpleBoundary()     const override  { return fSimpleBoundary; }
      
      void CheckIfConfigured() const;
      
    protected:
      
     
      struct SternheimerParameters_t {
        double a;               
        double k;               
        double x0;              
        double x1;              
        double cbar;            
      }; //  SternheimerParameters_t
      
      void         CalculateXTicksParams();
      
      // service providers we depend on;
      // in principle could be replaced by a single providerpacl_type.
      const detinfo::LArProperties* fLP;
      const detinfo::DetectorClocks* fClocks;
      const geo::GeometryCore* fGeo;
      
      std::vector< double >          fEfield;           
      double                         fElectronlifetime; 
      double                         fTemperature;      
      double       fSamplingRate;      
      double       fElectronsToADC;    
      unsigned int fNumberTimeSamples; 
      unsigned int fReadOutWindowSize; 
      double       fTimeOffsetU;       
      double       fTimeOffsetV;       
      double       fTimeOffsetZ;       
      double       fTimeOffsetY;       
      double       fTimeOffsetX;       
      double       fHasTimeOffsetU = false; 
      double       fHasTimeOffsetV = false; 
      double       fHasTimeOffsetZ = false; 
      double       fHasTimeOffsetY = false; 
      double       fHasTimeOffsetX = false; 
      
      SternheimerParameters_t fSternheimerParameters; 
      
      double       fXTicksCoefficient; 

      std::vector<std::vector<std::vector<double> > > fXTicksOffsets;
      std::vector<std::vector<double> >               fDriftDirection;

      ::detinfo::ElecClock fTPCClock;     
      
      bool fSimpleBoundary;

      std::string CheckTimeOffsetConfigurationAfterSetup() const;
      
      void CheckConfigurationAfterSetup() const;
      
      void DoUpdateClocks();
      
    }; // class DetectorPropertiesStandard
} //namespace detinfo

#endif // DETINFO_DETECTOR_PROPERTIES_H