Phase2EndcapLayerDoubleDisk Class Reference

#include <Phase2EndcapLayerDoubleDisk.h>

Inheritance diagram for Phase2EndcapLayerDoubleDisk:

Classes
struct	SubDiskPar

Public Member Functions
const std::vector< const GeomDet * > &	basicComponents () const override
const std::vector< const GeometricSearchDet * > &	components () const override
void	groupedCompatibleDetsV (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const override
Phase2EndcapLayerDoubleDisk &	operator= (const Phase2EndcapLayerDoubleDisk &)=delete
	Phase2EndcapLayerDoubleDisk (std::vector< const Phase2EndcapSubDisk * > &subDisks)
	Phase2EndcapLayerDoubleDisk (const Phase2EndcapLayerDoubleDisk &)=delete
SubDetector	subDetector () const override
	~Phase2EndcapLayerDoubleDisk () override

Private Member Functions
BoundDisk *	computeDisk (const std::vector< const Phase2EndcapSubDisk * > &subDisks) const
void	fillSubDiskPars (int i)
std::array< int, 2 >	findTwoClosest (std::vector< GlobalPoint >) const
std::array< int, 2 >	subDiskIndicesByCrossingProximity (const TrajectoryStateOnSurface &startingState, const Propagator &prop) const

Private Attributes
std::vector< SubDiskPar >	subDiskPars
std::vector< GeomDet const * >	theBasicComps
std::atomic< std::vector < const GeometricSearchDet * > * >	theComponents
std::vector< const Phase2EndcapSubDisk * >	theComps
int	theSubDisksSize

Detailed Description

A concrete implementation for Phase 2 Endcap/Forward layer built out of Phase2EndcapRings

Definition at line 14 of file Phase2EndcapLayerDoubleDisk.h.

Constructor & Destructor Documentation

Phase2EndcapLayerDoubleDisk::Phase2EndcapLayerDoubleDisk

(

std::vector< const Phase2EndcapSubDisk * > &

subDisks

)

Definition at line 26 of file Phase2EndcapLayerDoubleDisk.cc.

    : RingedForwardLayer(true), theComponents{nullptr} {
  theSubDisksSize = subDisks.size();
  LogDebug("TkDetLayers") << "Number of subdisks in Phase2 IT EC layer is " << theSubDisksSize << std::endl;
  setSurface(computeDisk(subDisks));

  for (unsigned int i = 0; i != subDisks.size(); ++i) {
    theComps.push_back(subDisks[i]);
    fillSubDiskPars(i);
    theBasicComps.insert(
        theBasicComps.end(), (*subDisks[i]).basicComponents().begin(), (*subDisks[i]).basicComponents().end());
  }

  LogDebug("TkDetLayers") << "==== DEBUG Phase2EndcapLayer =====";
  LogDebug("TkDetLayers") << "r,zed pos  , thickness, innerR, outerR: " << this->position().perp() << " , "
                          << this->position().z() << " , " << this->specificSurface().bounds().thickness() << " , "
                          << this->specificSurface().innerRadius() << " , " << this->specificSurface().outerRadius();
}

Phase2EndcapLayerDoubleDisk::~Phase2EndcapLayerDoubleDisk ( )

override

Definition at line 49 of file Phase2EndcapLayerDoubleDisk.cc.

References c, theComponents, and theComps.

                                                          {
  for (auto c : theComps)
    delete c;

  delete theComponents.load();
}

Phase2EndcapLayerDoubleDisk::Phase2EndcapLayerDoubleDisk ( const Phase2EndcapLayerDoubleDisk &  )

delete

Member Function Documentation

const std::vector<const GeomDet*>& Phase2EndcapLayerDoubleDisk::basicComponents ( ) const

inlineoverride

Definition at line 25 of file Phase2EndcapLayerDoubleDisk.h.

References theBasicComps.

{ return theBasicComps; }

const std::vector< const GeometricSearchDet * > & Phase2EndcapLayerDoubleDisk::components ( ) const

override

Definition at line 15 of file Phase2EndcapLayerDoubleDisk.cc.

References Exception.

                                                                                          {
  throw cms::Exception("Phase2EndcapLayerDoubleDisk::components() is not implemented");
}

BoundDisk * Phase2EndcapLayerDoubleDisk::computeDisk ( const std::vector< const Phase2EndcapSubDisk * > &  subDisks ) const

private

Definition at line 45 of file Phase2EndcapLayerDoubleDisk.cc.

References tkDetUtil::computeDisk().

                                                                                                            {
  return tkDetUtil::computeDisk(subDisks);
}

void Phase2EndcapLayerDoubleDisk::fillSubDiskPars ( int  i )

private

Definition at line 19 of file Phase2EndcapLayerDoubleDisk.cc.

References funct::abs(), mps_fire::i, and Phase2EndcapLayerDoubleDisk::SubDiskPar::theSubDiskZ.

                                                       {
  const BoundDisk& subDiskDisk = static_cast<const BoundDisk&>(theComps[i]->surface());
  SubDiskPar tempPar;
  tempPar.theSubDiskZ = std::abs(subDiskDisk.position().z());
  subDiskPars.push_back(tempPar);
}

std::array< int, 2 > Phase2EndcapLayerDoubleDisk::findTwoClosest ( std::vector< GlobalPoint >  subDiskCrossing ) const

private

Definition at line 169 of file Phase2EndcapLayerDoubleDisk.cc.

References funct::abs(), mps_fire::i, subDiskPars, theSubDisksSize, and z.

Referenced by subDiskIndicesByCrossingProximity().

                                                                                                         {
  std::array<int, 2> theBins = {{-1, -1}};
  theBins[0] = 0;
  float initialZ = subDiskPars[0].theSubDiskZ;
  float zDiff0 = std::abs(subDiskCrossing[0].z() - initialZ);
  float zDiff1 = -1.;
  for (int i = 1; i < theSubDisksSize; i++) {
    float subDiskZ = subDiskPars[i].theSubDiskZ;
    float testDiff = std::abs(subDiskCrossing[i].z() - subDiskZ);
    if (testDiff < zDiff0) {
      zDiff1 = zDiff0;
      zDiff0 = testDiff;
      theBins[1] = theBins[0];
      theBins[0] = i;
    } else if (zDiff1 < 0 || testDiff < zDiff1) {
      zDiff1 = testDiff;
      theBins[1] = i;
    }
  }

  return theBins;
}

void Phase2EndcapLayerDoubleDisk::groupedCompatibleDetsV ( const TrajectoryStateOnSurface &  tsos, const Propagator &  prop, const MeasurementEstimator &  est, std::vector< DetGroup > &  result  ) const

override

Definition at line 56 of file Phase2EndcapLayerDoubleDisk.cc.

References funct::abs(), DetGroupMerger::addSameLevel(), alongMomentum, PVValHelper::fill(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, eostools::move(), DetGroupMerger::orderAndMergeTwoLevels(), position, Propagator::propagationDirection(), subDiskIndicesByCrossingProximity(), theComps, theSubDisksSize, z, and PV3DBase< T, PVType, FrameType >::z().

                                                                                            {
  std::array<int, 2> const& subDiskIndices = subDiskIndicesByCrossingProximity(startingState, prop);

  //order subdisks in z
  //Subdisk near in z: 0, Subdisk far in z: 1
  std::vector<int> subDiskOrder(theSubDisksSize);
  std::fill(subDiskOrder.begin(), subDiskOrder.end(), 1);
  if (theSubDisksSize > 1) {
    if (std::abs(theComps[0]->position().z()) < std::abs(theComps[1]->position().z())) {
      for (int i = 0; i < theSubDisksSize; i++) {
        if (i % 2 == 0)
          subDiskOrder[i] = 0;
      }
    } else if (std::abs(theComps[0]->position().z()) > std::abs(theComps[1]->position().z())) {
      std::fill(subDiskOrder.begin(), subDiskOrder.end(), 0);
      for (int i = 0; i < theSubDisksSize; i++) {
        if (i % 2 == 0)
          subDiskOrder[i] = 1;
      }
    } else {
      throw DetLayerException("SubDisks in Endcap Layer have same z position, no idea how to order them!");
    }
  }

  auto index = [&subDiskIndices, &subDiskOrder](int i) { return subDiskOrder[subDiskIndices[i]]; };

  std::vector<DetGroup> closestResult;
  theComps[subDiskIndices[0]]->groupedCompatibleDetsV(startingState, prop, est, closestResult);
  // if the closest is empty, use the next one and exit: inherited from TID !
  if (closestResult.empty()) {
    theComps[subDiskIndices[1]]->groupedCompatibleDetsV(startingState, prop, est, result);
    return;
  }

  // check if next subdisk is found

  bool subdisk1ok = subDiskIndices[1] != -1;

  // determine if we are propagating from in to out (0) or from out to in (1)

  int direction = 0;
  if (startingState.globalPosition().z() * startingState.globalMomentum().z() > 0) {
    if (prop.propagationDirection() == alongMomentum)
      direction = 0;
    else
      direction = 1;
  } else {
    if (prop.propagationDirection() == alongMomentum)
      direction = 1;
    else
      direction = 0;
  }

  if (index(0) == index(1)) {
    if (subdisk1ok) {
      std::vector<DetGroup> subdisk1res;
      theComps[subDiskIndices[1]]->groupedCompatibleDetsV(startingState, prop, est, subdisk1res);
      DetGroupMerger::addSameLevel(std::move(subdisk1res), closestResult);
      result.swap(closestResult);
      return;
    }
  } else {
    std::vector<DetGroup> subdisk1res;
    if (subdisk1ok) {
      theComps[subDiskIndices[1]]->groupedCompatibleDetsV(startingState, prop, est, subdisk1res);
    }
    if (!subdisk1res.empty()) {
      DetGroupMerger::orderAndMergeTwoLevels(
          std::move(closestResult), std::move(subdisk1res), result, index(0), direction);
      return;
    } else {
      result.swap(closestResult);
      return;
    }
  }
}

Phase2EndcapLayerDoubleDisk& Phase2EndcapLayerDoubleDisk::operator= ( const Phase2EndcapLayerDoubleDisk &  )

delete

SubDetector Phase2EndcapLayerDoubleDisk::subDetector ( ) const

inlineoverride

Definition at line 35 of file Phase2EndcapLayerDoubleDisk.h.

References GeomDetEnumerators::P2PXEC, and GeomDetEnumerators::subDetGeom.

{ return GeomDetEnumerators::subDetGeom[GeomDetEnumerators::P2PXEC]; }

std::array< int, 2 > Phase2EndcapLayerDoubleDisk::subDiskIndicesByCrossingProximity ( const TrajectoryStateOnSurface &  startingState, const Propagator &  prop  ) const

private

Definition at line 136 of file Phase2EndcapLayerDoubleDisk.cc.

References findTwoClosest(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, Propagator::propagationDirection(), rho, theComps, theSubDisksSize, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                 {
  typedef HelixForwardPlaneCrossing Crossing;
  typedef MeasurementEstimator::Local2DVector Local2DVector;

  HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
  HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
  PropagationDirection propDir(prop.propagationDirection());
  float rho(startingState.transverseCurvature());

  // calculate the crossings with the subdisk surfaces

  Crossing myXing(startPos, startDir, rho, propDir);

  std::vector<GlobalPoint> subDiskCrossings;
  subDiskCrossings.reserve(theSubDisksSize);

  for (int i = 0; i < theSubDisksSize; i++) {
    const BoundDisk& theSubDisk = static_cast<const BoundDisk&>(theComps[i]->surface());
    pair<bool, double> pathlen = myXing.pathLength(theSubDisk);
    if (pathlen.first) {
      subDiskCrossings.push_back(GlobalPoint(myXing.position(pathlen.second)));
    } else {
      // TO FIX.... perhaps there is something smarter to do
      subDiskCrossings.push_back(GlobalPoint(0., 0., 0.));
    }
  }

  //find two closest subdisks to the crossing

  return findTwoClosest(subDiskCrossings);
}

Member Data Documentation

std::vector<SubDiskPar> Phase2EndcapLayerDoubleDisk::subDiskPars

private

Definition at line 55 of file Phase2EndcapLayerDoubleDisk.h.

Referenced by findTwoClosest().

std::vector<GeomDet const*> Phase2EndcapLayerDoubleDisk::theBasicComps

private

Definition at line 49 of file Phase2EndcapLayerDoubleDisk.h.

Referenced by basicComponents().

std::atomic<std::vector<const GeometricSearchDet*>*> Phase2EndcapLayerDoubleDisk::theComponents

mutableprivate

Definition at line 50 of file Phase2EndcapLayerDoubleDisk.h.

Referenced by ~Phase2EndcapLayerDoubleDisk().

std::vector<const Phase2EndcapSubDisk*> Phase2EndcapLayerDoubleDisk::theComps

private

Definition at line 51 of file Phase2EndcapLayerDoubleDisk.h.

Referenced by groupedCompatibleDetsV(), subDiskIndicesByCrossingProximity(), and ~Phase2EndcapLayerDoubleDisk().

int Phase2EndcapLayerDoubleDisk::theSubDisksSize

private

Definition at line 56 of file Phase2EndcapLayerDoubleDisk.h.

Referenced by findTwoClosest(), groupedCompatibleDetsV(), and subDiskIndicesByCrossingProximity().