PXDBackgroundModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/gearbox/Unit.h>
#include <vxd/dataobjects/VxdID.h>
#include <pxd/geometry/SensorInfo.h>
#include <vxd/geometry/GeoCache.h>
#include <string>
#include <memory>
#include <map>
#include <vxd/background/niel_fun.h>
 
namespace Belle2 {
 
  namespace PXD {

    class PXDBackgroundModule: public Module {
 
    public:
 
      // 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_fired;
        double m_occupancy;
      };

      PXDBackgroundModule();
      virtual ~PXDBackgroundModule() override;

      virtual void initialize() override;
      virtual void event() override;
      virtual void terminate() override;
 
    private:
 
      // General
      const double c_densitySi = 2.3290 * Unit::g_cm3; 
      const double c_smy = 1.0e7 * Unit::s;             
      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.

      static inline const PXD::SensorInfo& getInfo(const VxdID& sensorID);
      static inline double getSensorThickness(VxdID sensorID);
      inline double getSensorMass(VxdID sensorID) const;
      static inline double getSensorArea(VxdID sensorID);

      static const ROOT::Math::XYZVector& pointToGlobal(VxdID sensorID, const ROOT::Math::XYZVector& local);
      static const ROOT::Math::XYZVector& vectorToGlobal(VxdID sensorID, const ROOT::Math::XYZVector& local);

      static 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_integrationTime; 
 
      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 PXD::SensorInfo& PXDBackgroundModule::getInfo(const VxdID& sensorID)
    {
      return dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
    }
 
    inline  double PXDBackgroundModule::getSensorThickness(VxdID sensorID)
    {
      return getInfo(sensorID).getThickness();
    }
 
    inline  double PXDBackgroundModule::getSensorMass(VxdID sensorID) const
    {
      const PXD::SensorInfo& info = getInfo(sensorID);
      return info.getWidth() * info.getLength() * info.getThickness() * c_densitySi;
    }
 
    inline  double PXDBackgroundModule::getSensorArea(VxdID sensorID)
    {
      const PXD::SensorInfo& info = getInfo(sensorID);
      return info.getWidth() * info.getLength();
    }
 
    inline int PXDBackgroundModule::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;
    }
  } // namespace PXD
} // namespace Belle2