#include <StripCPEfromTemplate.h>

Inheritance diagram for StripCPEfromTemplate:

Public Member Functions
StripClusterParameterEstimator::LocalValues	localParameters (const SiStripCluster &, const GeomDetUnit &, const LocalTrajectoryParameters &) const

	StripCPEfromTemplate (edm::ParameterSet &conf, const MagneticField &mag, const TrackerGeometry &geom, const SiStripLorentzAngle &lorentz, const SiStripBackPlaneCorrection &backplaneCorrections, const SiStripConfObject &confObj, const SiStripLatency &latency)

Public Member Functions inherited from StripCPE
LocalVector	driftDirection (const StripGeomDetUnit *det) const

AlgoParam	getAlgoParam (const GeomDetUnit &det, const LocalTrajectoryParameters &ltp) const

StripClusterParameterEstimator::LocalValues	localParameters (const SiStripCluster &cl, const GeomDetUnit &) const override

virtual StripClusterParameterEstimator::LocalValues	localParameters (const SiStripCluster &cl, AlgoParam const &ap) const

	StripCPE (edm::ParameterSet &conf, const MagneticField &, const TrackerGeometry &, const SiStripLorentzAngle &, const SiStripBackPlaneCorrection &, const SiStripConfObject &, const SiStripLatency &)

Public Member Functions inherited from StripClusterParameterEstimator
virtual void	localParameters (AClusters const &clusters, ALocalValues &retValues, const GeomDetUnit &gd, const LocalTrajectoryParameters &ltp) const

virtual LocalValues	localParameters (const SiStripCluster &cluster, const GeomDetUnit &gd, const TrajectoryStateOnSurface &tsos) const

virtual VLocalValues	localParametersV (const SiStripCluster &cluster, const GeomDetUnit &gd) const

virtual VLocalValues	localParametersV (const SiStripCluster &cluster, const GeomDetUnit &gd, const TrajectoryStateOnSurface &tsos) const

virtual	~StripClusterParameterEstimator ()

Private Attributes
int	template_reco_speed

std::vector< SiStripTemplateStore >	theStripTemp_

bool	use_strip_split_cluster_errors

bool	use_template_reco

Additional Inherited Members
Public Types inherited from StripClusterParameterEstimator
using	AClusters = DynArray< SiStripCluster const * >

using	ALocalValues = DynArray< LocalValues >

using	LocalValues = std::pair< LocalPoint, LocalError >

typedef std::vector< LocalValues >	VLocalValues

Protected Member Functions inherited from StripCPE
Param const &	param (const GeomDetUnit &det) const

Protected Attributes inherited from StripCPE
const SiStripBackPlaneCorrection &	BackPlaneCorrectionMap_

const TrackerGeometry &	geom_

const SiStripLorentzAngle &	LorentzAngleMap_

const MagneticField &	magfield_

const bool	peakMode_

std::vector< float >	xtalk1

std::vector< float >	xtalk2

Detailed Description

Definition at line 10 of file StripCPEfromTemplate.h.

Constructor & Destructor Documentation

StripCPEfromTemplate::StripCPEfromTemplate	(	edm::ParameterSet &	conf,
		const MagneticField &	mag,
		const TrackerGeometry &	geom,
		const SiStripLorentzAngle &	lorentz,
		const SiStripBackPlaneCorrection &	backplaneCorrections,
		const SiStripConfObject &	confObj,
		const SiStripLatency &	latency
	)

inline

Definition at line 19 of file StripCPEfromTemplate.h.

References SiStripTemplate::pushfile(), and theStripTemp_.

     : StripCPE(conf, mag, geom, lorentz, backplaneCorrections, confObj, latency ),
     use_template_reco( conf.getParameter<bool>("UseTemplateReco") ),
     template_reco_speed( conf.getParameter<int>("TemplateRecoSpeed") ),
     use_strip_split_cluster_errors( conf.getParameter<bool>("UseStripSplitClusterErrors") )
     {
       SiStripTemplate::pushfile( 11, theStripTemp_ );
       SiStripTemplate::pushfile( 12, theStripTemp_ );
       SiStripTemplate::pushfile( 13, theStripTemp_ );
       SiStripTemplate::pushfile( 14, theStripTemp_ );
       SiStripTemplate::pushfile( 15, theStripTemp_ );
       SiStripTemplate::pushfile( 16, theStripTemp_ );
 
       //cout << "STRIPS: (int)use_template_reco = " << (int)use_template_reco << endl;
       //cout << "template_reco_speed    = " << template_reco_speed    << endl;
       //cout << "(int)use_strip_split_cluster_errors = " << (int)use_strip_split_cluster_errors << endl;
     }

Member Function Documentation

StripClusterParameterEstimator::LocalValues StripCPEfromTemplate::localParameters	(	const SiStripCluster &	cluster,
		const GeomDetUnit &	det,
		const LocalTrajectoryParameters &	ltp
	)		const

virtual

Reimplemented from StripClusterParameterEstimator.

Definition at line 23 of file StripCPEfromTemplate.cc.

References SiStripCluster::amplitudes(), StripCPE::Param::backplanecorrection, SiStripCluster::barycenter(), StripCPE::Param::coveredStrips(), StripCPE::Param::drift, f, SiStripCluster::firstStrip(), GeomDet::geographicalId(), SiStripCluster::getSplitClusterError(), i, MagneticField::inTesla(), StripTopology::localError(), StripTopology::localPitch(), StripTopology::localPosition(), PV3DBase< T, PVType, FrameType >::mag(), StripCPE::magfield_, StripCPE::Param::maxLength, StripCPE::Param::moduleGeom, LocalTrajectoryParameters::momentum(), AlCaHLTBitMon_ParallelJobs::p, StripCPE::param(), GloballyPositioned< T >::position(), LocalTrajectoryParameters::position(), findQualityFiles::size, HLT_25ns10e33_v2_cff::speed, SiStripDetId::stereo(), SiStripTemplateReco::StripTempReco1D(), GeomDet::surface(), template_reco_speed, theStripTemp_, StripCPE::Param::thickness, toLocal(), StripCPE::Param::topology, use_strip_split_cluster_errors, use_template_reco, LocalTrajectoryParameters::vector(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), LocalError::yy(), and PV3DBase< T, PVType, FrameType >::z().

 {
   StripClusterParameterEstimator::LocalValues final_lv;
 
   LocalPoint final_lp;
   LocalError final_le; 
 
   // Default reconstruction (needed if template reco fails)
 
   StripCPE::Param const& p = param( det );
 
   LocalVector track = ltp.momentum();
   track *= 
     ( track.z()<0 ) ?  fabs( p.thickness/track.z() ) : 
     ( track.z()>0 ) ? -fabs( p.thickness/track.z() ) :  
     p.maxLength/track.mag() ;
 
   const unsigned N = cluster.amplitudes().size();
 
   const float fullProjection = p.coveredStrips( track+p.drift, ltp.position());
 
   const float strip = cluster.barycenter() -  0.5f*(1.f-p.backplanecorrection) * fullProjection
     + 0.5f*p.coveredStrips(track, ltp.position());
   
   LocalPoint default_lp = p.topology->localPosition( strip, ltp.vector() );
 
 
 
 
  
   // Get the error of the split cluster.
   // If the cluster is not split, then the error is -99999.9.
   // The split cluster error is in microns and it has to be transformed into centimeteres and then in measurement units
   
   float uerr2 = -99999.9;
   float split_cluster_error = cluster.getSplitClusterError(); 
 
   float local_pitch = p.topology->localPitch( default_lp );
 
   if ( split_cluster_error > 0.0 && use_strip_split_cluster_errors )
     {
       //cout << endl;
       //cout << "Assign split rechit errors" << endl;
       // go from microns to cm and then to strip units...
       
       uerr2 = 
     (split_cluster_error/10000.0 / local_pitch ) * 
     (split_cluster_error/10000.0 / local_pitch ); 
     }
   else
     {
       //cout << endl;
       //cout << "Assign default rechit errors" << endl;
       uerr2 = stripErrorSquared( N, fabs(fullProjection) );
     }
   
   
   LocalError default_le = p.topology->localError( strip, uerr2, ltp.vector() );
 
 
 
   // Template reconstruction
  
   int ierr = 9999999; // failed template reco ( if ierr = 0, then, template reco was successful )
   float template_x_pos = -9999999.9;
   float template_x_err = -9999999.9;
 
   // int cluster_size = (int)cluster.amplitudes().size();
   
   // do not use template reco for huge clusters
   if ( use_template_reco )
     {    
 
       int id = -9999999;
       
       SiStripDetId ssdid = SiStripDetId( det.geographicalId() );
 
       int is_stereo = (int)( ssdid.stereo() ); 
       
       if      ( p.moduleGeom == 1 ) // IB1 
     {
       if ( !is_stereo ) 
         id = 11;
       else
         id = 12;
     }
       else if ( p.moduleGeom == 2 ) // IB2
     {
       id = 13;
     }
       else if ( p.moduleGeom == 3 ) // OB1
     {
       id = 16; 
     }
       else if ( p.moduleGeom == 4 ) // OB2
     {
       if ( !is_stereo )
         id = 14;
       else
         id = 15;
     }
       //else 
       //cout << "Do not use templates for strip modules other than IB1, IB2, OB1 and OB2" << endl;
       
       const StripGeomDetUnit* stripdet = (const StripGeomDetUnit*)(&det);
  
       if ( (id  > -9999999) && !(stripdet == 0) )
     {
       // Variables needed by template reco
       float cotalpha = -9999999.9; 
       float cotbeta  = -9999999.9;
       float locBy    = -9999999.9;
       std::vector<float> vec_cluster_charge; 
       
       // Variables returned by template reco 
       float xrec   = -9999999.9; 
       float sigmax = -9999999.9; 
       float probx  = -9999999.9; 
       int qbin     = -9999999  ;
       int speed    = template_reco_speed        ; 
       float probQ  = -9999999.9; 
       
       
       LocalVector lbfield = ( stripdet->surface() ).toLocal( magfield_.inTesla( stripdet->surface().position() ) ); 
       locBy = lbfield.y();
           
       
       LocalVector localDir = ltp.momentum()/ltp.momentum().mag();     
       float locx = localDir.x();
       float locy = localDir.y();
       float locz = localDir.z();
       cotalpha = locx/locz;
       cotbeta  = locy/locz;
       
       
       int cluster_size = (int)( (cluster.amplitudes()).size() );
       for (int i=0; i<cluster_size; ++i)
         {
           vec_cluster_charge.push_back( (float)( (cluster.amplitudes())[i] ) );  
         }
       
       
       float measurement_position_first_strip_center = (float)(cluster.firstStrip()) + 0.5;
       
       LocalPoint local_position_first_strip_center 
         = p.topology->localPosition( measurement_position_first_strip_center, ltp.vector() );
       
 
           SiStripTemplate templ(theStripTemp_);
       ierr = SiStripTemplateReco::StripTempReco1D( id, 
                                cotalpha, 
                                cotbeta, 
                                locBy, 
                                vec_cluster_charge, 
                                templ, 
                                xrec, 
                                sigmax, 
                                probx, 
                                qbin, 
                                speed, 
                                probQ ); 
       
       
 
       // stripCPEtemplateProbability_ = probQ;
       // stripCPEtemplateQbin_ = qbin; 
 
      
       template_x_pos = xrec / 10000.0  +  local_position_first_strip_center.x();
      
       if ( split_cluster_error > 0.0 && use_strip_split_cluster_errors )
         {
           template_x_err = split_cluster_error/10000.0; 
         }
       else
         {
           template_x_err = sigmax/10000.0;
         }
 
 
     } // if ( id  > -9999999 && !stripdet == 0 ) 
       
     } // if ( use_template_reco )
 
 
   if ( use_template_reco && ierr == 0 )
     {
       //cout << "Use template reco " << ierr << endl;
       
       LocalPoint template_lp( template_x_pos               , default_lp.y() , default_lp.z()  );
       LocalError template_le( template_x_err*template_x_err, default_le.xy(), default_le.yy() );
       
 
       final_lv = std::make_pair( template_lp, template_le ); 
     
     }
   else
     {
       //cout << "Use default reco " << ierr << endl;
       
       final_lv = std::make_pair( default_lp, default_le );
     }
 
   return final_lv; 
 
 
 }