/data/refman/pasoursint/CMSSW_6_1_2_SLHC2_patch1/src/SLHCUpgradeSimulations/L1TrackTrigger/src/WindowFinder.cc

Go to the documentation of this file.

#include "SLHCUpgradeSimulations/L1TrackTrigger/interface/WindowFinder.h"
#include <iostream>


WindowFinder::WindowFinder( const StackedTrackerGeometry *aGeometry,
                                         double aPtScalingFactor,
                                         double aIPwidth,
                                         double aRowResolution,
                                         double aColResolution )
  : mGeometry( aGeometry ),
    mPtScalingFactor( aPtScalingFactor ),
    mIPwidth( aIPwidth ),
    mRowResolution( aRowResolution ),
    mColResolution( aColResolution ),
    mMinrow(0), mMaxrow(0), mMincol(0), mMaxcol(0),
    mLastId(0), mlastInnerRow(-1), mlastInnerCol(-1){}

WindowFinder::~WindowFinder(){}

void WindowFinder::dumphit( const StackedTrackerDetId & anId,
                                         unsigned int hitIdentifier,
                                         const double & aInnerRow,
                                         const double & aInnerColumn )
{
  const PixelGeomDetUnit* detunit = reinterpret_cast< const PixelGeomDetUnit* > (mGeometry -> idToDetUnit( anId, hitIdentifier ));

  MeasurementPoint mp( aInnerRow + (0.5*mRowResolution), aInnerColumn + (0.5*mColResolution) );
  LocalPoint LP  = detunit->topology().localPosition( mp );
  GlobalPoint GP = detunit->surface().toGlobal( LP );
  std::cout << (hitIdentifier?"INNER":"OUTER") << " -> eta = " << GP.eta() << std::endl;
}

StackedTrackerWindow WindowFinder::getWindow( const StackedTrackerDetId & anId,
                                                                        const double & aInnerRow,
                                                                        const double & aInnerColumn )
{
  if ( (anId == mLastId) && (mlastInnerRow == aInnerRow) && (mlastInnerCol == aInnerColumn) )
  {
    StackedTrackerWindow thisWindow = StackedTrackerWindow( mMinrow, mMaxrow, mMincol, mMaxcol );
    return thisWindow;
  }

  mlastInnerRow = aInnerRow;
  mlastInnerCol = aInnerColumn;

  if (anId != mLastId)
  {
    mLastId = anId;
    mInnerDet = const_cast< PixelGeomDetUnit* >(reinterpret_cast< const PixelGeomDetUnit* > (mGeometry->idToDetUnit( anId, 0 )));
    mOuterDet = const_cast< PixelGeomDetUnit* >(reinterpret_cast< const PixelGeomDetUnit* > (mGeometry->idToDetUnit( anId, 1 )));

    mHalfPixelLength = mInnerDet->specificTopology().pitch().second * mColResolution * 0.5;
    mSeparation = mInnerDet->surface().localZ( mOuterDet->position() );
    if ( mSeparation < 0 )
      mSeparation = -mSeparation;

    mInnerDetRadius  = mInnerDet->position().perp();
    mInnerDetPhi     = mInnerDet->position().phi();
  }

  MeasurementPoint MP_INNER( aInnerRow + (0.5*mRowResolution), aInnerColumn + (0.5*mColResolution) );

  LocalPoint       LP_INNER = mInnerDet->topology().localPosition( MP_INNER );

  GlobalPoint      GP_INNER = mInnerDet->surface().toGlobal( LP_INNER );

  double           PHI = asin( mPtScalingFactor * GP_INNER.perp() );

  double           PixelAngle = acos( sin( mInnerDetPhi - GP_INNER.phi() ) * mInnerDetRadius / LP_INNER.x() );

  double           deltaXminus = ( mSeparation * tan( PixelAngle - PHI ));  
  double           deltaXplus  = ( mSeparation * tan( PixelAngle + PHI ));  

  double           PIXEL_Z_PLUS  = GP_INNER.z()+mHalfPixelLength;
  double           PIXEL_Z_MINUS = GP_INNER.z()-mHalfPixelLength;

  double           IP_Z_PLUS  =  mIPwidth;
  double           IP_Z_MINUS = -mIPwidth;

  double                R_SEPARATION =  mSeparation / cos( PixelAngle );
  if (R_SEPARATION < 0)
    R_SEPARATION = -R_SEPARATION;

  double           deltaZminus = (PIXEL_Z_MINUS-IP_Z_PLUS) * R_SEPARATION / GP_INNER.perp();  
  double           deltaZplus  = (PIXEL_Z_PLUS-IP_Z_MINUS) * R_SEPARATION / GP_INNER.perp();    

  LocalPoint LP_OUTER_PLUS( LP_INNER.x()-deltaXplus , LP_INNER.y()-mHalfPixelLength-deltaZplus , -mSeparation );
  LocalPoint LP_OUTER_MINUS( LP_INNER.x()-deltaXminus , LP_INNER.y()+mHalfPixelLength-deltaZminus , -mSeparation );

  GlobalPoint GP_OUTER_PLUS = mInnerDet ->surface().toGlobal(LP_OUTER_PLUS);
  GlobalPoint GP_OUTER_MINUS = mInnerDet ->surface().toGlobal(LP_OUTER_MINUS);

  LocalPoint LP_OUTER_PLUS_2 = mOuterDet ->surface().toLocal(GP_OUTER_PLUS);
  LocalPoint LP_OUTER_MINUS_2 = mOuterDet ->surface().toLocal(GP_OUTER_MINUS);

  std::pair<float,float> PLUS = mOuterDet -> specificTopology().pixel(LP_OUTER_PLUS_2);
  std::pair<float,float> MINUS = mOuterDet -> specificTopology().pixel(LP_OUTER_MINUS_2);

  mMinrow = mRowResolution * floor( PLUS.first / mRowResolution ); 
  mMincol = mColResolution * floor( PLUS.second / mColResolution );
  mMaxrow = mRowResolution * floor( MINUS.first / mRowResolution );
  mMaxcol = mColResolution * floor( MINUS.second / mColResolution ); 

  if (mMinrow>mMaxrow)
    std::swap(mMinrow,mMaxrow);
  if (mMincol>mMaxcol)
    std::swap(mMincol,mMaxcol);

  StackedTrackerWindow theWindow = StackedTrackerWindow( mMinrow, mMaxrow, mMincol, mMaxcol );
  return theWindow;
}