EcalTimeMapDigitizer.cc

Go to the documentation of this file.

#include "SimCalorimetry/EcalSimAlgos/interface/EcalTimeMapDigitizer.h"
 
#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
#include "Geometry/CaloGeometry/interface/TruncatedPyramid.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
//#include "FWCore/ServiceRegistry/interface/Service.h"
//#include "FWCore/Utilities/interface/RandomNumberGenerator.h"
//#include "CLHEP/Random/RandPoissonQ.h"
//#include "CLHEP/Random/RandGaussQ.h"
 
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/isFinite.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "CLHEP/Units/GlobalPhysicalConstants.h"
#include "CLHEP/Units/GlobalSystemOfUnits.h"
 
#include <iostream>
 
//#define ecal_time_debug 1
 
const float EcalTimeMapDigitizer::MIN_ENERGY_THRESHOLD =
    5e-5;  //50 KeV threshold to consider a valid hit in the timing detector
 
EcalTimeMapDigitizer::EcalTimeMapDigitizer(EcalSubdetector myDet) : m_subDet(myDet), m_geometry(nullptr) {
  //    edm::Service<edm::RandomNumberGenerator> rng ;
  //    if ( !rng.isAvailable() )
  //    {
  //       throw cms::Exception("Configuration")
  //     << "EcalTimeMapDigitizer requires the RandomNumberGeneratorService\n"
  //     "which is not present in the configuration file.  You must add the service\n"
  //     "in the configuration file or remove the modules that require it.";
  //    }
  //    m_RandPoisson = new CLHEP::RandPoissonQ( rng->getEngine() ) ;
  //    m_RandGauss   = new CLHEP::RandGaussQ(   rng->getEngine() ) ;
 
  unsigned int size = 0;
  DetId detId(0);
 
  //Initialize the map
  if (myDet == EcalBarrel) {
    size = EBDetId::kSizeForDenseIndexing;
    detId = EBDetId::detIdFromDenseIndex(0);
  } else if (myDet == EcalEndcap) {
    size = EEDetId::kSizeForDenseIndexing;
    detId = EEDetId::detIdFromDenseIndex(0);
  } else
    edm::LogError("TimeDigiError") << "[EcalTimeMapDigitizer]::ERROR::This subdetector " << myDet
                                   << " is not implemented";
 
  assert(m_maxBunch - m_minBunch + 1 <= 10);
  assert(m_minBunch <= 0);
 
  m_vSam.reserve(size);
 
  for (unsigned int i(0); i != size; ++i) {
    //       m_vSam.emplace_back(CaloGenericDetId( detId.det(), detId.subdetId(), i ) ,
    //            m_maxBunch-m_minBunch+1, abs(m_minBunch) );
    m_vSam.emplace_back(TimeSamples(CaloGenericDetId(detId.det(), detId.subdetId(), i)));
  }
 
  edm::LogInfo("TimeDigiInfo") << "[EcalTimeDigitizer]::Subdetector " << m_subDet << "::Reserved size for time digis "
                               << m_vSam.size();
 
#ifdef ecal_time_debug
  std::cout << "[EcalTimeDigitizer]::Subdetector " << m_subDet << "::Reserved size for time digis " << m_vSam.size()
            << std::endl;
#endif
}
 
EcalTimeMapDigitizer::~EcalTimeMapDigitizer() {}
 
void EcalTimeMapDigitizer::add(const std::vector<PCaloHit>& hits, int bunchCrossing) {
  if (bunchCrossing >= m_minBunch && bunchCrossing <= m_maxBunch) {
    for (std::vector<PCaloHit>::const_iterator it = hits.begin(), itEnd = hits.end(); it != itEnd; ++it) {
      //here goes the map logic
 
      if (edm::isNotFinite((*it).time()))
        continue;
 
      //Just consider only the hits belonging to the specified time layer
      int depth2 = (((*it).depth() >> PCaloHit::kEcalDepthOffset) & PCaloHit::kEcalDepthMask);
 
      if (depth2 != m_timeLayerId)
        continue;
 
      if ((*it).energy() < MIN_ENERGY_THRESHOLD)  //apply a minimal cut on the hit energy
        continue;
 
      const DetId detId((*it).id());
 
      double time = (*it).time();
 
      //time of flight is not corrected here for the vertex position
      const double jitter(time - timeOfFlight(detId, m_timeLayerId));
 
      TimeSamples& result(*findSignal(detId));
 
      //here fill the result for the given bunch crossing
      result.average_time[bunchCrossing - m_minBunch] += jitter * (*it).energy();
      result.tot_energy[bunchCrossing - m_minBunch] += (*it).energy();
      result.nhits[bunchCrossing - m_minBunch]++;
 
#ifdef ecal_time_debug
      std::cout << (*it).id() << "\t" << (*it).depth() << "\t" << jitter << "\t" << (*it).energy() << "\t"
                << result.average_time[bunchCrossing - m_minBunch] << "\t" << result.nhits[bunchCrossing - m_minBunch]
                << "\t" << timeOfFlight(detId, m_timeLayerId) << std::endl;
#endif
    }
  }
}
 
EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::findSignal(const DetId& detId) {
  const unsigned int di(CaloGenericDetId(detId).denseIndex());
  TimeSamples* result(vSamAll(di));
  if (result->zero())
    m_index.push_back(di);
  return result;
}
 
void EcalTimeMapDigitizer::setGeometry(const CaloSubdetectorGeometry* geometry) { m_geometry = geometry; }
 
void EcalTimeMapDigitizer::blankOutUsedSamples()  // blank out previously used elements
{
  const unsigned int size(m_index.size());
 
  for (unsigned int i(0); i != size; ++i) {
#ifdef ecal_time_debug
    std::cout << "Zeroing " << m_index[i] << std::endl;
#endif
    vSamAll(m_index[i])->setZero();
  }
 
  m_index.erase(m_index.begin(),  // done and make ready to start over
                m_index.end());
}
 
void EcalTimeMapDigitizer::finalizeHits() {
  //Getting the size from the actual hits
  const unsigned int size(m_index.size());
 
  //Here just averaging the MC truth
  for (unsigned int i(0); i != size; ++i) {
#ifdef ecal_time_debug
    std::cout << "Averaging " << m_index[i] << std::endl;
#endif
    vSamAll(m_index[i])->calculateAverage();
#ifdef ecal_time_debug
    for (unsigned int j(0); j != vSamAll(m_index[i])->time_average_capacity; ++j)
      std::cout << j << "\t" << vSamAll(m_index[i])->average_time[j] << "\t" << vSamAll(m_index[i])->nhits[j] << "\t"
                << vSamAll(m_index[i])->tot_energy[j] << std::endl;
#endif
  }
 
  //Noise can be added here
}
 
void EcalTimeMapDigitizer::initializeMap() {
#ifdef ecal_time_debug
  std::cout << "[EcalTimeMapDigitizer]::Zeroing the used samples" << std::endl;
#endif
  blankOutUsedSamples();
}
 
void EcalTimeMapDigitizer::run(EcalTimeDigiCollection& output) {
#ifdef ecal_time_debug
  std::cout << "[EcalTimeMapDigitizer]::Finalizing hits and fill output collection" << std::endl;
#endif
 
  //Do the time averages and add noise if simulated
  finalizeHits();
 
  //Until we do now simulated noise we can get the size from the index vector
  const unsigned int ssize(m_index.size());
 
  output.reserve(ssize);
 
  for (unsigned int i(0); i != ssize; ++i) {
#ifdef ecal_time_debug
    std::cout << "----- in digi loop " << i << std::endl;
#endif
 
    output.push_back(Digi(vSamAll(m_index[i])->id));
 
    unsigned int nTimeHits = 0;
    float timeHits[vSamAll(m_index[i])->time_average_capacity];
    unsigned int timeBX[vSamAll(m_index[i])->time_average_capacity];
 
    for (unsigned int j(0); j != vSamAll(m_index[i])->time_average_capacity; ++j)  //here sampling on the OOTPU
    {
      if (vSamAll(m_index[i])->nhits[j] > 0) {
        timeHits[nTimeHits] = vSamAll(m_index[i])->average_time[j];
        timeBX[nTimeHits++] = m_minBunch + j;
      }
    }
 
    output.back().setSize(nTimeHits);
 
    for (unsigned int j(0); j != nTimeHits; ++j)  //filling the !zero hits
    {
      output.back().setSample(j, timeHits[j]);
      if (timeBX[j] == 0) {
#ifdef ecal_time_debug
        std::cout << "setting interesting sample " << j << std::endl;
#endif
        output.back().setSampleOfInterest(j);
      }
    }
 
#ifdef ecal_time_debug
    std::cout << "digi " << output.back().id().rawId() << "\t" << output.back().size();
    if (output.back().sampleOfInterest() > 0)
      std::cout << "\tBX0 time " << output.back().sample(output.back().sampleOfInterest()) << std::endl;
    else
      std::cout << "\tNo in time hits" << std::endl;
#endif
  }
#ifdef ecal_time_debug
  std::cout << "[EcalTimeMapDigitizer]::Output collection size " << output.size() << std::endl;
#endif
}
 
double EcalTimeMapDigitizer::timeOfFlight(const DetId& detId, int layer) const {
  //not using the layer yet
  auto cellGeometry(m_geometry->getGeometry(detId));
  assert(nullptr != cellGeometry);
  GlobalPoint layerPos =
      (cellGeometry)->getPosition(double(layer) + 0.5);  //depth in mm in the middle of the layer position
  return layerPos.mag() * cm / c_light;
}
 
unsigned int EcalTimeMapDigitizer::samplesSize() const { return m_vSam.size(); }
 
unsigned int EcalTimeMapDigitizer::samplesSizeAll() const { return m_vSam.size(); }
 
const EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::operator[](unsigned int i) const { return &m_vSam[i]; }
 
EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::operator[](unsigned int i) { return &m_vSam[i]; }
 
EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::vSam(unsigned int i) { return &m_vSam[i]; }
 
EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::vSamAll(unsigned int i) { return &m_vSam[i]; }
 
const EcalTimeMapDigitizer::TimeSamples* EcalTimeMapDigitizer::vSamAll(unsigned int i) const { return &m_vSam[i]; }
 
int EcalTimeMapDigitizer::minBunch() const { return m_minBunch; }
 
int EcalTimeMapDigitizer::maxBunch() const { return m_maxBunch; }
 
EcalTimeMapDigitizer::VecInd& EcalTimeMapDigitizer::index() { return m_index; }
 
const EcalTimeMapDigitizer::VecInd& EcalTimeMapDigitizer::index() const { return m_index; }
 
// const EcalTimeMapDigitizer::TimeSamples*
// EcalTimeMapDigitizer::findDetId( const DetId& detId ) const
// {
//    const unsigned int di ( CaloGenericDetId( detId ).denseIndex() ) ;
//    return vSamAll( di ) ;
// }