BeamlineGeometry.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineGeometry.h
/// \brief   Definition of the beamline offline geometry.
///          Also implementation of a service to obtain this information.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    August 2019
////////////////////////////////////////////////////////////////////////////

#ifndef BeamlineGeometry_H
#define BeamlineGeometry_H

// framework
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Services/Registry/ServiceMacros.h"

// stl

// root
#include "TVector3.h"

// -----------------------------------------------------------------------
namespace beamlinegeo {

  // -----------------------------------------------------------------------
  struct SystemID {
    SystemID() { }
    SystemID(unsigned int system) {
      System = system;
    }
    inline bool operator==(const SystemID& sid) const {
      return (sid.System == System);
    }
    inline bool operator<(const SystemID& sid) const {
      if (sid.System >= System) return false;
      return true;
    }
    inline bool operator>(const SystemID& sid) const {
      if (sid.System <= System) return false;
      return true;
    }
    unsigned int System;
  };
  inline std::ostream& operator<<(std::ostream& os, const SystemID& system) {
    os << "SystemID: System " << system.System << std::endl;
    return os;
  }

  // -----------------------------------------------------------------------
  struct DetectorID : SystemID {
  DetectorID() : SystemID() { }
  DetectorID(SystemID system, unsigned int detector) : SystemID(system), Detector(detector) {
    }
  DetectorID(unsigned int system, unsigned int detector) : SystemID(system), Detector(detector) {
    }
    SystemID GetSystemID() const { return *this; }
    inline bool operator==(const DetectorID& did) const {
      return (did.System == System and did.Detector == Detector);
    }
    inline bool operator<(const DetectorID& did) const {
      if (did.System >= System) return false;
      if (did.Detector >= Detector) return false;
      return true;
    }
    inline bool operator>(const DetectorID& did) const {
      if (did.System <= System) return false;
      if (did.Detector <= Detector) return false;
      return true;
    }
    unsigned int Detector;
  };
  inline std::ostream& operator<<(std::ostream& os, const DetectorID& detector) {
    os << "DetectorID: System " << detector.System
       << ", Detector " << detector.Detector << std::endl;
    return os;
  }

  // -----------------------------------------------------------------------
  struct ChannelID : DetectorID {
  ChannelID() : DetectorID() { }
  ChannelID(DetectorID detector, unsigned int channel) : DetectorID(detector), Channel(channel) {
    }
  ChannelID(unsigned int system, unsigned int detector, unsigned int channel) : DetectorID(system, detector), Channel(channel) {
    }
    SystemID GetSystemID() const { return *this; }
    DetectorID GetDetectorID() const { return *this; }
    inline bool operator==(const ChannelID& cid) const {
      return (cid.System == System and cid.Detector == Detector and cid.Channel == Channel);
    }
    inline bool operator<(const ChannelID& cid) const {
      if (cid.System > System) return false;
      if (cid.System == System and cid.Detector > Detector) return false;
      if (cid.System == System and cid.Detector == Detector and cid.Channel >= Channel) return false;
      return true;
    }
    inline bool operator>(const ChannelID& cid) const {
      if (cid.System < System) return false;
      if (cid.System == System and cid.Detector < Detector) return false;
      if (cid.System == System and cid.Detector == Detector and cid.Channel <= Channel) return false;
      return true;
    }
    unsigned int Channel;
  };
  inline std::ostream& operator<<(std::ostream& os, const ChannelID& channel) {
    os << "ChannelID: System " << channel.System << ", Detector "
       << channel.Detector << ", Channel " << channel.Channel << std::endl;
    return os;
  }

  // -----------------------------------------------------------------------
  enum class BeamlineCoordSystem {
    Beamline     = 0,
    NOvADetector = 1
  };

  // -----------------------------------------------------------------------
  enum class BeamlineComponent {
    Target        = 0,
    ToFUS         = 1,
    ToFDS         = 2,
    ToFDSSiPM     = 3,
    WC1           = 4,
    WC2           = 5,
    WC3           = 6,
    WC4           = 7,
    Cherenkov     = 8,
    NOvA          = 9,
    Magnet        = 10,
    CollimatorUS  = 11,
    CollimatorDS  = 12,
    Shielding1    = 13,
    Shielding2    = 14,
    Shielding3    = 15,
    HeliumPipe1   = 16,
    HeliumPipe2   = 17,
    HeliumPipe3   = 18,
    HeliumPipe4   = 19,
    TotalNumber   = 20
  };

  struct BeamlineObject {
    BeamlineComponent Component;
    TVector3 Position;
    TVector3 Dimensions;
    float Angle;
    BeamlineObject() = default;
    BeamlineObject(BeamlineComponent component) {
      Component = component;
    }
  };

  // -----------------------------------------------------------------------
  enum BeamlineSystem {
    Trigger   = 0,
    Cherenkov = 1,
    ToF       = 2,
    WC        = 3,
    MuonStack = 4,
    Paddle    = 5,
    WCDigit   = 6,
    Other     = 7
  };

  // -----------------------------------------------------------------------
  enum ToFCounter {
    US     = 0,
    DS     = 1,
    DSSiPM = 2,
  };

  // -----------------------------------------------------------------------
  const std::map<ToFCounter, std::string> ToFCounterNames = {
    {ToFCounter::US, "US"},
    {ToFCounter::DS, "DS"},
    {ToFCounter::DSSiPM, "DSSiPM"}
  };

  // -----------------------------------------------------------------------
  enum ToFChannel {
    UpperLeft  = 0,
    LowerLeft  = 1,
    LowerRight = 2,
    UpperRight = 3
  };

  // -----------------------------------------------------------------------
  const std::map<ToFChannel, std::string> ToFChannelNames = {
    {ToFChannel::UpperLeft, "UpperLeft"},
    {ToFChannel::LowerLeft, "LowerLeft"},
    {ToFChannel::UpperRight, "UpperRight"},
    {ToFChannel::LowerRight, "LowerRight"},
  };

  // -----------------------------------------------------------------------
  class BeamlineGeometry {

  public:

    BeamlineGeometry(const fhicl::ParameterSet& pset);
    BeamlineGeometry(const fhicl::ParameterSet& pset, art::ActivityRegistry&);

    void MakeObjects();
    void ConfigureGeometry(const fhicl::ParameterSet& pset);

    /// Number of ToF counters in beamline
    unsigned int NumToFs() const;

    /// Number of WCs in beamline
    unsigned int NumWCs() const;

    /// Number of Cherenkov detectors in beamline
    unsigned int NumCherenkov() const;

    /// Number of counter of this ToF
    unsigned int NumToFCounters(DetectorID tof) const;

    /// Number of channels on this WC
    unsigned int NumWCChannels(DetectorID wc) const;

    /// Return beamline object for a BeamlineComponent
    BeamlineObject GetBeamlineObject(BeamlineComponent component) const;

    /// Return beamline object for a ChannelID
    BeamlineObject GetBeamlineObject(ChannelID channel) const;

    /// Return beamline object for a DetectorID
    BeamlineObject GetBeamlineObject(DetectorID detector) const;

    /// Return DetectorID for a beamline object
    DetectorID GetDetectorID(BeamlineObject object) const;

    /// Return DetectorID for a BeamlineComponent
    DetectorID GetDetectorID(BeamlineComponent component) const;

    /// Magnet angle
    float MagnetAngle() const;

    /// Effective length of the magnet
    float MagnetEffectiveLength() const;

    /// Intercept of the magnet midplane?
    float MagnetMidplaneIntercept() const;

    /// Number of wires on each WC plane
    unsigned int NumWCPlaneWires() const;

    /// Wire chamber wire pitch
    float WCWirePitch() const;

    /// WC angle
    float WCAngle(unsigned int wc) const;

    /// Convert a position vector in beamline coordinates
    /// to NOvA detector coordinates
    TVector3 BeamlineToNOvADetectorCoords(TVector3 vec) const;

    /// Convert a position vector in NOvA detector coordinates
    /// to beamline coordinates
    TVector3 NOvADetectorToBeamlineCoords(TVector3 vec) const;

    /// Get the position of a beamline component in the specified
    /// coordinate system
    TVector3 BeamlineComponentPos(BeamlineComponent component,
                                  BeamlineCoordSystem system) const;

    /// SystemIDs
    std::vector<SystemID> SystemIDs() const;

    /// DetectorIDs
    std::vector<DetectorID> DetectorIDs() const;

    /// ChannelIDs
    std::vector<ChannelID> ChannelIDs() const;

  private:

    // Number of beamline components
    unsigned int fNumToFs;
    unsigned int fNumWCs;
    unsigned int fNumCherenkov;

    // Information about ToF
    std::vector<unsigned int> fNumToFCounters;

    // Information about magnet
    float fMagnetAngle;
    float fMagnetEffectiveLength;
    float fMagnetMidplaneIntercept;

    // Information about WCs
    unsigned int fNumWCPlaneWires;
    float fWCWirePitch;
    std::vector<float> fWCAngles;

    // Container of beamline objects
    std::map<BeamlineComponent, BeamlineObject> fBeamlineObjects;

    // Origin of the NOvA coordinate system in Beamline coordinates
    // Used for translating between the two systems
    TVector3 fNOvACoordOrigin;

  };

}

// -----------------------------------------------------------------------
DECLARE_ART_SERVICE(beamlinegeo::BeamlineGeometry, LEGACY)

#endif