EcalEBTrigPrimTestAlgo.h

Go to the documentation of this file.

#ifndef EcalEBTrigPrimTestAlgo_h
#define EcalEBTrigPrimTestAlgo_h
 
#include <sys/time.h>
#include <iostream>
#include <vector>
 
#include "Geometry/EcalMapping/interface/EcalElectronicsMapping.h"
#include "Geometry/CaloTopology/interface/EcalTrigTowerConstituentsMap.h"
#include "DataFormats/EcalDetId/interface/EcalTriggerElectronicsId.h"
#include "DataFormats/Common/interface/SortedCollection.h"
//#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
 
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
 
#include <SimCalorimetry/EcalEBTrigPrimAlgos/interface/EcalFenixLinearizer.h>
#include <SimCalorimetry/EcalEBTrigPrimAlgos/interface/EcalFenixAmplitudeFilter.h>
#include <SimCalorimetry/EcalEBTrigPrimAlgos/interface/EcalFenixPeakFinder.h>
#include <SimCalorimetry/EcalEBTrigPrimAlgos/interface/EcalFenixStripFormatEB.h>
#include <SimCalorimetry/EcalEBTrigPrimAlgos/interface/EcalFenixTcpFormat.h>
 
#include <map>
#include <utility>
 
class EcalTrigTowerDetId;
class ETPCoherenceTest;
class EcalEBTriggerPrimitiveSample;
class CaloSubdetectorGeometry;
class EBDataFrame;
 
class EcalEBTrigPrimTestAlgo {
public:
  explicit EcalEBTrigPrimTestAlgo(
      const edm::EventSetup &setup, int nSamples, int binofmax, bool tcpFormat, bool barrelOnly, bool debug, bool famos);
 
  virtual ~EcalEBTrigPrimTestAlgo();
 
  //  void run(const edm::EventSetup &, const EcalRecHitCollection *col, EcalEBTrigPrimDigiCollection & result, EcalEBTrigPrimDigiCollection & resultTcp);
  void run(const edm::EventSetup &,
           const EBDigiCollection *col,
           EcalEBTrigPrimDigiCollection &result,
           EcalEBTrigPrimDigiCollection &resultTcp);
 
  void setPointers(const EcalTPGLinearizationConst *ecaltpLin,
                   const EcalTPGPedestals *ecaltpPed,
                   const EcalTPGCrystalStatus *ecaltpgBadX,
                   const EcalTPGWeightIdMap *ecaltpgWeightMap,
                   const EcalTPGWeightGroup *ecaltpgWeightGroup,
                   const EcalTPGSlidingWindow *ecaltpgSlidW,
                   const EcalTPGLutGroup *ecaltpgLutGroup,
                   const EcalTPGLutIdMap *ecaltpgLut,
                   const EcalTPGTowerStatus *ecaltpgBadTT,
                   const EcalTPGSpike *ecaltpgSpike) {
    ecaltpPed_ = ecaltpPed;
    ecaltpLin_ = ecaltpLin;
    ecaltpgBadX_ = ecaltpgBadX;
    ecaltpgWeightMap_ = ecaltpgWeightMap;
    ecaltpgWeightGroup_ = ecaltpgWeightGroup;
    ecaltpgSlidW_ = ecaltpgSlidW;
    ecaltpgLutGroup_ = ecaltpgLutGroup;
    ecaltpgLut_ = ecaltpgLut;
    ecaltpgBadTT_ = ecaltpgBadTT;
    ecaltpgSpike_ = ecaltpgSpike;
  }
 
private:
  void init(const edm::EventSetup &);
  template <class T>
  void initStructures(std::vector<std::vector<std::pair<int, std::vector<T> > > > &towMap);
  template <class T>
  void clean(std::vector<std::vector<std::pair<int, std::vector<T> > > > &towerMap);
  template <class Coll>
  void fillMap(Coll const *col,
               std::vector<std::vector<std::pair<int, std::vector<typename Coll::Digi> > > > &towerMap);
  int findStripNr(const EBDetId &id);
  int findStripNr(const EEDetId &id);
 
  // FIXME: temporary until hashedIndex works alsom for endcap
  int getIndex(const EBDigiCollection *, EcalTrigTowerDetId &id) { return id.hashedIndex(); }
  // mind that eta is continuous between barrel+endcap
  int getIndex(const EEDigiCollection *, EcalTrigTowerDetId &id) {
    int ind = (id.ietaAbs() - 18) * 72 + id.iphi();
    if (id.zside() < 0)
      ind += 792;
    return ind;
  }
 
  edm::ESHandle<EcalTrigTowerConstituentsMap> eTTmap_;
  //  const CaloSubdetectorGeometry *theEndcapGeometry;
  edm::ESHandle<CaloGeometry> theGeometry;
 
  float threshold;
  int nSamples_;
  int binOfMaximum_;
  int maxNrSamples_;
 
  bool tcpFormat_;
  bool barrelOnly_;
  bool debug_;
  bool famos_;
 
  int nrTowers_;  // nr of towers found by fillmap method
  static const unsigned int maxNrTowers_;
  static const unsigned int maxNrSamplesOut_;
  static const unsigned int nrSamples_;
 
  // data structures kept during the whole run
  std::vector<std::vector<int> > striptp_;
  std::vector<std::vector<std::pair<int, std::vector<EBDataFrame> > > > towerMapEB_;
  std::vector<std::vector<std::pair<int, std::vector<EEDataFrame> > > > towerMapEE_;
  std::vector<std::pair<int, EcalTrigTowerDetId> > hitTowers_;
  std::vector<EcalEBTriggerPrimitiveSample> towtp_;
  std::vector<EcalEBTriggerPrimitiveSample> towtp2_;
 
  enum { nbMaxStrips_ = 5 };
  enum { nbMaxXtals_ = 5 };
 
  const EcalElectronicsMapping *theMapping_;
 
  std::vector<EcalFenixLinearizer *> linearizer_;
  EcalFenixAmplitudeFilter *amplitude_filter_;
  EcalFenixPeakFinder *peak_finder_;
  EcalFenixStripFormatEB *fenixFormatterEB_;
  EcalFenixTcpFormat *fenixTcpFormat_;
 
  //
  const EcalTPGPedestals *ecaltpPed_;
  const EcalTPGLinearizationConst *ecaltpLin_;
  const EcalTPGCrystalStatus *ecaltpgBadX_;
  const EcalTPGWeightIdMap *ecaltpgWeightMap_;
  const EcalTPGWeightGroup *ecaltpgWeightGroup_;
  const EcalTPGSlidingWindow *ecaltpgSlidW_;
  const EcalTPGLutGroup *ecaltpgLutGroup_;
  const EcalTPGLutIdMap *ecaltpgLut_;
  const EcalTPGTowerStatus *ecaltpgBadTT_;
  const EcalTPGSpike *ecaltpgSpike_;
 
  EcalFenixLinearizer *getLinearizer(int i) const { return linearizer_[i]; }
  std::vector<std::vector<int> > lin_out_;
  //
  EcalFenixAmplitudeFilter *getFilter() const { return amplitude_filter_; }
  std::vector<int> filt_out_;
  std::vector<int> peak_out_;
  std::vector<int> format_out_;
  // these two are dummy
  std::vector<int> fgvb_out_;
  std::vector<int> fgvb_out_temp_;
 
  //
  EcalFenixPeakFinder *getPeakFinder() const { return peak_finder_; }
  EcalFenixStripFormatEB *getFormatterEB() const { return fenixFormatterEB_; }
  //
  EcalFenixTcpFormat *getFormatter() const { return fenixTcpFormat_; }
  std::vector<int> tcpformat_out_;
};
 
template <class T>
void EcalEBTrigPrimTestAlgo::clean(std::vector<std::vector<std::pair<int, std::vector<T> > > > &towMap) {
  // clean internal data structures
  for (unsigned int i = 0; i < maxNrTowers_; ++i)
    for (int j = 0; j < nbMaxStrips_; ++j)
      (towMap[i])[j].first = 0;
  return;
}
 
template <class Coll>
void EcalEBTrigPrimTestAlgo::fillMap(
    Coll const *col, std::vector<std::vector<std::pair<int, std::vector<typename Coll::Digi> > > > &towerMap) {
  typedef typename Coll::Digi Digi;
 
  // implementation for Barrel
  if (col) {
    nrTowers_ = 0;
    if (debug_)
      std::cout << "Fill mapping, Collection size = " << col->size() << std::endl;
    ;
    for (unsigned int i = 0; i < col->size(); ++i) {
      Digi samples((*col)[i]);
      EcalTrigTowerDetId coarser = (*eTTmap_).towerOf(samples.id());
      int index = getIndex(col, coarser);
      int stripnr = findStripNr(samples.id());
 
      int filled = 0;
      for (unsigned int ij = 0; ij < towerMap[index].size(); ++ij)
        filled += towerMap[index][ij].first;
      if (!filled) {
        hitTowers_[nrTowers_++] = std::pair<int, EcalTrigTowerDetId>(index, coarser);
      }
 
      //FIXME: temporary protection
      int ncryst = towerMap[index][stripnr - 1].first;
      if (ncryst >= nbMaxXtals_) {
        edm::LogError("EcalTrigPrimFunctionAlgo")
            << "! Too many xtals for TT " << coarser << " stripnr " << stripnr << " xtalid " << samples.id();
        continue;
      }
      ((towerMap[index])[stripnr - 1].second)[ncryst] = samples;
      (towerMap[index])[stripnr - 1].first++;
    }
 
    if (debug_)
      std::cout << "fillMap"
                << "[EcalTrigPrimFunctionalAlgo] (found " << col->size() << " frames in " << towerMap.size()
                << " towers) " << std::endl;
  } else {
    if (debug_)
      std::cout << "FillMap - FillMap Collection size=0 !!!!" << std::endl;
    ;
  }
}
 
template <class T>
void EcalEBTrigPrimTestAlgo::initStructures(std::vector<std::vector<std::pair<int, std::vector<T> > > > &towMap) {
  //initialise internal data structures
 
  std::vector<T> vec0(nbMaxXtals_);
  std::vector<std::pair<int, std::vector<T> > > vec1(nbMaxStrips_);
  for (int i = 0; i < nbMaxStrips_; ++i)
    vec1[i] = std::pair<int, std::vector<T> >(0, vec0);
  towMap.resize(maxNrTowers_);
  for (unsigned int i = 0; i < maxNrTowers_; ++i)
    towMap[i] = vec1;
 
  std::vector<int> vecint(maxNrSamples_);
  striptp_.resize(nbMaxStrips_);
  for (int i = 0; i < nbMaxStrips_; ++i)
    striptp_[i] = vecint;
}
 
#endif