SVDBackgroundModule.h

#ifndef SVDBackgroundMODULE_H_
#define SVDBackgroundMODULE_H_
 
#include <framework/core/Module.h>
#include <framework/gearbox/Unit.h>
#include <vxd/dataobjects/VxdID.h>
#include <vxd/geometry/SensorInfoBase.h>
#include <svd/geometry/SensorInfo.h>
#include <vxd/geometry/GeoCache.h>
#include <string>
#include <memory>
#include <map>
#include <vxd/background/niel_fun.h>
 
namespace Belle2 {
  namespace SVD {
 
    /* Modification Jan 2016:
     * 1. Delete all histogramming, only produce n-tuples and text file
     * with summaries. The HistogramFactory class is not used any longer.
     * All drawing will be done in pandas.
     * 2. Only process one background component at a time.
     * 3. Add occupancy estimates and a separate ntuple to hold the data.
     */
    /* Modifications Feb 2016:
     * Add more information on fired strips rate and related occupancy estmates:
     * 1. Two strip firing rates:
     * - one with threshold equal to threshold cut, to provide check for occupancy estimates
     * - another with threshold equal to elNoise
     * 2. Two occupancies:
     * - one for time of 1 APV cycle, no SNR adjustment
     * - one for trigger jitter of 5 ns + testbeam-based hit time error
     *
     * Make module functionality switchable:
     * - Add module parameters to turn on/off dose, neutron flux, and occupancy data collection.
     */
 
    class SVDBackgroundModule: public Module {
 
    public:
      static const int c_nVXDLayers = 6;
 
      // Reporting levels
      static const unsigned short c_reportNone = 0; 
      static const unsigned short c_reportSummary = 1; 
      static const unsigned short c_reportNTuple = 2; 
      struct SensorData {
        double m_expo;
        double m_dose;
        double m_neutronFlux;
        double m_firedU;
        double m_firedV;
        double m_firedU_t;
        double m_firedV_t;
        double m_occupancyU;
        double m_occupancyV;
        double m_occupancyU_APV;
        double m_occupancyV_APV;
      };
 
      SVDBackgroundModule();
      virtual ~SVDBackgroundModule();
 
      /* Initialize module */
      virtual void initialize() override;
      /* Start-of-run initializations */
      virtual void beginRun() override;
      /* Event processing */
      virtual void event() override;
      /* End-of-run tasks */
      virtual void endRun() override;
      /* Final summary and cleanup */
      virtual void terminate() override;
 
    private:
 
      // General
      const double c_densitySi = 2.3290 * Unit::g_cm3; 
      const double c_smy = 1.0e7 * Unit::s;             
      const double c_APVCycleTime = 31.44 * Unit::ns;   
      // NIEL file names - placed in vxd/data, so needn't be module parameters.
      const std::string c_niel_neutronFile = "/vxd/data/neutrons.csv";
      const std::string c_niel_protonFile = "/vxd/data/protons.csv";
      const std::string c_niel_pionFile = "/vxd/data/pions.csv";
      const std::string c_niel_electronFile = "/vxd/data/electrons.csv";
      // No NIEL for photons.
 
      inline const SVD::SensorInfo& getInfo(VxdID sensorID) const;
      inline double getSensorThickness(VxdID sensorID) const;
      inline double getSensorMass(VxdID sensorID) const;
      inline double getSensorArea(VxdID sensorID) const;
 
      const TVector3& pointToGlobal(VxdID sensorID, const TVector3& local);
      const TVector3& vectorToGlobal(VxdID sensorID, const TVector3& local);
 
      inline int getNumSensors(int layerNum);
      inline int getTotalSensors();
 
      // Output directory
      std::string m_outputDirectoryName; 
      std::string m_storeFileMetaDataName; 
      std::string m_storeBgMetaDataName; 
      // StoreArrays
      std::string m_storeMCParticlesName; 
      std::string m_storeSimHitsName; 
      std::string m_storeTrueHitsName; 
      std::string m_relParticlesTrueHitsName; 
      std::string m_storeDigitsName; 
      std::string m_relDigitsMCParticlesName; 
      std::string m_relDigitsTrueHitsName; 
      std::string m_storeClustersName; 
      std::string m_relClusterDigitName; 
      std::string m_relTrueHitsSimHitsName;  
      std::string m_storeEnergyDepositsName; 
      std::string m_storeNeutronFluxesName; 
      std::string m_storeOccupancyEventsName; 
      unsigned short m_doseReportingLevel; 
      unsigned short m_nfluxReportingLevel; 
      unsigned short m_occupancyReportingLevel; 
      std::string m_componentName; 
      double m_componentTime; 
      double m_triggerWidth; 
      double m_acceptanceWidth; 
      std::map<VxdID, SensorData> m_sensorData; 
      // NIEL tables
      std::unique_ptr<TNiel> m_nielNeutrons;  
      std::unique_ptr<TNiel> m_nielProtons;   
      std::unique_ptr<TNiel> m_nielPions;     
      std::unique_ptr<TNiel> m_nielElectrons; 
    };
 
    inline const SVD::SensorInfo& SVDBackgroundModule::getInfo(VxdID sensorID) const
    {
      return dynamic_cast<const SVD::SensorInfo&>(VXD::GeoCache::get(sensorID));
    }
 
    inline  double SVDBackgroundModule::getSensorThickness(VxdID sensorID) const
    {
      return getInfo(sensorID).getThickness();
    }
 
    inline  double SVDBackgroundModule::getSensorMass(VxdID sensorID) const
    {
      const SVD::SensorInfo& info = getInfo(sensorID);
      return info.getWidth() * info.getLength() * info.getThickness() * c_densitySi;
    }
 
    inline  double SVDBackgroundModule::getSensorArea(VxdID sensorID) const
    {
      const SVD::SensorInfo& info = getInfo(sensorID);
      return info.getWidth() * info.getLength();
    }
 
    inline int SVDBackgroundModule::getNumSensors(int layerNum)
    {
      VxdID layerID;
      layerID.setLayerNumber(layerNum);
      int result = 0;
      for (auto ladderID : VXD::GeoCache::getInstance().getLadders(layerID))
        result += VXD::GeoCache::getInstance().getSensors(ladderID).size();
      return result;
    }
 
    inline int SVDBackgroundModule::getTotalSensors()
    {
      int result = 0;
      for (auto layerID : VXD::GeoCache::getInstance().getLayers(VXD::SensorInfoBase::SVD))
        result += getNumSensors(layerID.getLayerNumber());
      return result;
    }
  } // namespace SVD
} // namespace Belle2
#endif