Merge pull request cms-sw#2333 from mschrode/LABPinTkAl_71X

Alignment/CommonAlignmentProducer -- Update on Lorentz-Anlge and Backplane correction related developments (7_1_X)

Author: nclopezo

Alignment/CommonAlignmentProducer/bin/aligncond_split_iov.cc

@@ -26,6 +26,9 @@
 #include "CondFormats/Alignment/interface/Alignments.h"
 #include "CondFormats/Alignment/interface/AlignmentErrors.h"
 #include "CondFormats/Alignment/interface/AlignmentSurfaceDeformations.h"
+#include "CondFormats/SiPixelObjects/interface/SiPixelLorentzAngle.h"
+#include "CondFormats/SiStripObjects/interface/SiStripLorentzAngle.h"
+#include "CondFormats/SiStripObjects/interface/SiStripBackPlaneCorrection.h"
 
 #include <iterator>
 #include <iostream>
@@ -131,6 +134,15 @@ int cond::AlignSplitIOV::execute()
     else if (payloadContainerName=="AlignmentSurfaceDeformations")
       objToken = processPayloadContainer<AlignmentSurfaceDeformations>(sourcedb, destdb,
 								       ioviterator->token(), payloadContainerName);
+    else if (payloadContainerName=="SiPixelLorentzAngle")
+      objToken = processPayloadContainer<SiPixelLorentzAngle>(sourcedb, destdb,
+								       ioviterator->token(), payloadContainerName);
+    else if (payloadContainerName=="SiStripLorentzAngle")
+      objToken = processPayloadContainer<SiStripLorentzAngle>(sourcedb, destdb,
+								       ioviterator->token(), payloadContainerName);
+    else if (payloadContainerName=="SiStripBackPlaneCorrection")
+      objToken = processPayloadContainer<SiStripBackPlaneCorrection>(sourcedb, destdb,
+								       ioviterator->token(), payloadContainerName);
     else {
       return 1;
     }

Alignment/CommonAlignmentProducer/interface/AlignmentTrackSelector.h

@@ -81,6 +81,10 @@ class AlignmentTrackSelector
   const int minHitsinENDCAP_, minHitsinENDCAPplus_, minHitsinENDCAPminus_;
   const double maxHitDiffEndcaps_;
   const double nLostHitMax_;
+  std::vector<double> RorZofFirstHitMin_;
+  std::vector<double> RorZofFirstHitMax_;
+  std::vector<double> RorZofLastHitMin_;
+  std::vector<double> RorZofLastHitMax_;
 
   const edm::InputTag clusterValueMapTag_;  // ValueMap containing association cluster - flag
   const int minPrescaledHits_;

Alignment/CommonAlignmentProducer/python/AlignmentTrackSelector_cfi.py

@@ -26,6 +26,10 @@
     nHitMax = cms.double(999.0),
     nLostHitMax = cms.double(999.0),          
     nHitMin2D = cms.uint32(0),
+    RorZofFirstHitMin = cms.vdouble(0.0,0.0),
+    RorZofFirstHitMax = cms.vdouble(999.0,999.0),
+    RorZofLastHitMin = cms.vdouble(0.0,0.0),
+    RorZofLastHitMax = cms.vdouble(999.0,999.0),
     countStereoHitAs2D = cms.bool(True),
     minHitsPerSubDet = cms.PSet(
         inTEC = cms.int32(0),

Alignment/CommonAlignmentProducer/src/AlignmentTrackSelector.cc

@@ -24,6 +24,9 @@
 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
 #include "Geometry/Records/interface/IdealGeometryRecord.h"
+
+#include <cmath>
+
 const int kBPIX = PixelSubdetector::PixelBarrel;
 const int kFPIX = PixelSubdetector::PixelEndcap;
 
@@ -81,6 +84,10 @@ AlignmentTrackSelector::AlignmentTrackSelector(const edm::ParameterSet & cfg) :
   minHitsinENDCAPminus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inENDCAPminus" ) ),
   maxHitDiffEndcaps_( cfg.getParameter<double>( "maxHitDiffEndcaps" ) ),
   nLostHitMax_( cfg.getParameter<double>( "nLostHitMax" ) ),
+  RorZofFirstHitMin_( cfg.getParameter<std::vector<double> >( "RorZofFirstHitMin" ) ),
+  RorZofFirstHitMax_( cfg.getParameter<std::vector<double> >( "RorZofFirstHitMax" ) ),
+  RorZofLastHitMin_( cfg.getParameter<std::vector<double> >( "RorZofLastHitMin" ) ),
+  RorZofLastHitMax_( cfg.getParameter<std::vector<double> >( "RorZofLastHitMax" ) ),
   clusterValueMapTag_(cfg.getParameter<edm::InputTag>("hitPrescaleMapTag")),
   minPrescaledHits_( cfg.getParameter<int>("minPrescaledHits")),
   applyPrescaledHitsFilter_(clusterValueMapTag_.encode().size() && minPrescaledHits_ > 0)
@@ -173,6 +180,47 @@ AlignmentTrackSelector::AlignmentTrackSelector(const edm::ParameterSet & cfg) :
 
   }
 
+  // Checking whether cuts on positions of first and last track hits are defined properly
+  if(RorZofFirstHitMin_.size() != 2){
+      throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector" 
+	  << "Wrong configuration of 'RorZofFirstHitMin'."
+	  << " Must have exactly 2 values instead of configured " << RorZofFirstHitMin_.size() << ")";
+  } else {
+    RorZofFirstHitMin_.at(0)=std::fabs(RorZofFirstHitMin_.at(0));
+    RorZofFirstHitMin_.at(1)=std::fabs(RorZofFirstHitMin_.at(1));
+  }
+  if(RorZofFirstHitMax_.size() != 2){
+      throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector" 
+	  << "Wrong configuration of 'RorZofFirstHitMax'."
+	  << " Must have exactly 2 values instead of configured " << RorZofFirstHitMax_.size() << ")";
+  } else {
+    RorZofFirstHitMax_.at(0) = std::fabs(RorZofFirstHitMax_.at(0));
+    RorZofFirstHitMax_.at(1) = std::fabs(RorZofFirstHitMax_.at(1));
+  }
+  if(RorZofLastHitMin_.size() != 2){
+      throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector" 
+	  << "Wrong configuration of 'RorZofLastHitMin'."
+	  << " Must have exactly 2 values instead of configured " << RorZofLastHitMin_.size() << ")";
+  } else {
+    RorZofLastHitMin_.at(0) = std::fabs(RorZofLastHitMin_.at(0));
+    RorZofLastHitMin_.at(1) = std::fabs(RorZofLastHitMin_.at(1));
+  }
+  if(RorZofLastHitMax_.size() != 2){
+      throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector" 
+	  << "Wrong configuration of 'RorZofLastHitMax'."
+	  << " Must have exactly 2 values instead of configured " << RorZofLastHitMax_.size() << ")";
+  } else {
+    RorZofLastHitMax_.at(0) = std::fabs(RorZofLastHitMax_.at(0));
+    RorZofLastHitMax_.at(1) = std::fabs(RorZofLastHitMax_.at(1));
+  }
+  // If first hit set to be at larger distance then the last hit
+  if(RorZofFirstHitMin_.at(0) > RorZofLastHitMax_.at(0) && RorZofFirstHitMin_.at(1) > RorZofLastHitMax_.at(1)){
+      throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector" 
+	  << "Position of the first hit is set to larger distance than the last hit:."
+	  << " First hit(min): [" << RorZofFirstHitMin_.at(0) << ", " << RorZofFirstHitMin_.at(1) << "]; Last hit(max): [" 
+	  << RorZofLastHitMax_.at(0) << ", " << RorZofLastHitMax_.at(1) << "];";
+  }
+
 }
 
 // destructor -----------------------------------------------------------------
@@ -294,7 +342,8 @@ bool AlignmentTrackSelector::detailedHitsCheck(const reco::Track *trackp, const
       || minHitsinFPIXplus_ || minHitsinFPIXminus_
       || minHitsinTECplus_ || minHitsinTECminus_
       || minHitsinFPIX_ || minHitsinBPIX_ || minHitsinPIX_ ||nHitMin2D_ || chargeCheck_
-      || applyIsolation_ || (seedOnlyFromAbove_ == 1 || seedOnlyFromAbove_ == 2)) {
+      || applyIsolation_ || (seedOnlyFromAbove_ == 1 || seedOnlyFromAbove_ == 2)
+      || RorZofFirstHitMin_.size() > 0 || RorZofFirstHitMax_.size() > 0 || RorZofLastHitMin_.size() > 0 || RorZofLastHitMax_.size() > 0 ) {
     // any detailed hit cut is active, so have to check
 
     int nhitinTIB = 0, nhitinTOB = 0, nhitinTID = 0;
@@ -372,6 +421,40 @@ bool AlignmentTrackSelector::detailedHitsCheck(const reco::Track *trackp, const
       // Do not call isHit2D(..) if already enough 2D hits for performance reason:
       if (nHit2D < nHitMin2D_ && this->isHit2D(**iHit)) ++nHit2D;
     } // end loop on hits
+
+
+    // Checking whether the track satisfies requirement of the first and last hit positions
+    bool passedLastHitPositionR = true;
+    bool passedLastHitPositionZ = true;
+    bool passedFirstHitPositionR = true;
+    bool passedFirstHitPositionZ = true;
+    
+    if( RorZofFirstHitMin_.at(0) != 0.0 || RorZofFirstHitMin_.at(1) != 0.0 
+      || RorZofFirstHitMax_.at(0) != 999.0 || RorZofFirstHitMax_.at(1) != 999.0 ) {
+
+      const reco::TrackBase::Point firstPoint(trackp->innerPosition());
+
+      if( (std::fabs(firstPoint.R()) < RorZofFirstHitMin_.at(0) )) passedFirstHitPositionR = false;
+      if( (std::fabs(firstPoint.R()) > RorZofFirstHitMax_.at(0) )) passedFirstHitPositionR = false;
+      if( (std::fabs(firstPoint.Z()) < RorZofFirstHitMin_.at(1) )) passedFirstHitPositionZ = false;
+      if( (std::fabs(firstPoint.Z()) > RorZofFirstHitMax_.at(1) )) passedFirstHitPositionZ = false;
+    }
+    
+    if( RorZofLastHitMin_.at(0) != 0.0 || RorZofLastHitMin_.at(1) != 0.0 
+      || RorZofLastHitMax_.at(0) != 999.0 || RorZofLastHitMax_.at(1) != 999.0 ) {
+
+      const reco::TrackBase::Point lastPoint(trackp->outerPosition());
+
+      if( (std::fabs(lastPoint.R()) < RorZofLastHitMin_.at(0) )) passedLastHitPositionR = false;
+      if( (std::fabs(lastPoint.R()) > RorZofLastHitMax_.at(0) )) passedLastHitPositionR = false;
+      if( (std::fabs(lastPoint.Z()) < RorZofLastHitMin_.at(1) )) passedLastHitPositionZ = false;
+      if( (std::fabs(lastPoint.Z()) > RorZofLastHitMax_.at(1) )) passedLastHitPositionZ = false;
+    }
+
+    bool passedFirstHitPosition = passedFirstHitPositionR || passedFirstHitPositionZ;
+    bool passedLastHitPosition = passedLastHitPositionR || passedLastHitPositionZ;
+
+
 
     return (nhitinTIB >= minHitsinTIB_ && nhitinTOB >= minHitsinTOB_ 
             && nhitinTID >= minHitsinTID_ && nhitinTEC >= minHitsinTEC_ 
@@ -382,7 +465,7 @@ bool AlignmentTrackSelector::detailedHitsCheck(const reco::Track *trackp, const
             && nhitinTECplus >= minHitsinTECplus_ && nhitinTECminus >= minHitsinTECminus_
             && nhitinBPIX >= minHitsinBPIX_ 
 	    && nhitinFPIX >= minHitsinFPIX_ && nhitinPIXEL>=minHitsinPIX_ 
-            && nHit2D >= nHitMin2D_);
+            && nHit2D >= nHitMin2D_ && passedFirstHitPosition && passedLastHitPosition);
   } else { // no cuts set, so we are just fine and can avoid loop on hits
     return true;
   }