HcalFlexiHardcodeGeometryLoader Class Reference

#include <HcalFlexiHardcodeGeometryLoader.h>

Classes
struct	HBHOCellParameters
struct	HECellParameters
struct	HFCellParameters

Public Member Functions
	HcalFlexiHardcodeGeometryLoader (const edm::ParameterSet &)
CaloSubdetectorGeometry *	load (const HcalTopology &fTopology, const HcalDDDRecConstants &hcons)

Private Member Functions
void	fillHBHO (HcalGeometry *fGeometry, const std::vector< HBHOCellParameters > &fCells, bool fHB)
void	fillHE (HcalGeometry *fGeometry, const std::vector< HECellParameters > &fCells)
void	fillHF (HcalGeometry *fGeometry, const std::vector< HFCellParameters > &fCells)
std::vector< HBHOCellParameters >	makeHBCells (const HcalDDDRecConstants &hcons)
std::vector< HECellParameters >	makeHECells (const HcalDDDRecConstants &hcons)
std::vector< HECellParameters >	makeHECells_H2 ()
std::vector< HFCellParameters >	makeHFCells (const HcalDDDRecConstants &hcons)
std::vector< HBHOCellParameters >	makeHOCells ()

Private Attributes
double	DEGREE2RAD
bool	isBH_
int	MAX_HCAL_PHI

Detailed Description

Author

F.Ratnikov, UMd

Definition at line 18 of file HcalFlexiHardcodeGeometryLoader.h.

Constructor & Destructor Documentation

HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader

(

const edm::ParameterSet &

)

Definition at line 19 of file HcalFlexiHardcodeGeometryLoader.cc.

References DEGREE2RAD, M_PI, and MAX_HCAL_PHI.

                                                                                       {

  MAX_HCAL_PHI = 72;
  DEGREE2RAD = M_PI / 180.;
}

Member Function Documentation

void HcalFlexiHardcodeGeometryLoader::fillHBHO ( HcalGeometry *  fGeometry, const std::vector< HBHOCellParameters > &  fCells, bool  fHB  )

private

Definition at line 131 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::depth, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::dphi, PV3DBase< T, PVType, FrameType >::eta(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::etaMax, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::etaMin, CaloCellGeometry::getParmPtr(), HcalBarrel, HcalOuter, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::ieta, HcalGeometry::increaseReserve(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::iphi, HcalGeometry::newCellFast(), CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::phi, DetId::rawId(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::rMax, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::rMin, funct::sin(), x, y, z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by load().

                                                                                                                                                             {

  fGeometry->increaseReserve(fCells.size());
  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
    const HcalFlexiHardcodeGeometryLoader::HBHOCellParameters& param = fCells[iCell];
    HcalDetId hid (fHB ? HcalBarrel : HcalOuter, param.ieta, param.iphi, param.depth);
    float phiCenter = param.phi; // middle of the cell
    float etaCenter = 0.5*(param.etaMin + param.etaMax);
    float x = param.rMin* cos (phiCenter);
    float y = param.rMin* sin (phiCenter);
    float z = (param.ieta < 0) ? -(param.rMin*sinh(etaCenter)) : (param.rMin*sinh(etaCenter));
    // make cell geometry
    GlobalPoint refPoint (x,y,z); // center of the cell's face
    std::vector<CCGFloat> cellParams;
    cellParams.reserve (5);
    cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); // deta_half
    cellParams.push_back (0.5 * param.dphi);                    // dphi_half
    cellParams.push_back (0.5 * (param.rMax - param.rMin) * cosh (etaCenter)); // dr_half
    cellParams.push_back ( fabs( refPoint.eta() ) ) ;
    cellParams.push_back ( fabs( refPoint.z() ) ) ;
#ifdef EDM_ML_DEBUG
    std::cout << "HcalFlexiHardcodeGeometryLoader::fillHBHO-> " << hid 
          << " " << hid.rawId() << " " << std::hex << hid.rawId() 
          << std::dec << " " << hid << " " << refPoint << '/' 
          << cellParams [0] << '/' << cellParams [1] << '/' 
          << cellParams [2] << std::endl;
#endif
    fGeometry->newCellFast(refPoint,  refPoint,  refPoint, 
               CaloCellGeometry::getParmPtr(cellParams, 
                            fGeometry->parMgr(), 
                            fGeometry->parVecVec()),
               hid ) ;
  }
}

void HcalFlexiHardcodeGeometryLoader::fillHE ( HcalGeometry *  fGeometry, const std::vector< HECellParameters > &  fCells  )

private

Definition at line 292 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, HcalFlexiHardcodeGeometryLoader::HECellParameters::depth, HcalFlexiHardcodeGeometryLoader::HECellParameters::dphi, PV3DBase< T, PVType, FrameType >::eta(), HcalFlexiHardcodeGeometryLoader::HECellParameters::etaMax, HcalFlexiHardcodeGeometryLoader::HECellParameters::etaMin, CaloCellGeometry::getParmPtr(), HcalEndcap, HcalFlexiHardcodeGeometryLoader::HECellParameters::ieta, HcalGeometry::increaseReserve(), HcalFlexiHardcodeGeometryLoader::HECellParameters::iphi, isBH_, HcalGeometry::newCellFast(), CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), perp(), HcalFlexiHardcodeGeometryLoader::HECellParameters::phi, DetId::rawId(), funct::sin(), x, y, z, PV3DBase< T, PVType, FrameType >::z(), HcalFlexiHardcodeGeometryLoader::HECellParameters::zMax, and HcalFlexiHardcodeGeometryLoader::HECellParameters::zMin.

Referenced by load().

                                                                                                                                                {

  fGeometry->increaseReserve(fCells.size());
  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
    const HcalFlexiHardcodeGeometryLoader::HECellParameters& param = fCells[iCell];
    HcalDetId hid (HcalEndcap, param.ieta, param.iphi, param.depth);
    float phiCenter = param.phi; // middle of the cell
    float etaCenter = 0.5 * (param.etaMin + param.etaMax);
    int   iside     = (param.ieta >= 0) ? 1 : -1;
    float perp = param.zMin / sinh (etaCenter);
    float x = perp * cos (phiCenter);
    float y = perp * sin (phiCenter);
    float z = (isBH_) ? (iside*0.5*(param.zMin+param.zMax)) : (iside*param.zMin);
    // make cell geometry
    GlobalPoint refPoint (x,y,z); // center of the cell's face
    std::vector<CCGFloat> cellParams;
    cellParams.reserve (5);
    cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); //deta_half
    cellParams.push_back (0.5 * param.dphi);  // dphi_half
    cellParams.push_back (-0.5 * (param.zMax - param.zMin) / tanh (etaCenter)); // dz_half, "-" means edges in Z
    cellParams.push_back ( fabs( refPoint.eta() ) ) ;
    cellParams.push_back ( fabs( refPoint.z() ) ) ;
#ifdef EDM_ML_DEBUG
    std::cout << "HcalFlexiHardcodeGeometryLoader::fillHE-> " << hid << " "
          << hid.rawId() << " " << std::hex << hid.rawId() << std::dec
          << " " << hid << refPoint << '/' << cellParams [0] << '/' 
          << cellParams [1] << '/' << cellParams [2] << std::endl;
#endif
    fGeometry->newCellFast(refPoint,  refPoint,  refPoint, 
               CaloCellGeometry::getParmPtr(cellParams, 
                            fGeometry->parMgr(), 
                            fGeometry->parVecVec()),
               hid ) ;
  }
}

void HcalFlexiHardcodeGeometryLoader::fillHF ( HcalGeometry *  fGeometry, const std::vector< HFCellParameters > &  fCells  )

private

Definition at line 328 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, DEGREE2RAD, HcalFlexiHardcodeGeometryLoader::HFCellParameters::depth, HcalFlexiHardcodeGeometryLoader::HFCellParameters::dphi, HcalFlexiHardcodeGeometryLoader::HFCellParameters::eta, PV3DBase< T, PVType, FrameType >::eta(), CaloCellGeometry::getParmPtr(), HcalForward, HcalGeometry::increaseReserve(), SurfaceOrientation::inner, JetComb::kPhi, MAX_HCAL_PHI, HcalGeometry::newCellFast(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::nPhi, SurfaceOrientation::outer, CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), perp(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::phiFirst, HcalFlexiHardcodeGeometryLoader::HFCellParameters::phiStep, DetId::rawId(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::rMax, HcalFlexiHardcodeGeometryLoader::HFCellParameters::rMin, funct::sin(), x, y, z, HcalFlexiHardcodeGeometryLoader::HFCellParameters::zMax, and HcalFlexiHardcodeGeometryLoader::HFCellParameters::zMin.

Referenced by load().

                                                                                                                                                {

  fGeometry->increaseReserve(fCells.size());
  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
    const HcalFlexiHardcodeGeometryLoader::HFCellParameters& param = fCells[iCell];
    for (int kPhi = 0; kPhi < param.nPhi; ++kPhi) {
      int iPhi = param.phiFirst + kPhi*param.phiStep;
      HcalDetId hid (HcalForward, param.eta, iPhi, param.depth);
      // middle of the cell
      float phiCenter = ((iPhi-1)*360./MAX_HCAL_PHI + 0.5*param.dphi) * DEGREE2RAD;
      GlobalPoint inner (param.rMin, 0, param.zMin);
      GlobalPoint outer (param.rMax, 0, param.zMin);
      float iEta = inner.eta();
      float oEta = outer.eta();
      float etaCenter = 0.5 * ( iEta + oEta );
    
      float perp = param.zMin / sinh (etaCenter);
      float x = perp * cos (phiCenter);
      float y = perp * sin (phiCenter);
      float z = (param.eta > 0) ? param.zMin : -param.zMin;
      // make cell geometry
      GlobalPoint refPoint (x,y,z); // center of the cell's face
      std::vector<CCGFloat> cellParams;
      cellParams.reserve (5);
      cellParams.push_back (0.5 * ( iEta - oEta )); // deta_half
      cellParams.push_back (0.5 * param.dphi * DEGREE2RAD);  // dphi_half
      cellParams.push_back (0.5 * (param.zMax - param.zMin)); // dz_half
      cellParams.push_back ( fabs( refPoint.eta()));
      cellParams.push_back ( fabs( refPoint.z() ) ) ;
#ifdef EDM_ML_DEBUG
      std::cout << "HcalFlexiHardcodeGeometryLoader::fillHF-> " << hid << " " 
        << hid.rawId() << " " << std::hex << hid.rawId() << std::dec 
        << " " << hid << " " << refPoint << '/' << cellParams [0] 
        << '/' << cellParams [1] << '/' << cellParams [2] << std::endl;
#endif  
      fGeometry->newCellFast(refPoint,  refPoint,  refPoint, 
             CaloCellGeometry::getParmPtr(cellParams, 
                              fGeometry->parMgr(), 
                              fGeometry->parVecVec()),
             hid ) ;
    }
  }
}

CaloSubdetectorGeometry * HcalFlexiHardcodeGeometryLoader::load	(	const HcalTopology &	fTopology,
		const HcalDDDRecConstants &	hcons
	)

Definition at line 25 of file HcalFlexiHardcodeGeometryLoader.cc.

References CaloSubdetectorGeometry::allocateCorners(), CaloSubdetectorGeometry::allocatePar(), CaloSubdetectorGeometry::cornersMgr(), gather_cfg::cout, fillHBHO(), fillHE(), fillHF(), HcalTopology::getHFSize(), HcalTopologyMode::H2, HcalDDDRecConstants::isBH(), isBH_, HcalGeometry::k_NumberOfParametersPerShape, makeHBCells(), makeHECells(), makeHECells_H2(), makeHFCells(), makeHOCells(), HcalTopology::mode(), HcalTopology::ncells(), HcalGeometry::numberOfShapes(), CaloSubdetectorGeometry::parMgr(), and HcalGeometry::sortValidIds().

Referenced by HcalHardcodeGeometryEP::produceIdeal().

                                                                                                                              {
  HcalGeometry* hcalGeometry = new HcalGeometry (fTopology);
  if( 0 == hcalGeometry->cornersMgr() ) hcalGeometry->allocateCorners ( fTopology.ncells()+fTopology.getHFSize() );
  if( 0 == hcalGeometry->parMgr() ) hcalGeometry->allocatePar (hcalGeometry->numberOfShapes(),
                                   HcalGeometry::k_NumberOfParametersPerShape ) ;
  isBH_ = hcons.isBH();
#ifdef EDM_ML_DEBUG
  std::cout << "FlexiGeometryLoader initialize with ncells " 
        << fTopology.ncells() << " and shapes " 
        << hcalGeometry->numberOfShapes() << ":"
        << HcalGeometry::k_NumberOfParametersPerShape 
        << " with BH Flag " << isBH_ << std::endl;
#endif
  if (fTopology.mode() == HcalTopologyMode::H2) {  // TB geometry
    fillHBHO (hcalGeometry, makeHBCells(hcons), true);
    fillHBHO (hcalGeometry, makeHOCells(), false);
    fillHE (hcalGeometry, makeHECells_H2());
  } else { // regular geometry
    fillHBHO (hcalGeometry, makeHBCells(hcons), true);
    fillHBHO (hcalGeometry, makeHOCells(), false);
    fillHF (hcalGeometry, makeHFCells(hcons));
    fillHE (hcalGeometry, makeHECells(hcons));
  }
  //fast insertion of valid ids requires sort at end
  hcalGeometry->sortValidIds();
  return hcalGeometry;
}

std::vector< HcalFlexiHardcodeGeometryLoader::HBHOCellParameters > HcalFlexiHardcodeGeometryLoader::makeHBCells ( const HcalDDDRecConstants &  hcons )

private

Definition at line 55 of file HcalFlexiHardcodeGeometryLoader.cc.

References gather_cfg::cout, particleFlowClusterECALTimeSelected_cfi::depth, ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, plotBeamSpotDB::first, HcalDDDRecConstants::getConstHBHE(), HcalDDDRecConstants::getEtaBins(), mps_fire::i, gen::k, M_PI, MAX_HCAL_PHI, mps_fire::result, and edm::second().

Referenced by load().

                                                                                                                                           {

  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
  std::vector<std::pair<double,double> > gconsHB = hcons.getConstHBHE(0);
  std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(0);

#ifdef EDM_ML_DEBUG
  std::cout << "FlexiGeometryLoader called for " << etabins.size() 
        << " Eta Bins" << std::endl;
  for (unsigned int k=0; k<gconsHB.size(); ++k) {
    std::cout << "gconsHB[" << k << "] = " << gconsHB[k].first << " +- "
          << gconsHB[k].second << std::endl;
  }
#endif
  for (unsigned int i=0; i<etabins.size(); ++i) {
    int iring = (etabins[i].zside >= 0) ? etabins[i].ieta : -etabins[i].ieta;
    int depth = etabins[i].depthStart;
    double dphi = (etabins[i].phis.size() > 1) ? 
      (etabins[i].phis[1].second-etabins[i].phis[0].second) : 
      ((2.0*M_PI)/MAX_HCAL_PHI);
    for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
      int layf = etabins[i].layer[k].first-1;
      int layl = etabins[i].layer[k].second-1;
      double rmin = gconsHB[layf].first-gconsHB[layf].second;
      double rmax = gconsHB[layl].first+gconsHB[layl].second;
      for (unsigned int j=0; j<etabins[i].phis.size(); ++j) {
#ifdef EDM_ML_DEBUG
    std::cout << "HBRing " << iring << " eta " << etabins[i].etaMin << ":"
          << etabins[i].etaMax << " depth " << depth << " R " << rmin
          << ":" << rmax << " Phi " << etabins[i].phis[j].first << ":" 
          << etabins[i].phis[j].second << ":" << dphi << " layer[" << k 
          << "]: " << etabins[i].layer[k].first-1 << ":"
          << etabins[i].layer[k].second << std::endl;
#endif
    result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(iring, depth, etabins[i].phis[j].first, etabins[i].phis[j].second, dphi, rmin, rmax, etabins[i].etaMin, etabins[i].etaMax));
      }
      depth++;
    }
  }
  return result;
}

std::vector< HcalFlexiHardcodeGeometryLoader::HECellParameters > HcalFlexiHardcodeGeometryLoader::makeHECells ( const HcalDDDRecConstants &  hcons )

private

Definition at line 168 of file HcalFlexiHardcodeGeometryLoader.cc.

References gather_cfg::cout, particleFlowClusterECALTimeSelected_cfi::depth, ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, plotBeamSpotDB::first, HcalDDDRecConstants::getConstHBHE(), HcalDDDRecConstants::getEtaBins(), mps_fire::i, gen::k, M_PI, MAX_HCAL_PHI, mps_fire::result, edm::second(), and units().

Referenced by load().

                                                                                                                                         {

  std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> result;
  std::vector<std::pair<double,double> > gconsHE = hcons.getConstHBHE(1);
#ifdef EDM_ML_DEBUG
  std::cout << "HcalFlexiHardcodeGeometryLoader:HE with " << gconsHE.size()
        << " cells" << std::endl;
#endif
  if (gconsHE.size() > 0) {
    std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(1);

#ifdef EDM_ML_DEBUG
    std::cout << "FlexiGeometryLoader called for HE with " << etabins.size() 
          << " Eta Bins and " << gconsHE.size() << " depths" 
          << std::endl;
    for (unsigned int i=0; i<gconsHE.size(); ++i)
      std::cout << " Depth[" << i << "] = " << gconsHE[i].first << " +- " 
        << gconsHE[i].second;
    std::cout << std::endl;
#endif
    for (unsigned int i=0; i<etabins.size(); ++i) {
      int    iring = (etabins[i].zside >= 0) ? etabins[i].ieta : -etabins[i].ieta;
      int    depth = etabins[i].depthStart;
      double dphi = (etabins[i].phis.size() > 1) ? 
    (etabins[i].phis[1].second-etabins[i].phis[0].second) : 
    ((2.0*M_PI)/MAX_HCAL_PHI);
#ifdef EDM_ML_DEBUG
      std::cout << "FlexiGeometryLoader::Ring " << iring << " nphi " << nphi
        << " dstart " << depth << " dphi " << dphi << " units "
        << units << " fioff " << fioff << " layers "
        << etabins[i].layer.size() << std::endl;
#endif
      for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
    int layf = etabins[i].layer[k].first-1;
    int layl = etabins[i].layer[k].second-1;
    double zmin = gconsHE[layf].first-gconsHE[layf].second;
    double zmax = gconsHE[layl].first+gconsHE[layl].second;
    if (zmin < 1.0) {
      for (int k2=layf; k2<=layl; ++k2) {
        if (gconsHE[k2].first > 10) {
          zmin = gconsHE[k2].first-gconsHE[k2].second;
          break;
        }
      }
    }
    if (zmin >= zmax) zmax = zmin+10.;
    for (unsigned int j=0; j<etabins[i].phis.size(); ++j) {
#ifdef EDM_ML_DEBUG
      std::cout << "HERing " << iring << " eta " << etabins[i].etaMin << ":"
            << etabins[i].etaMax << " depth " << depth << " Z " << zmin
            << ":" << zmax << " Phi :" << etabins[i].phis[j].first 
            << ":" << etabins[i].phis[j].second << ":" << dphi 
            << " layer[" << k << "]: " << etabins[i].layer[k].first-1 
            << ":" << etabins[i].layer[k].second-1 << std::endl;
#endif
      result.push_back(HcalFlexiHardcodeGeometryLoader::HECellParameters(iring, depth, etabins[i].phis[j].first, etabins[i].phis[j].second, dphi, zmin, zmax, etabins[i].etaMin, etabins[i].etaMax));
    }
    depth++;
      }
    }
  }
  return result;
}

std::vector< HcalFlexiHardcodeGeometryLoader::HECellParameters > HcalFlexiHardcodeGeometryLoader::makeHECells_H2 ( )

private

Definition at line 234 of file HcalFlexiHardcodeGeometryLoader.cc.

References DEGREE2RAD, particleFlowClusterECALTimeSelected_cfi::depth, EnergyCorrector::etas, mps_fire::i, gen::k, and mps_fire::result.

Referenced by load().

                                                                                                             {

  const double HEZMIN_H2 = 400.715;
  const double HEZMID_H2 = 436.285;
  const double HEZMAX_H2 = 541.885;
  const int    nEtas = 10;
  const int    nDepth[nEtas] = {1,2,2,2,2,2,2,2,3,3};
  const int    dStart[nEtas] = {3,1,1,1,1,1,1,1,1,1};
  const int    nPhis[nEtas]  = {8,8,8,8,8,8,4,4,4,4};
  const double etas[nEtas+1] = {1.305,1.373,1.444,1.521,1.603,1.693,1.790,
                1.880,1.980,2.090,2.210};
  const double zval[4*nEtas] = {409.885,462.685,0.,0.,
                HEZMIN_H2,427.485,506.685,0.0,
                HEZMIN_H2,HEZMID_H2,524.285,0.,
                HEZMIN_H2,HEZMID_H2,HEZMAX_H2,0.,
                HEZMIN_H2,HEZMID_H2,HEZMAX_H2,0.,
                HEZMIN_H2,HEZMID_H2,HEZMAX_H2,0.,
                HEZMIN_H2,HEZMID_H2,HEZMAX_H2,0.,
                HEZMIN_H2,HEZMID_H2,HEZMAX_H2,0.,
                HEZMIN_H2,418.685,HEZMID_H2,HEZMAX_H2,
                HEZMIN_H2,418.685,HEZMID_H2,HEZMAX_H2};
  std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> result;

  for (int i = 0; i < nEtas; ++i) {
    int ieta = 16+i;
    for (int k=0; k<nDepth[i]; ++k) {
      int depth = dStart[i]+k;
      for (int j=0; j < nPhis[i]; ++j) {
    int    iphi = (nPhis[i] == 8) ? (j+1) : (2*j+1);
    double dphi = (40.0*DEGREE2RAD)/nPhis[i];
    double phi0 = (j+0.5)*dphi;
    // ieta, depth, iphi, phi0, deltaPhi, zMin, zMax, etaMin, etaMax
    result.push_back (HcalFlexiHardcodeGeometryLoader::HECellParameters(ieta, depth, iphi, phi0, dphi, zval[4*i+k+1], zval[4*i+k+2], etas[i], etas[i+1]));
      }
    }
  }
  return result;
}

std::vector< HcalFlexiHardcodeGeometryLoader::HFCellParameters > HcalFlexiHardcodeGeometryLoader::makeHFCells ( const HcalDDDRecConstants &  hcons )

private

Definition at line 274 of file HcalFlexiHardcodeGeometryLoader.cc.

References particleFlowClusterECALTimeSelected_cfi::depth, HcalDDDRecConstants::getHFCellParameters(), mps_fire::i, DetIdAssociatorESProducer_cff::nPhi, mps_fire::result, conversionPostprocessing_cfi::rMax, and conversionPostprocessing_cfi::rMin.

Referenced by load().

                                                                                                                                          {

  const float HFZMIN1 = 1115.;
  const float HFZMIN2 = 1137.;
  const float HFZMAX = 1280.1;
  std::vector<HcalDDDRecConstants::HFCellParameters> cells = hcons.getHFCellParameters();
  unsigned int nCells = cells.size();
  std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters> result;
  result.reserve (nCells);
  for (unsigned int i = 0; i < nCells; ++i) {
    HcalFlexiHardcodeGeometryLoader::HFCellParameters cell1(cells[i].ieta,cells[i].depth,cells[i].firstPhi,cells[i].stepPhi,cells[i].nPhi,5*cells[i].stepPhi,HFZMIN1,HFZMAX,cells[i].rMin,cells[i].rMax);
    result.push_back (cell1);
    HcalFlexiHardcodeGeometryLoader::HFCellParameters cell2(cells[i].ieta,1+cells[i].depth,cells[i].firstPhi,cells[i].stepPhi,cells[i].nPhi,5*cells[i].stepPhi,HFZMIN2,HFZMAX,cells[i].rMin,cells[i].rMax);
    result.push_back (cell2);
  }
  return result;
}

std::vector< HcalFlexiHardcodeGeometryLoader::HBHOCellParameters > HcalFlexiHardcodeGeometryLoader::makeHOCells ( )

private

Definition at line 99 of file HcalFlexiHardcodeGeometryLoader.cc.

References mps_fire::i, M_PI, DetIdAssociatorESProducer_cff::nPhi, phi, and mps_fire::result.

Referenced by load().

                                                                                                           {
  const double HORMIN0 = 390.0;
  const double HORMIN1 = 412.6;
  const double HORMAX  = 413.6;
  const int    nCells  = 15;
  const int    nPhi    = 72;
  const double etamin[nCells] = {0.000,0.087,0.174, 0.261, 0.3395,0.435,0.522,
                 0.609,0.696,0.783, 0.873, 0.957, 1.044,1.131,
                 1.218};
  const double etamax[nCells] = {0.087,0.174,0.261, 0.3075,0.435, 0.522,0.609,
                 0.696,0.783,0.8494,0.957, 1.044, 1.131,1.218,
                 1.305};
  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
  result.reserve (nCells*nPhi);
  double dphi = ((2.0*M_PI)/nPhi);
  for (int i = 0; i < nCells; ++i) {
    double rmin = ((i < 4) ? HORMIN0 : HORMIN1);
    for (int iside = -1; iside <= 1; iside += 2) {
      for (int j=0; j < nPhi; ++j) {
    double phi = (j+0.5)*dphi;
    // eta, depth, phi, phi0, deltaPhi, rMin, rMax, etaMin, etaMax
    result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(iside*(i+1), 4, j+1, phi, dphi, rmin, HORMAX, etamin[i], etamax[i]));
      }
    }
  }
  return result;
}

Member Data Documentation

double HcalFlexiHardcodeGeometryLoader::DEGREE2RAD

private

Definition at line 87 of file HcalFlexiHardcodeGeometryLoader.h.

Referenced by fillHF(), HcalFlexiHardcodeGeometryLoader(), and makeHECells_H2().

bool HcalFlexiHardcodeGeometryLoader::isBH_

private

Definition at line 88 of file HcalFlexiHardcodeGeometryLoader.h.

Referenced by fillHE(), and load().

int HcalFlexiHardcodeGeometryLoader::MAX_HCAL_PHI

private

Definition at line 86 of file HcalFlexiHardcodeGeometryLoader.h.

Referenced by fillHF(), HcalFlexiHardcodeGeometryLoader(), makeHBCells(), and makeHECells().