TrackAssociator.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    HTrackAssociator
// Class:      HTrackAssociator
// 
/*

 Description: <one line class summary>

 Implementation:
     <Notes on implementation>
*/
//
// Original Author:  Dmytro Kovalskyi
// Modified for ECAL+HCAL by:  Michal Szleper
//         Created:  Fri Apr 21 10:59:41 PDT 2006
//
//

#include "Calibration/Tools/interface/TrackAssociator.h"

// user include files


#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"

// calorimeter info
#include "Geometry/Records/interface/CaloGeometryRecord.h"




#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"

#include "TrackPropagation/SteppingHelixPropagator/interface/SteppingHelixPropagator.h"
#include <stack>
#include <set>



//
// class declaration
//

using namespace reco;

HTrackAssociator::HTrackAssociator() 
{
   ivProp_ = nullptr;
   defProp_ = nullptr;
   debug_ = 0;
   caloTowerMap_ = nullptr;
   useDefaultPropagator_ = false;
}

HTrackAssociator::~HTrackAssociator()
{
   if (defProp_) delete defProp_;
}

//-----------------------------------------------------------------------------
void HTrackAssociator::addDataLabels( const std::string className,
                     const std::string moduleLabel,
                     const std::string productInstanceLabel)
{
   if (className == "EBRecHitCollection")
     {
    EBRecHitCollectionLabels.clear();
    EBRecHitCollectionLabels.push_back(moduleLabel);
    EBRecHitCollectionLabels.push_back(productInstanceLabel);
     }
   if (className == "EERecHitCollection")
     {
    EERecHitCollectionLabels.clear();
    EERecHitCollectionLabels.push_back(moduleLabel);
    EERecHitCollectionLabels.push_back(productInstanceLabel);
     }
   if (className == "HBHERecHitCollection")
     {
    HBHERecHitCollectionLabels.clear();
    HBHERecHitCollectionLabels.push_back(moduleLabel);
    HBHERecHitCollectionLabels.push_back(productInstanceLabel);
     }
   if (className == "CaloTowerCollection")
     {
    CaloTowerCollectionLabels.clear();
    CaloTowerCollectionLabels.push_back(moduleLabel);
    CaloTowerCollectionLabels.push_back(productInstanceLabel);
     }
}


//-----------------------------------------------------------------------------
void HTrackAssociator::setPropagator( Propagator* ptr)
{
   ivProp_ = ptr; 
   caloDetIdAssociator_.setPropagator(ivProp_);
   ecalDetIdAssociator_.setPropagator(ivProp_);
   hcalDetIdAssociator_.setPropagator(ivProp_);
}

//-----------------------------------------------------------------------------
void HTrackAssociator::useDefaultPropagator()
{
   useDefaultPropagator_ = true;
}


//-----------------------------------------------------------------------------
void HTrackAssociator::init( const edm::EventSetup& iSetup )
{
   // access the calorimeter geometry
   iSetup.get<CaloGeometryRecord>().get(theCaloGeometry_);
   if (!theCaloGeometry_.isValid()) 
     throw cms::Exception("FatalError") << "Unable to find IdealGeometryRecord in event!\n";
   
   if (useDefaultPropagator_ && ! defProp_ ) {
      // setup propagator
      edm::ESHandle<MagneticField> bField;
      iSetup.get<IdealMagneticFieldRecord>().get(bField);
      
      SteppingHelixPropagator* prop  = new SteppingHelixPropagator(&*bField,anyDirection);
      prop->setMaterialMode(false);
      prop->applyRadX0Correction(true);
      // prop->setDebug(true); // tmp
      defProp_ = prop;
      setPropagator(defProp_);
   }
   
    
}

//-----------------------------------------------------------------------------
HTrackDetMatchInfo HTrackAssociator::associate( const edm::Event& iEvent,
                          const edm::EventSetup& iSetup,
                          const FreeTrajectoryState& trackOrigin,
                          const HAssociatorParameters& parameters )
{
   HTrackDetMatchInfo info;
   using namespace edm;
   
   init( iSetup );
   
   const FreeTrajectoryState& currentPosition(trackOrigin);

   if (parameters.useEcal) fillEcal( iEvent, iSetup, info, currentPosition,parameters.idREcal, parameters.dREcal);
   if (parameters.useHcal) fillHcal( iEvent, iSetup, info, currentPosition,parameters.idRHcal,parameters.dRHcal);
   if (parameters.useCalo) fillCaloTowers( iEvent, iSetup, info, currentPosition,parameters.idRCalo,parameters.dRCalo);

   return info;
}

//-----------------------------------------------------------------------------
std::vector<EcalRecHit> HTrackAssociator::associateEcal( const edm::Event& iEvent,
                            const edm::EventSetup& iSetup,
                            const FreeTrajectoryState& trackOrigin,
                            const double dR )
{
   HAssociatorParameters parameters;
   parameters.useHcal = false;
   parameters.dREcal = dR;
   HTrackDetMatchInfo info( associate(iEvent, iSetup, trackOrigin, parameters ));
   if (dR>0) 
     return info.coneEcalRecHits;
   else
     return info.crossedEcalRecHits;
}

//-----------------------------------------------------------------------------
double HTrackAssociator::getEcalEnergy( const edm::Event& iEvent,
                       const edm::EventSetup& iSetup,
                       const FreeTrajectoryState& trackOrigin,
                       const double dR )
{
   HAssociatorParameters parameters;
   parameters.useHcal = false;
   parameters.dREcal = dR;
   HTrackDetMatchInfo info = associate(iEvent, iSetup, trackOrigin, parameters );
   if(dR>0) 
     return info.ecalConeEnergyFromRecHits();
   else
     return info.ecalEnergyFromRecHits();
}

//-----------------------------------------------------------------------------
std::vector<CaloTower> HTrackAssociator::associateHcal( const edm::Event& iEvent,
                               const edm::EventSetup& iSetup,
                               const FreeTrajectoryState& trackOrigin,
                               const double dR )
{
   HAssociatorParameters parameters;
   parameters.useEcal = false;
   parameters.dRHcal = dR;
   HTrackDetMatchInfo info( associate(iEvent, iSetup, trackOrigin, parameters ));
   if (dR>0) 
     return info.coneTowers;
   else
     return info.crossedTowers;
   
}

//-----------------------------------------------------------------------------
double HTrackAssociator::getHcalEnergy( const edm::Event& iEvent,
                       const edm::EventSetup& iSetup,
                       const FreeTrajectoryState& trackOrigin,
                       const double dR )
{
   HAssociatorParameters parameters;
   parameters.useEcal = false;
   parameters.dRHcal = dR;
   HTrackDetMatchInfo info( associate(iEvent, iSetup, trackOrigin, parameters ));
   if (dR>0) 
     return info.hcalConeEnergyFromRecHits();
   else
     return info.hcalEnergyFromRecHits();
}

//-----------------------------------------------------------------------------
void HTrackAssociator::fillEcal( const edm::Event& iEvent,
                const edm::EventSetup& iSetup,
                HTrackDetMatchInfo& info,
                const FreeTrajectoryState& trajectoryPoint,
                const int idR,
                const double dR)
{
   ecalDetIdAssociator_.setGeometry(&*theCaloGeometry_);
   
   // ECAL points (EB+EE)
   std::vector<GlobalPoint> ecalPoints;
   ecalPoints.push_back(GlobalPoint(135.,0,310.));
   ecalPoints.push_back(GlobalPoint(150.,0,340.));
   ecalPoints.push_back(GlobalPoint(170.,0,370.));
   
   std::vector<GlobalPoint> ecalTrajectory = ecalDetIdAssociator_.getTrajectory(trajectoryPoint, ecalPoints);
//   if(ecalTrajectory.empty()) throw cms::Exception("FatalError") << "Failed to propagate a track to ECAL\n";

   if(ecalTrajectory.empty()) {
      LogTrace("HTrackAssociator::fillEcal") << "Failed to propagate a track to ECAL; moving on\n";
      info.isGoodEcal = false;
      return;
   }
   
   info.isGoodEcal = true;

   info.trkGlobPosAtEcal = getPoint(ecalTrajectory[0]);

   // Find ECAL crystals
   edm::Handle<EBRecHitCollection> EBRecHits;
   edm::Handle<EERecHitCollection> EERecHits;
//   if (EBRecHitCollectionLabels.empty())
//     throw cms::Exception("FatalError") << "Module lable is not set for EBRecHitCollection.\n";
//   else
     iEvent.getByLabel (EBRecHitCollectionLabels[0], EBRecHitCollectionLabels[1], EBRecHits);
//   if (!EBRecHits.isValid()) throw cms::Exception("FatalError") << "Unable to find EBRecHitCollection in event!\n";
     if (EERecHitCollectionLabels[1]!=EBRecHitCollectionLabels[1]) iEvent.getByLabel (EERecHitCollectionLabels[0], EERecHitCollectionLabels[1], EERecHits);
//   if (!EERecHits.isValid()) throw cms::Exception("FatalError") << "Unable to find EERecHitCollection in event!\n";

   std::set<DetId> ecalIdsInRegion = ecalDetIdAssociator_.getDetIdsCloseToAPoint(ecalTrajectory[0],idR);
   std::set<DetId> ecalIdsInACone =  ecalDetIdAssociator_.getDetIdsInACone(ecalIdsInRegion, ecalTrajectory, dR);
   std::set<DetId> crossedEcalIds =  ecalDetIdAssociator_.getCrossedDetIds(ecalIdsInRegion, ecalTrajectory);
   
   // add EcalRecHits
   for(std::set<DetId>::const_iterator itr=crossedEcalIds.begin(); itr!=crossedEcalIds.end();itr++) {
     std::vector<EcalRecHit>::const_iterator hit = (*EBRecHits).find(*itr);
     if(hit != (*EBRecHits).end()) 
       info.crossedEcalRecHits.push_back(*hit);
     else  
       LogTrace("HTrackAssociator::fillEcal") << "EcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
   }
   for(std::set<DetId>::const_iterator itr=ecalIdsInACone.begin(); itr!=ecalIdsInACone.end();itr++) {
     std::vector<EcalRecHit>::const_iterator hit = (*EBRecHits).find(*itr);
     if(hit != (*EBRecHits).end()) {
       info.coneEcalRecHits.push_back(*hit);
     }
     else 
       LogTrace("HTrackAssociator::fillEcal") << "EcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
   }
   if (EERecHitCollectionLabels[1]==EBRecHitCollectionLabels[1])return;
   for(std::set<DetId>::const_iterator itr=crossedEcalIds.begin(); itr!=crossedEcalIds.end();itr++) {
     std::vector<EcalRecHit>::const_iterator hit = (*EERecHits).find(*itr);
     if(hit != (*EERecHits).end()) 
       info.crossedEcalRecHits.push_back(*hit);
     else  
       LogTrace("HTrackAssociator::fillEcal") << "EcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
   }
   for(std::set<DetId>::const_iterator itr=ecalIdsInACone.begin(); itr!=ecalIdsInACone.end();itr++) {
     std::vector<EcalRecHit>::const_iterator hit = (*EERecHits).find(*itr);
     if(hit != (*EERecHits).end()) {
       info.coneEcalRecHits.push_back(*hit);
     }
     else 
       LogTrace("HTrackAssociator::fillEcal") << "EcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
   }
}

//-----------------------------------------------------------------------------
void HTrackAssociator::fillCaloTowers( const edm::Event& iEvent,
                      const edm::EventSetup& iSetup,
                      HTrackDetMatchInfo& info,
                      const FreeTrajectoryState& trajectoryPoint,
                      const int idR,
                      const double dR)
{
   // ECAL hits are not used for the CaloTower identification
   caloDetIdAssociator_.setGeometry(&*theCaloGeometry_);
   
   // HCAL points (HB+HE)
   std::vector<GlobalPoint> hcalPoints;   
   hcalPoints.push_back(GlobalPoint(135.,0,310.));
   hcalPoints.push_back(GlobalPoint(150.,0,340.));
   hcalPoints.push_back(GlobalPoint(170.,0,370.));
   hcalPoints.push_back(GlobalPoint(190.,0,400.));
   hcalPoints.push_back(GlobalPoint(240.,0,500.));
   hcalPoints.push_back(GlobalPoint(280.,0,550.));
   
   std::vector<GlobalPoint> hcalTrajectory = caloDetIdAssociator_.getTrajectory(trajectoryPoint, hcalPoints);
//   if(hcalTrajectory.empty()) throw cms::Exception("FatalError") << "Failed to propagate the track to HCAL\n";

   if(hcalTrajectory.empty()) {
      LogTrace("HTrackAssociator::fillEcal") << "Failed to propagate a track to ECAL; moving on\n";
      info.isGoodCalo = false;
      info.isGoodEcal = false;
      std::cout<<" HTrackAssociator::fillCaloTowers::Failed to propagate a track to ECAL "<<std::endl;
      return;
   }
   
   info.isGoodCalo = true;
   info.isGoodEcal = true;
   info.trkGlobPosAtEcal = getPoint(hcalTrajectory[0]);
   
   if(hcalTrajectory.size()<4) {
      LogTrace("HTrackAssociator::fillEcal") << "Failed to propagate a track to HCAL; moving on\n";
      info.isGoodHcal = false;
   }
   
   info.isGoodHcal = true;
   
   info.trkGlobPosAtHcal = getPoint(hcalTrajectory[4]);

   // find crossed CaloTowers
   edm::Handle<CaloTowerCollection> caloTowers;

   if (CaloTowerCollectionLabels.empty())
     throw cms::Exception("FatalError") << "Module lable is not set for CaloTowers.\n";
   else
     iEvent.getByLabel (CaloTowerCollectionLabels[0], CaloTowerCollectionLabels[1], caloTowers);
   if (!caloTowers.isValid())  throw cms::Exception("FatalError") << "Unable to find CaloTowers in event!\n";
   
// first get DetIds in a predefined NxN region
//   std::set<DetId> caloTowerIdsInBigRegion = caloDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR+1);
   std::set<DetId> caloTowerIdsInRegion = caloDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR);

   std::set<DetId> caloTowerIdsInACone;
   std::set<DetId> crossedCaloTowerIds;
   std::set<DetId> caloTowerIdsInBox;
   caloTowerIdsInACone = caloDetIdAssociator_.getDetIdsInACone(caloTowerIdsInRegion, hcalTrajectory, dR);
// get DetId of the most energetic tower in that region
   crossedCaloTowerIds = caloDetIdAssociator_.getMaxEDetId(caloTowerIdsInRegion, caloTowers);
// get DetIds of the towers surrounding the most energetic one
   caloTowerIdsInBox = caloDetIdAssociator_.getDetIdsInACone(crossedCaloTowerIds, hcalTrajectory, -1.);

//
//  Debug prints
//
//   std::cout <<" Debug printout in CaloTowers "<<std::endl;
//   std::cout <<" with position at outer layer:r,z,phi "<<trajectoryPoint.position().eta()<<
//               " "<<trajectoryPoint.position().phi()<<
//         " "<<trajectoryPoint.position().perp()<<
//               " "<<trajectoryPoint.position().z()<<
//         " "<<trajectoryPoint.charge()<<std::endl;
//   std::cout <<" Trajectory point at ECAL surface:eta:phi:radius:z "<<(hcalTrajectory[0]).eta()<<
//               " "<<(hcalTrajectory[0]).phi()<<
//               " "<<(hcalTrajectory[0]).perp()<<
//         " "<<(hcalTrajectory[0]).z()<<
//         " momentum "<<trajectoryPoint.momentum().perp()<<std::endl; 
//
//   std::cout<<" Number of towers in the region "<<caloTowerIdsInRegion.size()<<" idR= "<<idR<<std::endl;
   
   // add CaloTowers
   for(std::set<DetId>::const_iterator itr=crossedCaloTowerIds.begin(); itr!=crossedCaloTowerIds.end();itr++)
     {
    DetId id(*itr);
    CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
    if(tower != (*caloTowers).end()) 
      info.crossedTowers.push_back(*tower);
    else
      LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }

   for(std::set<DetId>::const_iterator itr=caloTowerIdsInACone.begin(); itr!=caloTowerIdsInACone.end();itr++)
     {
    DetId id(*itr);
    CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
    if(tower != (*caloTowers).end()) {
      info.coneTowers.push_back(*tower);
        }
    else 
      LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }

   for(std::set<DetId>::const_iterator itr=caloTowerIdsInBox.begin(); itr!=caloTowerIdsInBox.end();itr++)
     {
        DetId id(*itr);
        CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
        if(tower != (*caloTowers).end()) {
          info.boxTowers.push_back(*tower);
        }
        else
          LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }
   
   for(std::set<DetId>::const_iterator itr=caloTowerIdsInRegion.begin(); itr!=caloTowerIdsInRegion.end();itr++)
     {
    DetId id(*itr);
    CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
    if(tower != (*caloTowers).end()) {
      info.regionTowers.push_back(*tower);
        }
    else 
      LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }

}

//-----------------------------------------------------------------------------
void HTrackAssociator::fillHcal( const edm::Event& iEvent,
                                      const edm::EventSetup& iSetup,
                                      HTrackDetMatchInfo& info,
                                      const FreeTrajectoryState& trajectoryPoint,
                                      const int idR,
                                      const double dR) {
  hcalDetIdAssociator_.setGeometry(&*theCaloGeometry_);

// HCAL points (HB+HE)
  std::vector<GlobalPoint> hcalPoints;
  hcalPoints.push_back(GlobalPoint(190.,0,400.));
  hcalPoints.push_back(GlobalPoint(240.,0,500.));
  hcalPoints.push_back(GlobalPoint(280.,0,550.));

  std::vector<GlobalPoint> hcalTrajectory = hcalDetIdAssociator_.getTrajectory(trajectoryPoint, hcalPoints);
//   if(hcalTrajectory.empty()) throw cms::Exception("FatalError") << "Failed to propagate the track to HCAL\n";

  if(hcalTrajectory.empty()) {
    LogTrace("HTrackAssociator::fillHcal") << "Failed to propagate a track to HCAL; moving on\n";
    info.isGoodHcal = false;
//    std::cout<<" HTrackAssociator::fillHcal::Failed to propagate a track to HCAL "<<std::endl;
    return;
  }

  info.isGoodHcal = true;

  info.trkGlobPosAtHcal = getPoint(hcalTrajectory[0]);

  edm::Handle<HBHERecHitCollection> HBHERecHits;
//  if (HBHERecHitCollectionLabels.empty())
//    throw cms::Exception("FatalError") << "Module label is not set for HBHERecHitCollection.\n";
//  else
    iEvent.getByLabel (HBHERecHitCollectionLabels[0], HBHERecHitCollectionLabels[1], HBHERecHits);
  if (!HBHERecHits.isValid()) throw cms::Exception("FatalError") << "Unable to find HBHERecHitCollection in event!\n";

// first get DetIds in a predefined NxN region
//  std::set<DetId> hcalIdsInBigRegion = hcalDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR+1);
  std::set<DetId> hcalIdsInRegion = hcalDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR);

  std::set<DetId> hcalIdsInACone;
  std::set<DetId> crossedHcalIds;
  std::set<DetId> hcalIdsInBox;
  hcalIdsInACone = hcalDetIdAssociator_.getDetIdsInACone(hcalIdsInRegion, hcalTrajectory, dR);
// get DetId of the most energetic tower in that region
  crossedHcalIds = hcalDetIdAssociator_.getMaxEDetId(hcalIdsInRegion, HBHERecHits);
// get DetIds of the towers surrounding the most energetic one
  hcalIdsInBox = hcalDetIdAssociator_.getDetIdsInACone(crossedHcalIds, hcalTrajectory, -1.);

// add HcalRecHits
  for(std::set<DetId>::const_iterator itr=crossedHcalIds.begin(); itr!=crossedHcalIds.end();itr++) {
    std::vector<HBHERecHit>::const_iterator hit = (*HBHERecHits).find(*itr);
    if(hit != (*HBHERecHits).end())
      info.crossedHcalRecHits.push_back(*hit);
    else
      LogTrace("HTrackAssociator::fillHcal") << "HcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
  }
  for(std::set<DetId>::const_iterator itr=hcalIdsInACone.begin(); itr!=hcalIdsInACone.end();itr++) {
    std::vector<HBHERecHit>::const_iterator hit = (*HBHERecHits).find(*itr);
    if(hit != (*HBHERecHits).end())
      info.coneHcalRecHits.push_back(*hit);
    else
      LogTrace("HTrackAssociator::fillHcal") << "HcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
  }
  for(std::set<DetId>::const_iterator itr=hcalIdsInBox.begin(); itr!=hcalIdsInBox.end();itr++) {
    std::vector<HBHERecHit>::const_iterator hit = (*HBHERecHits).find(*itr);
    if(hit != (*HBHERecHits).end())
      info.boxHcalRecHits.push_back(*hit);
    else
      LogTrace("HTrackAssociator::fillHcal") << "HcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
  }
  for(std::set<DetId>::const_iterator itr=hcalIdsInRegion.begin(); itr!=hcalIdsInRegion.end();itr++) {
    std::vector<HBHERecHit>::const_iterator hit = (*HBHERecHits).find(*itr);
    if(hit != (*HBHERecHits).end())
      info.regionHcalRecHits.push_back(*hit);
    else
      LogTrace("HTrackAssociator::fillHcal") << "HcalRecHit is not found for DetId: " << itr->rawId() <<"\n";
  }
}

//-----------------------------------------------------------------------------
void HTrackAssociator::fillHcalTowers( const edm::Event& iEvent,
                      const edm::EventSetup& iSetup,
                      HTrackDetMatchInfo& info,
                      const FreeTrajectoryState& trajectoryPoint,
                      const int idR,
                      const double dR)
{
   // ECAL hits are not used for the CaloTower identification
   caloDetIdAssociator_.setGeometry(&*theCaloGeometry_);
   
   // HCAL points (HB+HE)
   std::vector<GlobalPoint> hcalPoints;
   hcalPoints.push_back(GlobalPoint(190.,0,400.));
   hcalPoints.push_back(GlobalPoint(240.,0,500.));
   hcalPoints.push_back(GlobalPoint(280.,0,550.));
   
   std::vector<GlobalPoint> hcalTrajectory = caloDetIdAssociator_.getTrajectory(trajectoryPoint, hcalPoints);
//   if(hcalTrajectory.empty()) throw cms::Exception("FatalError") << "Failed to propagate the track to HCAL\n";

   if(hcalTrajectory.empty()) {
      LogTrace("HTrackAssociator::fillEcal") << "Failed to propagate a track to HCAL; moving on\n";
      info.isGoodCalo = false;
      std::cout<<" HTrackAssociator::fillCaloTowers::Failed to propagate a track to HCAL "<<std::endl;
      return;
   }
   
   info.isGoodCalo = true;

   info.trkGlobPosAtHcal = getPoint(hcalTrajectory[0]);
   
   // find crossed CaloTowers
   edm::Handle<CaloTowerCollection> caloTowers;

   if (CaloTowerCollectionLabels.empty())
     throw cms::Exception("FatalError") << "Module lable is not set for CaloTowers.\n";
   else
     iEvent.getByLabel (CaloTowerCollectionLabels[0], CaloTowerCollectionLabels[1], caloTowers);
   if (!caloTowers.isValid())  throw cms::Exception("FatalError") << "Unable to find CaloTowers in event!\n";
   

// first get DetIds in a predefined NxN region
   std::set<DetId> caloTowerIdsInBigRegion = caloDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR+1);
   std::set<DetId> caloTowerIdsInRegion = caloDetIdAssociator_.getDetIdsCloseToAPoint(hcalTrajectory[0],idR);

   std::set<DetId> caloTowerIdsInACone;
   std::set<DetId> crossedCaloTowerIds;
   std::set<DetId> caloTowerIdsInBox;
   caloTowerIdsInACone = caloDetIdAssociator_.getDetIdsInACone(caloTowerIdsInBigRegion, hcalTrajectory, dR);
// get DetId of the most energetic tower in that region
   crossedCaloTowerIds = caloDetIdAssociator_.getMaxEDetId(caloTowerIdsInRegion, caloTowers);
// get DetIds of the towers surrounding the most energetic one
   caloTowerIdsInBox = caloDetIdAssociator_.getDetIdsInACone(crossedCaloTowerIds, hcalTrajectory, -1.);
   
   // add CaloTowers
   for(std::set<DetId>::const_iterator itr=crossedCaloTowerIds.begin(); itr!=crossedCaloTowerIds.end();itr++)
     {
    DetId id(*itr);
    CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
    if(tower != (*caloTowers).end()) 
      info.crossedTowers.push_back(*tower);
    else
      LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }

   for(std::set<DetId>::const_iterator itr=caloTowerIdsInACone.begin(); itr!=caloTowerIdsInACone.end();itr++)
     {
    DetId id(*itr);
    CaloTowerCollection::const_iterator tower = (*caloTowers).find(id);
    if(tower != (*caloTowers).end()) 
      info.coneTowers.push_back(*tower);
    else 
      LogTrace("HTrackAssociator::fillEcal") << "CaloTower is not found for DetId: " << id.rawId() << "\n";
     }
   
}

//-----------------------------------------------------------------------------
FreeTrajectoryState HTrackAssociator::getFreeTrajectoryState( const edm::EventSetup& iSetup, 
                                 const SimTrack& track, 
                                 const SimVertex& vertex )
{
   edm::ESHandle<MagneticField> bField;
   iSetup.get<IdealMagneticFieldRecord>().get(bField);
   
   GlobalVector vector( track.momentum().x(), track.momentum().y(), track.momentum().z() );
   // convert mm to cm
   GlobalPoint point( vertex.position().x()*.1, vertex.position().y()*.1, vertex.position().z()*.1 );
   int charge = track.type( )> 0 ? -1 : 1;
   GlobalTrajectoryParameters tPars(point, vector, charge, &*bField);
   
   AlgebraicSymMatrix66 covT=  AlgebraicMatrixID(); covT *= 1e-6; // initialize to sigma=1e-3
   CartesianTrajectoryError tCov(covT);
   
   return FreeTrajectoryState(tPars, tCov);
}

//-----------------------------------------------------------------------------
FreeTrajectoryState HTrackAssociator::getFreeTrajectoryState( const edm::EventSetup& iSetup,
                                 const reco::Track& track )
{
   edm::ESHandle<MagneticField> bField;
   iSetup.get<IdealMagneticFieldRecord>().get(bField);
   
   GlobalVector vector( track.momentum().x(), track.momentum().y(), track.momentum().z() );

   GlobalPoint point( track.vertex().x(), track.vertex().y(),  track.vertex().z() );

   GlobalTrajectoryParameters tPars(point, vector, track.charge(), &*bField);
   
   // FIX THIS !!!
   // need to convert from perigee to global or helix (curvilinear) frame
   // for now just an arbitrary matrix.
   AlgebraicSymMatrix66 covT=  AlgebraicMatrixID(); covT *= 1e-6; // initialize to sigma=1e-3
   CartesianTrajectoryError tCov(covT);
   
   return FreeTrajectoryState(tPars, tCov);
}