QuadrupletSeedMerger Class Reference

#include <QuadrupletSeedMerger.h>

Public Member Functions
std::pair< double, double >	calculatePhiEta (SeedingHitSet const &) const
const OrderedSeedingHits &	mergeTriplets (const OrderedSeedingHits &, const edm::EventSetup &)
const TrajectorySeedCollection	mergeTriplets (const TrajectorySeedCollection &, const TrackingRegion &, const edm::EventSetup &)
void	printHit (const TrackingRecHit *) const
void	printNtuplet (const SeedingHitSet &) const
	QuadrupletSeedMerger (const edm::ParameterSet &iConfig, edm::ConsumesCollector &iC)
	QuadrupletSeedMerger (const edm::ParameterSet &iConfig, const edm::ParameterSet &seedCreatorConfig, edm::ConsumesCollector &iC)
void	setAddRemainingTriplets (bool)
void	setMergeTriplets (bool)
void	setTTRHBuilderLabel (std::string)
void	update (const edm::EventSetup &)
	~QuadrupletSeedMerger ()

Private Types
typedef std::array < SeedingHitSet::ConstRecHitPointer, 4 >	QuadrupletHits

Private Member Functions
bool	isValidQuadruplet (const QuadrupletHits &quadruplet, const std::vector< SeedMergerPixelLayer > &layers, const TrackerTopology *tTopo) const
void	mySort (QuadrupletHits &unsortedHits)
	QuadrupletSeedMerger (const edm::ParameterSet &iConfig, SeedCreator *seedCreator, edm::ConsumesCollector &iC)

Private Attributes
bool	isAddRemainingTriplets_
bool	isMergeTriplets_
OrderedHitSeeds	quads_
SeedingLayerSetsBuilder	theLayerBuilder_
ctfseeding::SeedingLayerSets	theLayerSets_
std::unique_ptr< SeedCreator >	theSeedCreator_
edm::ESHandle< TrackerGeometry >	theTrackerGeometry_
edm::ESHandle < TransientTrackingRecHitBuilder >	theTTRHBuilder_
std::string	theTTRHBuilderLabel_

Detailed Description

merge triplets into quadruplets

Definition at line 76 of file QuadrupletSeedMerger.h.

Member Typedef Documentation

typedef std::array<SeedingHitSet::ConstRecHitPointer, 4> QuadrupletSeedMerger::QuadrupletHits

private

Definition at line 96 of file QuadrupletSeedMerger.h.

Constructor & Destructor Documentation

QuadrupletSeedMerger::QuadrupletSeedMerger ( const edm::ParameterSet &  iConfig, edm::ConsumesCollector &  iC  )

explicit

Definition at line 68 of file QuadrupletSeedMerger.cc.

                                                                                                  :
  QuadrupletSeedMerger(iConfig, nullptr, iC) {}

QuadrupletSeedMerger::QuadrupletSeedMerger	(	const edm::ParameterSet &	iConfig,
		const edm::ParameterSet &	seedCreatorConfig,
		edm::ConsumesCollector &	iC
	)

Definition at line 70 of file QuadrupletSeedMerger.cc.

                                                                                                                                            :
  QuadrupletSeedMerger(iConfig,
                       SeedCreatorFactory::get()->create(seedCreatorConfig.getParameter<std::string>("ComponentName") , seedCreatorConfig), 
                       iC) {}

QuadrupletSeedMerger::~QuadrupletSeedMerger

(

)

Definition at line 94 of file QuadrupletSeedMerger.cc.

                                            {

}

QuadrupletSeedMerger::QuadrupletSeedMerger ( const edm::ParameterSet &  iConfig, SeedCreator *  seedCreator, edm::ConsumesCollector &  iC  )

private

Definition at line 74 of file QuadrupletSeedMerger.cc.

References isAddRemainingTriplets_, and isMergeTriplets_.

                                                                                                                            :
  theLayerBuilder_(iConfig, iC),
  theSeedCreator_(seedCreator)
 {

  // by default, do not..
  // ..merge triplets
  isMergeTriplets_ = false;
  // ..add remaining triplets
  isAddRemainingTriplets_ = false;
}

Member Function Documentation

std::pair< double, double > QuadrupletSeedMerger::calculatePhiEta

(

SeedingHitSet const &

nTuplet

)

const

Definition at line 483 of file QuadrupletSeedMerger.cc.

References eta, p1, p2, phi, funct::sqr(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by mergeTriplets().

                                                                                                 {

//   if( nTuplet.size() < 3 ) {
//     std::cerr << " [QuadrupletSeedMerger::calculatePhiEta] ** ERROR: nTuplet has less than 3 hits" << std::endl;
//     throw; // tbr.
//   }

  GlobalPoint p1 = nTuplet[0]->globalPosition();
  GlobalPoint p2 = nTuplet[1]->globalPosition();

  const double x1 = p1.x();
  const double x2 = p2.x();
  const double y1 = p1.y();
  const double y2 = p2.y();
  const double z1 = p1.z();
  const double z2 = p2.z();

  const double phi = atan2( x2 - x1, y2 -y1 );
  const double eta = acos( (z2 - z1) / sqrt( sqr( x2 - x1 ) + sqr( y2 - y1 ) + sqr( z2 - z1 ) ) ); // this is theta angle in reality

  std::pair<double,double> retVal;
  retVal=std::make_pair (phi,eta);
  return retVal;
  //return std::make_pair<double,double>( phi, eta );
  
}

bool QuadrupletSeedMerger::isValidQuadruplet ( const QuadrupletHits &  quadruplet, const std::vector< SeedMergerPixelLayer > &  layers, const TrackerTopology *  tTopo  ) const

private

check for validity of a (radius-) sorted quadruplet:

1. after sorting, hits must be on layers according to the order given in PixelSeedMergerQuadruplets (from cfg)

Definition at line 604 of file QuadrupletSeedMerger.cc.

References gather_cfg::cout, and cmsHarvester::index.

Referenced by mergeTriplets().

                                                                                                                                                                {

  const unsigned int quadrupletSize = quadruplet.size();

  // basic size test..
  if( quadrupletSize != layers.size() ) {
    std::cout << " [QuadrupletSeedMerger::isValidQuadruplet] ** WARNING: size mismatch: "
          << quadrupletSize << "/" << layers.size() << std::endl;
    return false;
  }

  // go along layers and check if all (parallel) quadruplet hits match
  for( unsigned int index = 0; index < quadrupletSize; ++index ) {
    if( ! layers[index].isContainsDetector( quadruplet[index]->geographicalId(), tTopo ) ) {
      return false;
    }
  }

  return true;

}

const OrderedSeedingHits & QuadrupletSeedMerger::mergeTriplets	(	const OrderedSeedingHits &	inputTriplets,
		const edm::EventSetup &	es
	)

merge triplets into quadruplets INPUT: OrderedSeedingHits OUTPUT: SeedingHitSets

this method is used in RecoPixelVertexing/PixelTrackFitting/src/PixelTrackReconstruction.cc and contains the basic merger functionality

Definition at line 110 of file QuadrupletSeedMerger.cc.

References a, assert(), b, KDTreeLinkerAlgo< DATA >::build(), calculatePhiEta(), SeedingLayerSetsBuilder::check(), constexpr, gather_cfg::cout, eta, edm::EventSetup::get(), i, isAddRemainingTriplets_, isMergeTriplets_, isValidQuadruplet(), j, SeedingLayerSetsBuilder::layers(), bookConverter::max, maxEta, min(), benchmark_cfg::minEta, mySort(), class-composition::nodes, phi, edm::ESHandle< class >::product(), quads_, indexGen::s2, KDTreeLinkerAlgo< DATA >::search(), EgAmbiguityTools::sharedHits(), OrderedSeedingHits::size(), findQualityFiles::size, python.multivaluedict::sort(), theLayerBuilder_, theLayerSets_, and Geom::twoPi().

Referenced by mergeTriplets().

                                                                                                                                {

  //Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHand;
  es.get<TrackerTopologyRcd>().get(tTopoHand);
  const TrackerTopology *tTopo=tTopoHand.product();
  
  // the list of layers on which quadruplets should be formed
  if(theLayerBuilder_.check(es)) {
    theLayerSets_ = theLayerBuilder_.layers( es ); // this is a vector<vector<SeedingLayer> >
  }

  
  // make a working copy of the input triplets
  // to be able to remove merged triplets

  std::vector<std::pair<double,double> > phiEtaCache;
  std::vector<SeedingHitSet> tripletCache; //somethings strange about OrderedSeedingHits?

  const unsigned int nInputTriplets = inputTriplets.size();
  phiEtaCache.reserve(nInputTriplets);
  tripletCache.reserve(nInputTriplets);

  for( unsigned int it = 0; it < nInputTriplets; ++it ) {
    tripletCache.push_back((inputTriplets[it]));
    phiEtaCache.push_back(calculatePhiEta( (tripletCache[it]) ));

  }

  // the output
  quads_.clear();

  // check if the input is all triplets
  // (code is also used for pairs..)
  // if not, copy the input to the output & return
  bool isAllTriplets = true;
  for( unsigned int it = 0; it < nInputTriplets; ++it ) {
    if( tripletCache[it].size() != 3 ) {
      isAllTriplets = false;
      break;
    }
  }

  if( !isAllTriplets && isMergeTriplets_ )
    std::cout << "[QuadrupletSeedMerger::mergeTriplets] (in HLT) ** bailing out since non-triplets in input." << std::endl;

  if( !isAllTriplets || !isMergeTriplets_ ) {
    quads_.reserve(nInputTriplets);
    for( unsigned int it = 0; it < nInputTriplets; ++it ) {
      quads_.push_back( (tripletCache[it]));
    }

    return quads_;
  }


  quads_.reserve(0.2*nInputTriplets); //rough guess

  // loop all possible 4-layer combinations
  // as specified in python/quadrupletseedmerging_cff.py

  std::vector<bool> usedTriplets(nInputTriplets,false);
  std::pair<SeedingHitSet::ConstRecHitPointer,SeedingHitSet::ConstRecHitPointer> sharedHits;
  std::pair<SeedingHitSet::ConstRecHitPointer,SeedingHitSet::ConstRecHitPointer> nonSharedHits;

  // k-d tree, indices are (th)eta, phi
  // build the tree
  std::vector<KDTreeNodeInfo<unsigned int> > nodes;
  std::vector<unsigned int> foundNodes;
  nodes.reserve(2*nInputTriplets);
  foundNodes.reserve(100);
  KDTreeLinkerAlgo<unsigned int> kdtree;
  double minEta=1e10, maxEta=-1e10;
  for(unsigned int it=0; it < nInputTriplets; ++it) {
    double phi = phiEtaCache[it].first;
    double eta = phiEtaCache[it].second;
    nodes.push_back(KDTreeNodeInfo<unsigned int>(it, eta, phi));
    minEta = std::min(minEta, eta);
    maxEta = std::max(maxEta, eta);

    // to wrap all points in phi
    // if(phi < 0) phi += twoPi(); else phi -= twoPi();
    double twoPi = std::copysign(Geom::twoPi(), phi);
    nodes.push_back(KDTreeNodeInfo<unsigned int>(it, eta, phi-twoPi));
  }
  KDTreeBox kdEtaPhi(minEta-0.01, maxEta+0.01, -1*Geom::twoPi(), Geom::twoPi());
  kdtree.build(nodes, kdEtaPhi);
  nodes.clear();
  
  // loop over triplets, search for close-by triplets by using the k-d tree
  // also identify the hits which are shared by triplet pairs, and
  // store indices to hits which are not shared
  std::vector<unsigned int> t1List;
  std::vector<unsigned int> t2List;
  std::vector<short> t1NonSharedHitList;
  std::vector<short> t2NonSharedHitList;
  constexpr short sharedToNonShared[7] = {-1, -1, -1,
                                          2, // 011=3 shared, not shared = 2
                                          -1,
                                          1, // 101=5 shared, not shared = 1
                                          0}; // 110=6 shared, not shared = 0
  constexpr short nonSharedToShared[3][2] = {
    {1, 2},
    {0, 2},
    {0, 1}
  };

  typedef std::tuple<unsigned int, short, short> T2NonSharedTuple;
  std::vector<T2NonSharedTuple> t2Tmp; // temporary to sort t2's before insertion to t2List
  for(unsigned int t1=0; t1<nInputTriplets; ++t1) {
    double phi = phiEtaCache[t1].first;
    double eta = phiEtaCache[t1].second;

    KDTreeBox box(eta-0.05, eta+0.05, phi-0.15, phi+0.15);
    foundNodes.clear();
    kdtree.search(box, foundNodes);
    if(foundNodes.empty())
      continue;

    const SeedingHitSet& tr1 = tripletCache[t1];

    for(unsigned int t2: foundNodes) {
      if(t1 >= t2)
        continue;

      // Ensure here that the triplet pairs share two hits.
      const SeedingHitSet& tr2 = tripletCache[t2];

      // If neither of first two hits in tr1 are found from tr2, this
      // pair can be skipped
      int equalHits=0;
      // Find the indices of shared hits in both t1 and t2, use them
      // to obtain the index of non-shared hit for both. The index of
      // non-shared hit is then stored for later use (the indices of
      // shared hits can be easily obtained from them).
      unsigned int t1Shared = 0;
      unsigned int t2Shared = 0;
      for(unsigned int i=0; i<2; ++i) {
        for(unsigned int j=0; j<3; ++j) {
          if(areHitsEqual(*tr1[i], *tr2[j])) {
            t1Shared |= (1<<i);
            t2Shared |= (1<<j);
            ++equalHits;
            break;
          }
        }
      }
      if(equalHits == 0)
        continue;
      // If, after including the third hit of tr1, number of equal
      // hits is not 2, this pair can be skipped
      if(equalHits != 2) {
        for(unsigned int j=0; j<3; ++j) {
          if(areHitsEqual(*tr1[2], *tr2[j])) {
            t1Shared |= (1<<2);
            t2Shared |= (1<<j);
            ++equalHits;
            break;
          }
        }
        if(equalHits != 2)
          continue;
      }
      // valid values for the bitfields are 011=3, 101=5, 110=6
      assert(t1Shared <= 6 && t2Shared <= 6); // against out-of-bounds of sharedToNonShared[]
      short t1NonShared = sharedToNonShared[t1Shared];
      short t2NonShared = sharedToNonShared[t2Shared];
      assert(t1NonShared >= 0 && t2NonShared >= 0); // against invalid value from sharedToNonShared[]

      t2Tmp.emplace_back(t2, t1NonShared, t2NonShared);
    }

    // Sort to increasing order in t2 in order to get exactly same result as before
    std::sort(t2Tmp.begin(), t2Tmp.end(), [](const T2NonSharedTuple& a, const T2NonSharedTuple& b){
        return std::get<0>(a) < std::get<0>(b);
      });
    for(T2NonSharedTuple& t2tpl: t2Tmp) {
      t1List.push_back(t1);
      t2List.push_back(std::get<0>(t2tpl));
      t1NonSharedHitList.push_back(std::get<1>(t2tpl));
      t2NonSharedHitList.push_back(std::get<2>(t2tpl));
    }
    t2Tmp.clear();
  }
  nodes.clear();

  for( ctfseeding::SeedingLayerSets::const_iterator lsIt = theLayerSets_.begin(); lsIt < theLayerSets_.end(); ++lsIt ) {

    // fill a vector with the layers in this set
    std::vector<SeedMergerPixelLayer> currentLayers;
    currentLayers.reserve(lsIt->size());
    for( ctfseeding::SeedingLayers::const_iterator layIt = lsIt->begin(); layIt < lsIt->end(); ++layIt ) {
      currentLayers.push_back( SeedMergerPixelLayer( layIt->name() ) );
    }
    // loop all pair combinations of these 4 layers;
    // strategy is to look for shared hits on such a pair and
    // then merge the remaining hits in both triplets if feasible
    // (SeedingLayers is a vector<SeedingLayer>)

    for( unsigned int s1=0; s1<currentLayers.size()-1; s1++) {

      for( unsigned int s2=s1+1; s2<currentLayers.size(); s2++) {

    std::vector<unsigned int> nonSharedLayerNums;
    for ( unsigned int us1=0; us1<currentLayers.size(); us1++) {
      if ( s1!=us1 && s2!=us1) nonSharedLayerNums.push_back(us1);
    }

    // loop all possible triplet pairs (which come as input)
    for (unsigned int t12=0; t12<t1List.size(); t12++) {
      unsigned int t1=t1List[t12];
      unsigned int t2=t2List[t12];

        if (usedTriplets[t1] || usedTriplets[t2] ) continue; 

            const SeedingHitSet& firstTriplet = tripletCache[t1];

            short t1NonShared = t1NonSharedHitList[t12];
            sharedHits.first = firstTriplet[nonSharedToShared[t1NonShared][0]];
            sharedHits.second = firstTriplet[nonSharedToShared[t1NonShared][1]];

            // are the shared hits on these two layers?
            if(areHitsOnLayers(currentLayers[s1], currentLayers[s2], sharedHits, tTopo)) {
              short t2NonShared = t2NonSharedHitList[t12];
              const SeedingHitSet& secondTriplet = tripletCache[t2];
              nonSharedHits.first = firstTriplet[t1NonShared];
              nonSharedHits.second = secondTriplet[t2NonShared];

          // are the remaining hits on different layers?
              if(areHitsOnLayers(currentLayers[nonSharedLayerNums[0]], currentLayers[nonSharedLayerNums[1]], nonSharedHits, tTopo)) {
                QuadrupletHits unsortedHits{ {sharedHits.first, sharedHits.second,
                      nonSharedHits.first, nonSharedHits.second} };

                mySort(unsortedHits);

        //start here with old addtoresult
        if( isValidQuadruplet( unsortedHits, currentLayers, tTopo ) ) {
          // and create the quadruplet
          SeedingHitSet quadruplet(unsortedHits[0],unsortedHits[1],unsortedHits[2],unsortedHits[3]);
          
          // insert this quadruplet
          quads_.push_back( quadruplet );
          // remove both triplets from the list,
          // needs this 4-permutation since we're in a double loop
          usedTriplets[t1]=true;
          usedTriplets[t2]=true;
        }
        
          } // isMergeableHitsInTriplets
        } // isTripletsShareHitsOnLayers
        // } // triplet double loop
    }
      } // seeding layers double loop
    }
  
  } // seeding layer sets
  
  // add the remaining triplets
  if( isAddRemainingTriplets_ ) {
    for( unsigned int it = 0; it < nInputTriplets; ++it ) {
      if ( !usedTriplets[it] ) 
    quads_.push_back( tripletCache[it]);
    }
  }

  //calc for printout...
//  unsigned int nLeft=0;
//  for ( unsigned int i=0; i<nInputTriplets; i++)
//    if ( !usedTriplets[i] ) nLeft++;
  // some stats
//  std::cout << " [QuadrupletSeedMerger::mergeTriplets] -- Created: " << theResult.size()
//      << " quadruplets from: " << nInputTriplets << " input triplets (" << nLeft
//      << " remaining ";
//  std::cout << (isAddRemainingTriplets_?"added":"dropped");
//  std::cout << ")." << std::endl;

  return quads_;

}

const TrajectorySeedCollection QuadrupletSeedMerger::mergeTriplets	(	const TrajectorySeedCollection &	seedCollection,
		const TrackingRegion &	region,
		const edm::EventSetup &	es
	)

merge triplets into quadruplets INPUT: TrajectorySeedCollection OUTPUT: TrajectorySeedCollection

this is a wrapper for: vector<SeedingHitSet> mergeTriplets( const OrderedSeedingHits& ) for use in RecoTracker/TkSeedGenerator/plugins/SeedGeneratorFromRegionHitsEDProducer.cc (iterative tracking)

Definition at line 402 of file QuadrupletSeedMerger.cc.

References gather_cfg::cout, edm::EventSetup::get(), i, isMergeTriplets_, mergeTriplets(), OrderedSeedingHits::size(), theSeedCreator_, theTTRHBuilder_, and theTTRHBuilderLabel_.

                                                             {

  // ttrh builder for HitSet -> TrajectorySeed conversion;
  // require this to be correctly configured, otherwise -> exception
  es.get<TransientRecHitRecord>().get( theTTRHBuilderLabel_, theTTRHBuilder_ );

  // output collection
  TrajectorySeedCollection theResult;

  // loop to see if we have triplets ONLY
  // if not, copy input -> output and return
  bool isAllTriplets = true;
  for( TrajectorySeedCollection::const_iterator aTrajectorySeed = seedCollection.begin();
       aTrajectorySeed < seedCollection.end(); ++aTrajectorySeed ) {
    if( 3 != aTrajectorySeed->nHits() ) isAllTriplets = false;
  }

  if( !isAllTriplets && isMergeTriplets_ )
    std::cout << " [QuadrupletSeedMerger::mergeTriplets] (in RECO) -- bailing out since non-triplets in input." << std::endl;

  if( !isAllTriplets || !isMergeTriplets_ ) {
    for( TrajectorySeedCollection::const_iterator aTrajectorySeed = seedCollection.begin();
       aTrajectorySeed < seedCollection.end(); ++aTrajectorySeed ) {
      theResult.push_back( *aTrajectorySeed );
    }

    return theResult;
  }


  // all this fiddling here is now about converting
  // TrajectorySeedCollection <-> OrderedSeedingHits

  // create OrderedSeedingHits first;
  OrderedHitTriplets inputTriplets;

  // loop seeds
  for( TrajectorySeedCollection::const_iterator aTrajectorySeed = seedCollection.begin();
       aTrajectorySeed < seedCollection.end(); ++aTrajectorySeed ) {

    std::vector<SeedingHitSet::ConstRecHitPointer> recHitPointers;

    // loop RecHits
    const TrajectorySeed::range theHitsRange = aTrajectorySeed->recHits();
    for( edm::OwnVector<TrackingRecHit>::const_iterator aHit = theHitsRange.first;
     aHit < theHitsRange.second; ++aHit ) {
      
      // this is a collection of: ReferenceCountingPointer< SeedingHitSet> 
      recHitPointers.push_back( (SeedingHitSet::ConstRecHitPointer)(&*aHit ) );

    }
    
    // add to input collection
    inputTriplets.push_back( OrderedHitTriplet( recHitPointers.at( 0 ), recHitPointers.at( 1 ), recHitPointers.at( 2 ) ) );

  }

  // do the real merging..
  const OrderedSeedingHits &quadrupletHitSets = mergeTriplets( inputTriplets, es );
  
  // convert back to TrajectorySeedCollection

  // the idea here is to fetch the same SeedCreator and PSet
  // as those used by the plugin which is calling the merger
  // (at the moment that's SeedGeneratorFromRegionHitsEDProducer)
  theSeedCreator_->init(region, es, 0);
  for ( unsigned int i=0; i< quadrupletHitSets.size(); i++) {
    // add trajectory seed to result collection
    theSeedCreator_->makeSeed( theResult, quadrupletHitSets[i]);
  }

  return theResult;
  
}

void QuadrupletSeedMerger::mySort ( QuadrupletHits &  unsortedHits )

private

Definition at line 724 of file QuadrupletSeedMerger.cc.

References p1, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by mergeTriplets().

                                                                                            {
  float radiiSq[4];
  for ( unsigned int iR=0; iR<4; iR++){
    GlobalPoint p1 = unsortedHits[iR]->globalPosition();
    radiiSq[iR]=( p1.x()*p1.x()+p1.y()*p1.y()); // no need to take the sqrt
  }
  SeedingHitSet::ConstRecHitPointer tempRHP;
  float tempFloat=0.;
  for ( unsigned int iR1=0; iR1<3; iR1++) {
    for ( unsigned int iR2=iR1+1; iR2<4; iR2++) {
      if (radiiSq[iR1]>radiiSq[iR2]) {
    tempRHP=unsortedHits[iR1];
    unsortedHits[iR1]=unsortedHits[iR2];
    unsortedHits[iR2]=tempRHP;
    tempFloat=radiiSq[iR1];
    radiiSq[iR1]=radiiSq[iR2];
    radiiSq[iR2]=tempFloat;
      }
    }
  }
}

void QuadrupletSeedMerger::printHit

(

const TrackingRecHit *

aHit

)

const

Definition at line 516 of file QuadrupletSeedMerger.cc.

References gather_cfg::cout, TrackingRecHit::geographicalId(), TrackingRecHit::localPosition(), PV3DBase< T, PVType, FrameType >::perp(), GloballyPositioned< T >::position(), alignCSCRings::r, GeomDet::surface(), theTrackerGeometry_, GeomDet::toGlobal(), x, y, and z.

                                                                      {

  const GeomDet* geomDet = theTrackerGeometry_->idToDet( aHit->geographicalId() );
  const double r = geomDet->surface().position().perp();
  const double x = geomDet->toGlobal( aHit->localPosition() ).x();
  const double y = geomDet->toGlobal( aHit->localPosition() ).y();
  const double z = geomDet->toGlobal( aHit->localPosition() ).z();
  std::cout << "<RecHit> x: " << x << " y: " << y << " z: " << z << " r: " << r << std::endl;

}

void QuadrupletSeedMerger::printNtuplet

(

const SeedingHitSet &

aNtuplet

)

const

Definition at line 530 of file QuadrupletSeedMerger.cc.

References gather_cfg::cout, PixelEndcapName::diskName(), TrackingRecHit::geographicalId(), PixelBarrelName::layerName(), TrackingRecHit::localPosition(), PixelSubdetector::PixelBarrel, alignCSCRings::r, SeedingHitSet::size(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, DetId::subdetId(), theTrackerGeometry_, GeomDet::toGlobal(), x, y, and z.

                                                                             {

  std::cout << "DUMPING NTUPLET OF SIZE:";
  std::cout << aNtuplet.size() << std::endl;

  for( unsigned int aHit = 0; aHit < aNtuplet.size(); ++aHit ) {

    const TrackingRecHit* theHit = aNtuplet[aHit]->hit();
    const GeomDet* geomDet = theTrackerGeometry_->idToDet( theHit->geographicalId() );
    const double x = geomDet->toGlobal( theHit->localPosition() ).x();
    const double y = geomDet->toGlobal( theHit->localPosition() ).y();
    const double z = geomDet->toGlobal( theHit->localPosition() ).z();
    const double r = sqrt( x*x + y*y );

    unsigned int layer;
    std::string detName;
    if( PixelSubdetector::PixelBarrel == theHit->geographicalId().subdetId() ) {
      detName = "BPIX ";
      PixelBarrelName pbn( aNtuplet[aHit]->hit()->geographicalId());
      layer = pbn.layerName();
    }
    else {
      detName = "FPIX";
      if( z > 0 ) detName += "+";
      else detName += "-";

      PixelEndcapName pen( theHit->geographicalId() );
      layer = pen.diskName();
    }

    std::cout << "<NtupletHit> D: " << detName << " L: " << layer << " x: " << x << " y: " << y << " z: " << z << " r: " << r << std::endl;
    
}

  std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;

}

void QuadrupletSeedMerger::setAddRemainingTriplets

(

bool

isAddTriplets

)

Definition at line 593 of file QuadrupletSeedMerger.cc.

References isAddRemainingTriplets_.

                                                                       {
  isAddRemainingTriplets_ = isAddTriplets;
}

void QuadrupletSeedMerger::setMergeTriplets

(

bool

isMergeTriplets

)

Definition at line 584 of file QuadrupletSeedMerger.cc.

References isMergeTriplets_.

                                                                  {
  isMergeTriplets_ = isMergeTriplets;
}

void QuadrupletSeedMerger::setTTRHBuilderLabel

(

std::string

label

)

Definition at line 573 of file QuadrupletSeedMerger.cc.

References diffTwoXMLs::label, and theTTRHBuilderLabel_.

                                                                {

  theTTRHBuilderLabel_ = label;
  
}

void QuadrupletSeedMerger::update

(

const edm::EventSetup &

es

)

Definition at line 86 of file QuadrupletSeedMerger.cc.

References edm::EventSetup::get(), and theTrackerGeometry_.

Referenced by progressbar.ProgressBar::__next__(), relval_steps.Matrix::__setitem__(), relval_steps.Steps::__setitem__(), Vispa.Gui.VispaWidget.VispaWidget::autosize(), Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Views.LineDecayView.LineDecayContainer::deselectAllObjects(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::deselectAllWidgets(), Vispa.Gui.VispaWidget.VispaWidget::enableAutosizing(), progressbar.ProgressBar::finish(), Vispa.Gui.MenuWidget.MenuWidget::leaveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Views.LineDecayView.LineDecayContainer::mouseMoveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseReleaseEvent(), Vispa.Views.LineDecayView.LineDecayContainer::objectMoved(), relval_steps.Steps::overwrite(), Vispa.Views.LineDecayView.LineDecayContainer::removeObject(), Vispa.Gui.ConnectableWidget.ConnectableWidget::removePorts(), Vispa.Gui.FindDialog.FindDialog::reset(), Vispa.Gui.PortConnection.PointToPointConnection::select(), Vispa.Gui.VispaWidget.VispaWidget::select(), Vispa.Views.LineDecayView.LineDecayContainer::select(), Vispa.Gui.VispaWidget.VispaWidget::setText(), Vispa.Gui.VispaWidget.VispaWidget::setTitle(), Vispa.Gui.ZoomableWidget.ZoomableWidget::setZoom(), Vispa.Views.LineDecayView.LineDecayContainer::setZoom(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

                                                         {
  // copy geometry
  es.get<TrackerDigiGeometryRecord>().get( theTrackerGeometry_ );
}

Member Data Documentation

bool QuadrupletSeedMerger::isAddRemainingTriplets_

private

Definition at line 112 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets(), QuadrupletSeedMerger(), and setAddRemainingTriplets().

bool QuadrupletSeedMerger::isMergeTriplets_

private

Definition at line 111 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets(), QuadrupletSeedMerger(), and setMergeTriplets().

OrderedHitSeeds QuadrupletSeedMerger::quads_

private

Definition at line 114 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets().

SeedingLayerSetsBuilder QuadrupletSeedMerger::theLayerBuilder_

private

Definition at line 106 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets().

ctfseeding::SeedingLayerSets QuadrupletSeedMerger::theLayerSets_

private

Definition at line 107 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets().

std::unique_ptr<SeedCreator> QuadrupletSeedMerger::theSeedCreator_

private

Definition at line 110 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets().

edm::ESHandle<TrackerGeometry> QuadrupletSeedMerger::theTrackerGeometry_

private

Definition at line 108 of file QuadrupletSeedMerger.h.

Referenced by printHit(), printNtuplet(), and update().

edm::ESHandle<TransientTrackingRecHitBuilder> QuadrupletSeedMerger::theTTRHBuilder_

private

Definition at line 109 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets().

std::string QuadrupletSeedMerger::theTTRHBuilderLabel_

private

Definition at line 113 of file QuadrupletSeedMerger.h.

Referenced by mergeTriplets(), and setTTRHBuilderLabel().