CmsTrackerPhase1DiskBuilder< FilteredView > Class Template Reference

#include <CmsTrackerPhase1DiskBuilder.h>

Inheritance diagram for CmsTrackerPhase1DiskBuilder< FilteredView >:

Private Member Functions
void	buildComponent (FilteredView &, GeometricDet *, const std::string &) override
void	PhiPosNegSplit_innerOuter (std::vector< GeometricDet const * >::iterator begin, std::vector< GeometricDet const * >::iterator end)
void	sortNS (FilteredView &, GeometricDet *) override

Static Private Member Functions
static bool	PhiSort (const GeometricDet *Panel1, const GeometricDet *Panel2)

Additional Inherited Members
Public Member Functions inherited from CmsTrackerLevelBuilder< FilteredView >
void	build (FilteredView &, GeometricDet *, const std::string &) override
template<>
void	build (DDFilteredView &fv, GeometricDet *tracker, const std::string &attribute)
template<>
void	build (cms::DDFilteredView &fv, GeometricDet *tracker, const std::string &attribute)
	~CmsTrackerLevelBuilder () override
Public Member Functions inherited from CmsTrackerAbstractConstruction< FilteredView >
virtual	~CmsTrackerAbstractConstruction ()=default
Protected Attributes inherited from CmsTrackerLevelBuilder< FilteredView >
CmsTrackerStringToEnum	theCmsTrackerStringToEnum

Detailed Description

template<class FilteredView>
class CmsTrackerPhase1DiskBuilder< FilteredView >

Class which contructs PixelForward/Disk.

Definition at line 12 of file CmsTrackerPhase1DiskBuilder.h.

Member Function Documentation

template<class FilteredView >

void CmsTrackerPhase1DiskBuilder< FilteredView >::buildComponent ( FilteredView &  fv, GeometricDet *  g, const std::string &  s  )

overrideprivatevirtual

Implements CmsTrackerLevelBuilder< FilteredView >.

Definition at line 84 of file CmsTrackerPhase1DiskBuilder.cc.

References GeometricDet::addComponent(), CmsTrackerLevelBuilder< FilteredView >::build(), ExtractStringFromDDD< FilteredView >::getString(), and GeometricDet::panel.

                                                                                   {
  CmsTrackerPanelBuilder<FilteredView> theCmsTrackerPanelBuilder;
  GeometricDet* subdet = new GeometricDet(&fv,
                                          CmsTrackerLevelBuilder<FilteredView>::theCmsTrackerStringToEnum.type(
                                              ExtractStringFromDDD<FilteredView>::getString(s, &fv)));

  switch (CmsTrackerLevelBuilder<FilteredView>::theCmsTrackerStringToEnum.type(
      ExtractStringFromDDD<FilteredView>::getString(s, &fv))) {
    case GeometricDet::panel:
      theCmsTrackerPanelBuilder.build(fv, subdet, s);
      break;
    default:
      edm::LogError("CmsTrackerPhase1DiskBuilder")
          << " ERROR - I was expecting a Panel, I got a " << ExtractStringFromDDD<FilteredView>::getString(s, &fv);
  }
  g->addComponent(subdet);
}

template<class FilteredView >

void CmsTrackerPhase1DiskBuilder< FilteredView >::PhiPosNegSplit_innerOuter ( std::vector< GeometricDet const * >::iterator  begin, std::vector< GeometricDet const * >::iterator  end  )

private

Definition at line 20 of file CmsTrackerPhase1DiskBuilder.cc.

References SplitLinear::begin, filterCSVwithJSON::copy, dataset::end, SiStripPI::max, SiStripPI::min, and svgfig::rotate().

                                                                                              {
  // first sort in phi, lowest first (-pi to +pi)
  std::sort(begin, end, PhiSort);

  // now put positive phi (in order) ahead of negative phi as in std geometry
  std::vector<const GeometricDet*> theCompsPosNeg;
  // also find the average radius (used to split inner and outer disk panels)
  double theRmin = (**begin).rho();
  double theRmax = theRmin;
  for (vector<const GeometricDet*>::const_iterator it = begin; it != end; it++) {
    if ((**it).phi() >= 0)
      theCompsPosNeg.emplace_back(*it);
    theRmin = std::min(theRmin, (**it).rho());
    theRmax = std::max(theRmax, (**it).rho());
  }
  for (vector<const GeometricDet*>::const_iterator it = begin; it != end; it++) {
    if ((**it).phi() < 0)
      theCompsPosNeg.emplace_back(*it);
  }

  // now put inner disk panels first
  //  double radius_split = 0.5 * (theRmin + theRmax);
  // force the split radius to be 100 mm to be able to deal with disks with only outer ring
  double radius_split = 100.;
  std::vector<const GeometricDet*> theCompsInnerOuter;
  unsigned int num_inner = 0;
  for (vector<const GeometricDet*>::const_iterator it = theCompsPosNeg.begin(); it != theCompsPosNeg.end(); it++) {
    if ((**it).rho() <= radius_split) {
      theCompsInnerOuter.emplace_back(*it);
      num_inner++;
    }
  }

  for (vector<const GeometricDet*>::const_iterator it = theCompsPosNeg.begin(); it != theCompsPosNeg.end(); it++) {
    if ((**it).rho() > radius_split)
      theCompsInnerOuter.emplace_back(*it);
  }
  //  std::cout << "num of inner = " << num_inner << " with radius less than " << radius_split << std::endl;
  // now shift outer by one

  if (num_inner < theCompsInnerOuter.size()) {
    std::rotate(theCompsInnerOuter.begin() + num_inner, theCompsInnerOuter.end() - 1, theCompsInnerOuter.end());
  }
  if (num_inner > 0) {
    std::rotate(
        theCompsInnerOuter.begin(), theCompsInnerOuter.begin() + num_inner - 1, theCompsInnerOuter.begin() + num_inner);
  }

  if (num_inner == 0) {
    edm::LogError(
        "CmsTrackerPhase1DiskBuilder. num_inner == 0. The split of modules by radius is probably not doing what you "
        "expect: inner-radius group is empty.");
  }
  if (num_inner == theCompsInnerOuter.size()) {
    edm::LogError(
        "CmsTrackerPhase1DiskBuilder. num_inner == theCompsInnerOuter.size(). The split of modules by radius is "
        "probably not doing what you expect: outer-radius group is empty.");
  }

  std::copy(theCompsInnerOuter.begin(), theCompsInnerOuter.end(), begin);
}

template<class FilteredView >

bool CmsTrackerPhase1DiskBuilder< FilteredView >::PhiSort ( const GeometricDet *  Panel1, const GeometricDet *  Panel2  )

staticprivate

Definition at line 15 of file CmsTrackerPhase1DiskBuilder.cc.

References GeometricDet::phi().

                                                                                                              {
  return (Panel1->phi() < Panel2->phi());
}

template<class FilteredView >

void CmsTrackerPhase1DiskBuilder< FilteredView >::sortNS ( FilteredView &  fv, GeometricDet *  det  )

overrideprivatevirtual

Reimplemented from CmsTrackerLevelBuilder< FilteredView >.

Definition at line 105 of file CmsTrackerPhase1DiskBuilder.cc.

References funct::abs(), GeometricDet::addComponents(), GeometricDet::clearComponents(), AlCaHLTBitMon_QueryRunRegistry::comp, GeometricDet::component(), GeometricDet::components(), personalPlayback::fn, dqmiolumiharvest::j, GeometricDet::panel, and groupFilesInBlocks::temp.

                                                                                          {
  GeometricDet::ConstGeometricDetContainer& comp = det->components();

  switch (det->components().front()->type()) {
    case GeometricDet::panel:
      PhiPosNegSplit_innerOuter(comp.begin(), comp.end());
      break;
    default:
      edm::LogError("CmsTrackerPhase1DiskBuilder")
          << "ERROR - wrong SubDet to sort..... " << det->components().front()->type();
  }

  GeometricDet::GeometricDetContainer zminpanels;  // Here z refers abs(z);
  GeometricDet::GeometricDetContainer zmaxpanels;  // So, zmin panel is always closer to ip.

  uint32_t totalblade = comp.size() / 2;
  //  std::cout << "pixel_disk " << pixel_disk << endl;

  zminpanels.reserve(totalblade);
  zmaxpanels.reserve(totalblade);
  for (uint32_t j = 0; j < totalblade; j++) {
    if (std::abs(comp[2 * j]->translation().z()) > std::abs(comp[2 * j + 1]->translation().z())) {
      zmaxpanels.emplace_back(det->component(2 * j));
      zminpanels.emplace_back(det->component(2 * j + 1));

    } else if (std::abs(comp[2 * j]->translation().z()) < std::abs(comp[2 * j + 1]->translation().z())) {
      zmaxpanels.emplace_back(det->component(2 * j + 1));
      zminpanels.emplace_back(det->component(2 * j));
    } else {
      edm::LogWarning("CmsTrackerPhase1DiskBuilder") << "WARNING - The Z of  both panels are equal! ";
    }
  }

  for (uint32_t fn = 0; fn < zminpanels.size(); fn++) {
    uint32_t blade = fn + 1;
    uint32_t panel = 2;  // though being zmin, it is actually the one facing away the ip
    uint32_t temp = (blade << 2) | panel;
    zminpanels[fn]->setGeographicalID(temp);
  }

  for (uint32_t bn = 0; bn < zmaxpanels.size(); bn++) {
    uint32_t blade = bn + 1;
    uint32_t panel = 1;  // though being zmax, it is the one facing the ip
    uint32_t temp = (blade << 2) | panel;
    zmaxpanels[bn]->setGeographicalID(temp);
  }

  det->clearComponents();
  det->addComponents(zminpanels);
  det->addComponents(zmaxpanels);
}