hcalCalibUtils.h File Reference

#include <vector>
#include <map>
#include "Rtypes.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "Calibration/HcalCalibAlgos/src/TCell.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"

Go to the source code of this file.

Functions
void	combinePhi (std::vector< TCell > &selectCells)
void	combinePhi (std::vector< TCell > &selectCells, std::vector< TCell > &combinedCells)
void	filterCells3x3 (std::vector< TCell > &selectCells, Int_t iEta, UInt_t iPhi)
void	filterCells5x5 (std::vector< TCell > &selectCells, Int_t iEta, UInt_t iPhi)
void	filterCellsInCone (std::vector< TCell > &selectCells, const GlobalPoint hitPositionHcal, Float_t maxConeDist, const CaloGeometry *theCaloGeometry)
void	getIEtaIPhiForHighestE (std::vector< TCell > &selectCells, Int_t &iEta, UInt_t &iPhi)
void	sumDepths (std::vector< TCell > &selectCells)
void	sumSmallDepths (std::vector< TCell > &selectCells)

Function Documentation

combinePhi() [1/2]

void combinePhi

(

std::vector< TCell > &

selectCells

)

Definition at line 89 of file hcalCalibUtils.cc.

                                               {
  // Map: NxN -> N cluster
  // Comine the targetE of cells with the same iEta
 
  if (selectCells.empty())
    return;
 
  // new container for the TCells
  // dummy cell id created with iEta; iPhi=1; depth
  // if combinePhi() is run after combining depths, depth=1
  std::vector<TCell> combinedCells;
 
  std::map<UInt_t, std::vector<Float_t> > etaSliceE;  // keyed by id of cell with iEta and **iPhi=1**
 
  // map the cells to the eta ring
  std::vector<TCell>::iterator i_it = selectCells.begin();
  for (; i_it != selectCells.end(); ++i_it) {
    DetId id = HcalDetId(i_it->id());
    UInt_t thisKey = HcalDetId(HcalDetId(id).subdet(), HcalDetId(id).ieta(), 1, HcalDetId(id).depth());
    etaSliceE[thisKey].push_back(i_it->e());
  }
 
  std::map<UInt_t, std::vector<Float_t> >::iterator m_it = etaSliceE.begin();
  for (; m_it != etaSliceE.end(); ++m_it) {
    combinedCells.push_back(TCell(m_it->first, accumulate(m_it->second.begin(), m_it->second.end(), 0.0)));
  }
 
  // replace the original TCell vector with the new one
  selectCells = combinedCells;
}

References LEDCalibrationChannels::depth, and LEDCalibrationChannels::ieta.

Referenced by hcalCalib::Process().

combinePhi() [2/2]

void combinePhi	(	std::vector< TCell > &	selectCells,
		std::vector< TCell > &	combinedCells
	)

Definition at line 120 of file hcalCalibUtils.cc.

                                                                                {
  // Map: NxN -> N cluster
  // Comine the targetE of cells with the same iEta
 
  if (selectCells.empty())
    return;
 
  std::map<UInt_t, std::vector<Float_t> > etaSliceE;  // keyed by id of cell with iEta and **iPhi=1**
 
  // map the cells to the eta ring
  std::vector<TCell>::iterator i_it = selectCells.begin();
  for (; i_it != selectCells.end(); ++i_it) {
    DetId id = HcalDetId(i_it->id());
    UInt_t thisKey = HcalDetId(HcalDetId(id).subdet(), HcalDetId(id).ieta(), 1, HcalDetId(id).depth());
    etaSliceE[thisKey].push_back(i_it->e());
  }
 
  std::map<UInt_t, std::vector<Float_t> >::iterator m_it = etaSliceE.begin();
  for (; m_it != etaSliceE.end(); ++m_it) {
    combinedCells.push_back(TCell(m_it->first, accumulate(m_it->second.begin(), m_it->second.end(), 0.0)));
  }
}

References LEDCalibrationChannels::depth, and LEDCalibrationChannels::ieta.

filterCells3x3()

void filterCells3x3	(	std::vector< TCell > &	selectCells,
		Int_t	iEta,
		UInt_t	iPhi
	)

Definition at line 172 of file hcalCalibUtils.cc.

                                                                                    {
  std::vector<TCell> filteredCells;
 
  Int_t dEta, dPhi;
 
  for (std::vector<TCell>::iterator it = selectCells.begin(); it != selectCells.end(); ++it) {
    Bool_t passDEta = false;
    Bool_t passDPhi = false;
 
    dEta = HcalDetId(it->id()).ieta() - iEtaMaxE;
    dPhi = HcalDetId(it->id()).iphi() - iPhiMaxE;
 
    if (dPhi > 36)
      dPhi -= 72;
    if (dPhi < -36)
      dPhi += 72;
 
    if (abs(dEta) <= 1 || (iEtaMaxE * HcalDetId(it->id()).ieta() == -1))
      passDEta = true;
 
    if (abs(iEtaMaxE) <= 20) {
      if (abs(HcalDetId(it->id()).ieta()) <= 20) {
        if (abs(dPhi) <= 1)
          passDPhi = true;
      } else {
        // iPhi is labelled by odd numbers
        if (iPhiMaxE % 2 == 0) {
          if (abs(dPhi) <= 1)
            passDPhi = true;
        } else {
          if (dPhi == -2 || dPhi == 0)
            passDPhi = true;
        }
      }
 
    }  // if hottest cell with iEta<=20
 
    else {
      if (abs(HcalDetId(it->id()).ieta()) <= 20) {
        if (abs(dPhi) <= 1 || dPhi == 2)
          passDPhi = true;
      } else {
        if (abs(dPhi) <= 2)
          passDPhi = true;
      }
    }  // if hottest cell with iEta>20
 
    if (passDEta && passDPhi)
      filteredCells.push_back(*it);
  }
 
  selectCells = filteredCells;
 
  return;
}

References funct::abs(), HLT_FULL_cff::dEta, HLT_FULL_cff::dPhi, LEDCalibrationChannels::ieta, and LEDCalibrationChannels::iphi.

Referenced by hcalCalib::Process().

filterCells5x5()

void filterCells5x5	(	std::vector< TCell > &	selectCells,
		Int_t	iEta,
		UInt_t	iPhi
	)

Definition at line 236 of file hcalCalibUtils.cc.

                                                                                    {
  std::vector<TCell> filteredCells;
 
  Int_t dEta, dPhi;
 
  for (std::vector<TCell>::iterator it = selectCells.begin(); it != selectCells.end(); ++it) {
    dEta = HcalDetId(it->id()).ieta() - iEtaMaxE;
    dPhi = HcalDetId(it->id()).iphi() - iPhiMaxE;
 
    if (dPhi > 36)
      dPhi -= 72;
    if (dPhi < -36)
      dPhi += 72;
 
    bool passDPhi = (abs(dPhi) < 3);
 
    bool passDEta = (abs(dEta) < 3 || (iEtaMaxE * HcalDetId(it->id()).ieta() == -2));
    // includes  +/- eta boundary
 
    if (passDPhi && passDEta)
      filteredCells.push_back(*it);
  }
 
  selectCells = filteredCells;
 
  return;
}

References funct::abs(), HLT_FULL_cff::dEta, HLT_FULL_cff::dPhi, LEDCalibrationChannels::ieta, and LEDCalibrationChannels::iphi.

Referenced by hcalCalib::Process().

filterCellsInCone()

void filterCellsInCone	(	std::vector< TCell > &	selectCells,
		const GlobalPoint	hitPositionHcal,
		Float_t	maxConeDist,
		const CaloGeometry *	theCaloGeometry
	)

Definition at line 325 of file hcalCalibUtils.cc.

                                                            {
  std::vector<TCell> filteredCells;
 
  for (std::vector<TCell>::iterator it = selectCells.begin(); it != selectCells.end(); ++it) {
    GlobalPoint recHitPoint;
    DetId id = it->id();
    if (id.det() == DetId::Hcal) {
      recHitPoint = (static_cast<const HcalGeometry*>(theCaloGeometry->getSubdetectorGeometry(id)))->getPosition(id);
    } else {
      recHitPoint = GlobalPoint(theCaloGeometry->getPosition(id));
    }
 
    if (getDistInPlaneSimple(hitPositionHcal, recHitPoint) <= maxConeDist)
      filteredCells.push_back(*it);
  }
 
  selectCells = filteredCells;
 
  return;
}

References getDistInPlaneSimple(), CaloGeometry::getPosition(), CaloGeometry::getSubdetectorGeometry(), and DetId::Hcal.

Referenced by hcalCalib::Process().

getIEtaIPhiForHighestE()

void getIEtaIPhiForHighestE	(	std::vector< TCell > &	selectCells,
		Int_t &	iEta,
		UInt_t &	iPhi
	)

Definition at line 143 of file hcalCalibUtils.cc.

                                                                                                {
  std::vector<TCell> summedDepthsCells = selectCells;
 
  sumDepths(summedDepthsCells);
  std::vector<TCell>::iterator highCell = summedDepthsCells.begin();
 
  // sum depths locally to get highest energy tower
 
  Float_t highE = -999;
 
  for (std::vector<TCell>::iterator it = summedDepthsCells.begin(); it != summedDepthsCells.end(); ++it) {
    if (highE < it->e()) {
      highCell = it;
      highE = it->e();
    }
  }
 
  iEtaMostE = HcalDetId(highCell->id()).ieta();
  iPhiMostE = HcalDetId(highCell->id()).iphi();
 
  return;
}

References MillePedeFileConverter_cfg::e, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, and sumDepths().

Referenced by hcalCalib::Process().

sumDepths()

void sumDepths

(

std::vector< TCell > &

selectCells

)

Definition at line 15 of file hcalCalibUtils.cc.

                                              {
  // Assignes teh sum of the energy in cells with the same iEta, iPhi to the cell with depth=1.
  // All cells with depth>1 are removed form the container. If
  // the cell at depth=1 is not present: create it and follow the procedure.
 
  if (selectCells.empty())
    return;
 
  std::vector<TCell> selectCellsDepth1;
  std::vector<TCell> selectCellsHighDepth;
 
  //
  // NB: Here we add depth 3 for iEta==16 in *HE* to the value in the barrel
  // this approach is reflected in several of the following loops: make sure
  // to check when making changes.
  //
  // In some documents it is described as having depth 1, the mapping in CMSSW uses depth 3.
 
  for (std::vector<TCell>::iterator i_it = selectCells.begin(); i_it != selectCells.end(); ++i_it) {
    if (HcalDetId(i_it->id()).depth() == 1) {
      selectCellsDepth1.push_back(*i_it);
    } else {
      selectCellsHighDepth.push_back(*i_it);
    }
  }
 
  // case where depth 1 has zero energy, but higher depths with same (iEta, iPhi) have energy.
  // For iEta<15 there is one depth -> selectCellsHighDepth is empty and we do not get in the loop.
  for (std::vector<TCell>::iterator i_it2 = selectCellsHighDepth.begin(); i_it2 != selectCellsHighDepth.end();
       ++i_it2) {
    // protect against corrupt data
    if (HcalDetId(i_it2->id()).ietaAbs() < 15 && HcalDetId(i_it2->id()).depth() > 1) {
      edm::LogWarning("HcalCalib") << "ERROR!!! there are no HB cells with depth>1 for iEta<15!\n"
                                   << "Check the input data...\nHCalDetId: " << HcalDetId(i_it2->id());
      return;
    }
 
    bool foundDepthOne = false;
    for (std::vector<TCell>::iterator i_it = selectCellsDepth1.begin(); i_it != selectCellsDepth1.end(); ++i_it) {
      if (HcalDetId(i_it->id()).ieta() == HcalDetId(i_it2->id()).ieta() &&
          HcalDetId(i_it->id()).iphi() == HcalDetId(i_it2->id()).iphi())
        foundDepthOne = true;
      continue;
    }
    if (!foundDepthOne) {  // create entry for depth 1 with 0 energy
 
      UInt_t newId;
      if (abs(HcalDetId(i_it2->id()).ieta()) == 16)
        newId = HcalDetId(HcalBarrel, HcalDetId(i_it2->id()).ieta(), HcalDetId(i_it2->id()).iphi(), 1);
      else
        newId =
            HcalDetId(HcalDetId(i_it2->id()).subdet(), HcalDetId(i_it2->id()).ieta(), HcalDetId(i_it2->id()).iphi(), 1);
 
      selectCellsDepth1.push_back(TCell(newId, 0.0));
    }
  }
 
  for (std::vector<TCell>::iterator i_it = selectCellsDepth1.begin(); i_it != selectCellsDepth1.end(); ++i_it) {
    for (std::vector<TCell>::iterator i_it2 = selectCellsHighDepth.begin(); i_it2 != selectCellsHighDepth.end();
         ++i_it2) {
      if (HcalDetId(i_it->id()).ieta() == HcalDetId(i_it2->id()).ieta() &&
          HcalDetId(i_it->id()).iphi() == HcalDetId(i_it2->id()).iphi()) {
        i_it->SetE(i_it->e() + i_it2->e());
        i_it2->SetE(0.0);  // paranoid, aren't we...
      }
    }
  }
 
  // replace the original vectors with the new ones
  selectCells = selectCellsDepth1;
 
  return;
}

References funct::abs(), LEDCalibrationChannels::depth, HcalBarrel, LEDCalibrationChannels::ieta, and LEDCalibrationChannels::iphi.

Referenced by getIEtaIPhiForHighestE(), and hcalCalib::Process().

sumSmallDepths()

void sumSmallDepths

(

std::vector< TCell > &

selectCells

)

Definition at line 267 of file hcalCalibUtils.cc.

                                                   {
  if (selectCells.empty())
    return;
 
  std::vector<TCell> newCells;          // holds unaffected cells to which the modified ones are added
  std::vector<TCell> manipulatedCells;  // the ones that are combined
 
  for (std::vector<TCell>::iterator i_it = selectCells.begin(); i_it != selectCells.end(); ++i_it) {
    if ((HcalDetId(i_it->id()).ietaAbs() == 15 && HcalDetId(i_it->id()).depth() <= 2) ||
        (HcalDetId(i_it->id()).ietaAbs() == 16 && HcalDetId(i_it->id()).depth() <= 2)) {
      manipulatedCells.push_back(*i_it);
    } else {
      newCells.push_back(*i_it);
    }
  }
 
  // if the list is empty there is nothing to manipulate
  // leave the original vector unchanged
 
  if (manipulatedCells.empty()) {
    newCells.clear();
    return;
  }
 
  // See what cells are needed to hold the combined information:
  // Make holders for depth=1 for each (iEta,iPhi)
  // if a cell with these values is present in "manupulatedCells"
  std::vector<UInt_t> dummyIds;     // to keep track of kreated cells
  std::vector<TCell> createdCells;  // cells that need to be added or they exists;
 
  for (std::vector<TCell>::iterator i_it = manipulatedCells.begin(); i_it != manipulatedCells.end(); ++i_it) {
    UInt_t dummyId =
        HcalDetId(HcalDetId(i_it->id()).subdet(), HcalDetId(i_it->id()).ieta(), HcalDetId(i_it->id()).iphi(), 1);
    if (find(dummyIds.begin(), dummyIds.end(), dummyId) == dummyIds.end()) {
      dummyIds.push_back(dummyId);
      createdCells.push_back(TCell(dummyId, 0.0));
    }
  }
 
  for (std::vector<TCell>::iterator i_it = createdCells.begin(); i_it != createdCells.end(); ++i_it) {
    for (std::vector<TCell>::iterator i_it2 = manipulatedCells.begin(); i_it2 != manipulatedCells.end(); ++i_it2) {
      if (HcalDetId(i_it->id()).ieta() == HcalDetId(i_it2->id()).ieta() &&
          HcalDetId(i_it->id()).iphi() == HcalDetId(i_it2->id()).iphi() && HcalDetId(i_it2->id()).depth() <= 2) {
        i_it->SetE(i_it->e() + i_it2->e());
      }
    }
  }
 
  for (std::vector<TCell>::iterator i_it = createdCells.begin(); i_it != createdCells.end(); ++i_it) {
    newCells.push_back(*i_it);
  }
 
  // replace the original vectors with the new ones
  selectCells = newCells;
 
  return;
}

References LEDCalibrationChannels::depth, spr::find(), LEDCalibrationChannels::ieta, and LEDCalibrationChannels::iphi.

Referenced by hcalCalib::Process().