PXDBgTupleProducerModule.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 <vxd/geometry/SensorInfoBase.h>
#include <pxd/geometry/SensorInfo.h>
#include <vxd/geometry/GeoCache.h>
#include <string>
#include <vector>
#include <map>
 
 
namespace Belle2 {
 
  namespace PXD {

    class PXDBgTupleProducerModule: public Module {
 
    public:

      struct SensorData {
        int m_run;
        int m_nEvents;
        double m_minOccupancy;
        double m_maxOccupancy;
        double m_meanOccupancy;
        double m_expo;
        double m_dose;
        double m_softPhotonFlux;
        double m_chargedParticleFlux;
        double m_hardPhotonFlux;

        std::vector<double> m_regionExpoMap;
        std::vector<double> m_regionDoseMap;
        std::vector<double> m_regionSoftPhotonFluxMap;
        std::vector<double> m_regionChargedParticleFluxMap;
        std::vector<double> m_regionHardPhotonFluxMap;
      };

      PXDBgTupleProducerModule();

      void initialize() override final;
      void beginRun() override final;
      void event() override final;
      void terminate() override final;
 
    private:
 
      // General
      const double c_densitySi = 2.3290 * Unit::g_cm3; 

      inline const PXD::SensorInfo& getInfo(VxdID sensorID) const;
      inline double getSensorArea(VxdID sensorID) const;
      inline int getRegionID(int uBin, int vBin) const;
      inline double getRegionArea(VxdID sensorID, int vBin) const;
 
      // Output directory
      std::string m_outputFileName; 
 
      // StoreArrays
      std::string m_storeClustersName; 
      std::string m_storeDigitsName; 
      double m_integrationTime; 
      double m_timePeriod; 
      bool m_maskDeadPixels; 
      int m_nBinsU; 
      int m_nBinsV; 
 
      int m_nPXDSensors; 
 
      std::map<VxdID, SensorData> m_sensorData; 
      std::map<unsigned long long int,  std::map<VxdID, SensorData> > m_buffer; 
      std::map<VxdID, int> m_sensitivePixelMap; 
      std::map<VxdID, double> m_sensitiveAreaMap; 
      std::map<std::pair<VxdID, int>, int> m_regionSensitivePixelMap; 
      std::map<std::pair<VxdID, int>, double> m_regionSensitiveAreaMap; 
      bool m_hasPXDData; 
 
    };
 
    inline int PXDBgTupleProducerModule::getRegionID(int uBin, int vBin) const
    {
      return uBin * m_nBinsV + vBin;
    }
 
    inline const PXD::SensorInfo& PXDBgTupleProducerModule::getInfo(VxdID sensorID) const
    {
      return dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
    }
 
    inline  double PXDBgTupleProducerModule::getSensorArea(VxdID sensorID) const
    {
      const PXD::SensorInfo& info = getInfo(sensorID);
      return info.getWidth() * info.getLength();
    }
 
    inline  double PXDBgTupleProducerModule::getRegionArea(VxdID sensorID, int vBin) const
    {
      const PXD::SensorInfo& info = getInfo(sensorID);
      int vi = vBin * info.getVCells() / m_nBinsV;
      double length = info.getVPitch(info.getVCellPosition(vi)) * info.getVCells() / m_nBinsV;
      return length * info.getWidth() / m_nBinsU;
    }
 
  } // namespace PXD
} // namespace Belle2