From cmssw 6 2 0 slhc10

CalibCalorimetry/HcalPlugins/python/Hcal_Conditions_forGlobalTag_cff.py

@@ -12,7 +12,6 @@
 toGet = cms.untracked.vstring('GainWidths'),
 #--- the following 5 parameters can be omitted in case of regular Geometry 
     iLumi = cms.double(-1.),                 # for Upgrade: fb-1
-    HcalReLabel =  HcalReLabel,              # for Upgrade
     HERecalibration = cms.bool(False),       # True for Upgrade   
     HEreCalibCutoff = cms.double(20.),       # if above is True  
     HFRecalibration = cms.bool(False),       # True for Upgrade

CalibCalorimetry/HcalPlugins/src/HcalHardcodeCalibrations.cc

@@ -108,7 +108,7 @@ namespace {
 
 }
 
-HcalHardcodeCalibrations::HcalHardcodeCalibrations ( const edm::ParameterSet& iConfig ): he_recalibration(0), hf_recalibration(0)
+HcalHardcodeCalibrations::HcalHardcodeCalibrations ( const edm::ParameterSet& iConfig ): he_recalibration(0), hf_recalibration(0), setHEdsegm(false)
 {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
 
@@ -134,41 +134,6 @@ HcalHardcodeCalibrations::HcalHardcodeCalibrations ( const edm::ParameterSet& iC
     //     std::cout << " HcalHardcodeCalibrations:  iLumi = " <<  iLumi << std::endl;
   }
 
-  bool relabel_=false;
-  edm::ParameterSet ps0;
-  if ( iConfig.exists("HcalReLabel") ) {
-    ps0 = iConfig.getParameter<edm::ParameterSet>("HcalReLabel");
-    relabel_= ps0.getUntrackedParameter<bool>("RelabelHits",false);
-  }
-
-  if (relabel_) {
-    std::vector<std::vector<int>> m_segmentation;
-    m_segmentation.resize(29);
-    edm::ParameterSet ps1 = ps0.getUntrackedParameter<edm::ParameterSet>("RelabelRules");
-    for (int i = 0; i < 29; i++) {
-      char name[10];
-      snprintf(name,10,"Eta%d",i+1);
-      if (i > 0) {
-	m_segmentation[i]=
-	  ps1.getUntrackedParameter<std::vector<int>>(name,m_segmentation[i-1]);
-      } else {
-	m_segmentation[i]=ps1.getUntrackedParameter<std::vector<int> >(name);
-      }
-
-      /*
-      std::cout << name;
-      for (unsigned int k=0; k<m_segmentation[i].size(); k++) {
-	std::cout << " [" << k << "] " << m_segmentation[i][k];
-      }
-      std::cout << std::endl;
-      */
-
-    }
-
-    if(he_recalibration !=0) he_recalibration->setDsegm(m_segmentation);
-  }
-
-
   std::vector <std::string> toGet = iConfig.getUntrackedParameter <std::vector <std::string> > ("toGet");
   for(std::vector <std::string>::iterator objectName = toGet.begin(); objectName != toGet.end(); ++objectName ) {
     bool all = *objectName == "all";
@@ -394,6 +359,18 @@ std::auto_ptr<HcalRespCorrs> HcalHardcodeCalibrations::produceRespCorrs (const H
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
+  //set depth segmentation for HE recalib - only happens once
+  if(he_recalibration && !setHEdsegm){
+    std::vector<std::vector<int>> m_segmentation;
+    m_segmentation.resize(29);
+    for (int i = 0; i < 29; i++) {
+      if(i>0) topo->getDepthSegmentation(i,m_segmentation[i]);
+    }
+
+    he_recalibration->setDsegm(m_segmentation);
+	setHEdsegm = true;
+  }
+
   std::auto_ptr<HcalRespCorrs> result (new HcalRespCorrs (topo));
   std::vector <HcalGenericDetId> cells = allCells(*topo);
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); cell++) {

CalibCalorimetry/HcalPlugins/src/HcalHardcodeCalibrations.h

@@ -91,5 +91,6 @@ class HcalHardcodeCalibrations : public edm::ESProducer,
   HERecalibration* he_recalibration;  
   HFRecalibration* hf_recalibration;  
   bool switchGainWidthsForTrigPrims; 
+  bool setHEdsegm;
 };
 

CommonTools/ParticleFlow/python/pfTaus_cff.py

@@ -34,15 +34,23 @@
 pfJetsLegacyHPSPiZeros.jetSrc = cms.InputTag("ak5PFJets")
 
 pfTauPFJets08Region = recoTauAK5PFJets08Region.clone()
+pfTauPFJetsRecoTauChargedHadrons = ak5PFJetsRecoTauChargedHadrons.clone()
 pfTauPFJets08Region.src = cms.InputTag("ak5PFJets")
 pfTauPFJets08Region.pfSrc = cms.InputTag("particleFlow")
-pfJetsLegacyHPSPiZeros.jetRegionSrc = 'pfTauPFJets08Region'
+pfTauPFJetsRecoTauChargedHadrons.jetRegionSrc = 'pfTauPFJets08Region'
+
+pfTauTagInfoProducer = pfRecoTauTagInfoProducer.clone()
+pfTauTagInfoProducer.PFCandidateProducer = ak5PFJets.src
+pfTauTagInfoProducer.PFJetTracksAssociatorProducer = 'pfJetTracksAssociatorAtVertex'
 
 # Clone tau producer
 pfTausProducer = hpsPFTauProducer.clone()
 pfTausCombiner = combinatoricRecoTaus.clone()
 pfTausCombiner.jetSrc= cms.InputTag("ak5PFJets")
 pfTausCombiner.piZeroSrc= "pfJetsLegacyHPSPiZeros"
+pfTausCombiner.jetRegionSrc='pfTauPFJets08Region'
+pfTausCombiner.chargedHadronSrc='pfTauPFJetsRecoTauChargedHadrons'
+pfTausCombiner.modifiers[3].pfTauTagInfoSrc=cms.InputTag("pfTauTagInfoProducer")
 pfTausSelectionDiscriminator = hpsSelectionDiscriminator.clone()
 pfTausSelectionDiscriminator.PFTauProducer = cms.InputTag("pfTausCombiner")
 pfTausProducerSansRefs = hpsPFTauProducerSansRefs.clone()
@@ -93,6 +101,7 @@
 # Sequence to reproduce taus and compute our cloned discriminants
 pfTausBaseSequence = cms.Sequence(
    pfJetsLegacyHPSPiZeros +
+   pfTauPFJetsRecoTauChargedHadrons +
    pfTausCombiner +
    pfTausSelectionDiscriminator +
    pfTausProducerSansRefs +
@@ -130,20 +139,18 @@
 pfTaus = pfTauSelector.clone()
 pfTaus.src = cms.InputTag("pfTausProducer")
 pfTaus.discriminators = cms.VPSet(
-    cms.PSet( discriminator=cms.InputTag("pfTausDiscriminationByDecayModeFinding"),selectionCut=cms.double(0.5) ),
-    cms.PSet( discriminator=cms.InputTag("pfTausDiscriminationByIsolation"),selectionCut=cms.double(0.5) )
-    )
-
+        cms.PSet( discriminator=cms.InputTag("pfTausDiscriminationByDecayModeFinding"),selectionCut=cms.double(0.5) ),
+            )
 
 pfTausPtrs = cms.EDProducer("PFTauFwdPtrProducer",
-                            src=cms.InputTag("pfTaus")
-                            )
+                             src=cms.InputTag("pfTaus")
+                                                        )
 
 pfTauSequence = cms.Sequence(
     pfTausPreSequence +
-    pfTausBaseSequence + 
+    pfTausBaseSequence +
     pfTaus +
-    pfTausPtrs 
-    )
+    pfTausPtrs
+ )
 
 

CondTools/Geometry/plugins/calowriters.cc

@@ -165,6 +165,160 @@ CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter>::produceAligned( const type
 
     return ptr ; 
 }
+
+template<>
+CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>::PtrType
+CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>::produceAligned( const typename CaloTowerGeometry::AlignedRecord& iRecord ) {
+
+  const Alignments* alignPtr  ( 0 ) ;
+  const Alignments* globalPtr ( 0 ) ;
+  if( m_applyAlignment ) { // get ptr if necessary
+    edm::ESHandle< Alignments >                                      alignments ;
+    iRecord.getRecord< typename CaloTowerGeometry::AlignmentRecord >().get( alignments ) ;
+
+    assert( alignments.isValid() && // require valid alignments and expected sizet
+	    ( alignments->m_align.size() == CaloTowerGeometry::numberOfAlignments() ) ) ;
+    alignPtr = alignments.product() ;
+
+    edm::ESHandle< Alignments >                          globals   ;
+    iRecord.getRecord<GlobalPositionRcd>().get( globals ) ;
+
+    assert( globals.isValid() ) ;
+    globalPtr = globals.product() ;
+  }
+
+  TrVec  tvec ;
+  DimVec dvec ;
+  IVec   ivec ;
+  IVec   dins ;
+
+  if( CaloGeometryDBWriter::writeFlag() ) {
+    edm::ESHandle<CaloSubdetectorGeometry> pG ;
+    iRecord.get( CaloTowerGeometry::producerTag() + std::string("_master"), pG ) ; 
+
+    const CaloSubdetectorGeometry* pGptr ( pG.product() ) ;
+
+    pGptr->getSummary( tvec, ivec, dvec, dins ) ;
+
+    CaloGeometryDBWriter::writeIndexed( tvec, dvec, ivec, dins, CaloTowerGeometry::dbString() ) ;
+  } else {
+    edm::ESHandle<PCaloGeometry> pG ;
+    iRecord.getRecord<typename CaloTowerGeometry::PGeometryRecord >().get( pG ) ; 
+
+    tvec = pG->getTranslation() ;
+    dvec = pG->getDimension() ;
+    ivec = pG->getIndexes() ;
+    dins = pG->getDenseIndices();
+  }	 
+//*********************************************************************************************
+
+  edm::ESHandle<CaloTowerTopology> caloTopology;
+  iRecord.getRecord<HcalRecNumberingRecord>().get( caloTopology );
+
+
+  CaloTowerGeometry* ctg=new CaloTowerGeometry( &*caloTopology );
+
+  const unsigned int nTrParm ( tvec.size()/ctg->numberOfCellsForCorners() ) ;
+
+  assert( dvec.size() == ctg->numberOfShapes() * CaloTowerGeometry::k_NumberOfParametersPerShape ) ;
+
+
+  PtrType ptr ( ctg ) ;
+
+  ptr->fillDefaultNamedParameters() ;
+
+  ptr->allocateCorners( ctg->numberOfCellsForCorners() ) ;
+
+  ptr->allocatePar(    dvec.size() ,
+		       CaloTowerGeometry::k_NumberOfParametersPerShape ) ;
+
+  for( unsigned int i ( 0 ) ;  i < dins.size() ; ++i ) {
+    const unsigned int nPerShape ( ctg->numberOfParametersPerShape() ) ;
+    DimVec dims ;
+    dims.reserve( nPerShape ) ;
+
+    const unsigned int indx ( ivec.size()==1 ? 0 : i ) ;
+
+    DimVec::const_iterator dsrc ( dvec.begin() + ivec[indx]*nPerShape ) ;
+
+    for( unsigned int j ( 0 ) ; j != nPerShape ; ++j )  {
+      dims.push_back( *dsrc ) ;
+      ++dsrc ;
+    }
+
+    const CCGFloat* myParm ( CaloCellGeometry::getParmPtr( dims, 
+							   ptr->parMgr(), 
+							   ptr->parVecVec() ));
+
+
+    const DetId id ( caloTopology->detIdFromDenseIndex(dins[i]) ) ;
+
+    const unsigned int iGlob ( 0 == globalPtr ? 0 :
+			       ctg->alignmentTransformIndexGlobal( id ) ) ;
+
+    assert( 0 == globalPtr || iGlob < globalPtr->m_align.size() ) ;
+
+    const AlignTransform* gt ( 0 == globalPtr ? 0 : &globalPtr->m_align[ iGlob ] ) ;
+
+    assert( 0 == gt || iGlob == ctg->alignmentTransformIndexGlobal( DetId( gt->rawId() ) ) ) ;
+
+    const unsigned int iLoc ( 0 == alignPtr ? 0 :
+			      ctg->alignmentTransformIndexLocal( id ) ) ;
+
+    assert( 0 == alignPtr || iLoc < alignPtr->m_align.size() ) ;
+
+    const AlignTransform* at ( 0 == alignPtr ? 0 :
+			       &alignPtr->m_align[ iLoc ] ) ;
+
+    assert( 0 == at || ( ctg->alignmentTransformIndexLocal( DetId( at->rawId() ) ) == iLoc ) ) ;
+
+    const CaloGenericDetId gId ( id ) ;
+
+    Pt3D  lRef ;
+    Pt3DVec lc ( 8, Pt3D(0,0,0) ) ;
+    ctg->localCorners( lc, &dims.front(), dins[i], lRef ) ;
+
+    const Pt3D lBck ( 0.25*(lc[4]+lc[5]+lc[6]+lc[7] ) ) ; // ctr rear  face in local
+    const Pt3D lCor ( lc[0] ) ;
+
+    //----------------------------------- create transform from 6 numbers ---
+    const unsigned int jj ( i*nTrParm ) ;
+    Tr3D tr ;
+    const ROOT::Math::Translation3D tl ( tvec[jj], tvec[jj+1], tvec[jj+2] ) ;
+    const ROOT::Math::EulerAngles ea (
+				      6==nTrParm ?
+				      ROOT::Math::EulerAngles( tvec[jj+3], tvec[jj+4], tvec[jj+5] ) :
+				      ROOT::Math::EulerAngles() ) ;
+    const ROOT::Math::Transform3D rt ( ea, tl ) ;
+    double xx,xy,xz,dx,yx,yy,yz,dy,zx,zy,zz,dz;
+    rt.GetComponents(xx,xy,xz,dx,yx,yy,yz,dy,zx,zy,zz,dz) ;
+    tr = Tr3D( CLHEP::HepRep3x3( xx, xy, xz,
+				 yx, yy, yz,
+				 zx, zy, zz ), 
+	       CLHEP::Hep3Vector(dx,dy,dz)     );
+
+    // now prepend alignment(s) for final transform
+    const Tr3D atr ( 0 == at ? tr :
+		     ( 0 == gt ? at->transform()*tr :
+		       at->transform()*gt->transform()*tr ) ) ;
+    //--------------------------------- done making transform  ---------------
+
+    const Pt3D        gRef ( atr*lRef ) ;
+    const GlobalPoint fCtr ( gRef.x(), gRef.y(), gRef.z() ) ;
+    const Pt3D        gBck ( atr*lBck ) ;
+    const GlobalPoint fBck ( gBck.x(), gBck.y(), gBck.z() ) ;
+    const Pt3D        gCor ( atr*lCor ) ;
+    const GlobalPoint fCor ( gCor.x(), gCor.y(), gCor.z() ) ;
+
+    assert( caloTopology->denseIndex(id) == dins[i] );
+
+    ptr->newCell(  fCtr, fBck, fCor, myParm, id ) ;
+  }
+
+  ptr->initializeParms() ; // initializations; must happen after cells filled
+
+  return ptr ; 
+}
 
 template class CaloGeometryDBEP< EcalBarrelGeometry    , CaloGeometryDBWriter> ;
 template class CaloGeometryDBEP< EcalEndcapGeometry    , CaloGeometryDBWriter> ;