---

SharedConeStrategy.cxx

Go to the documentation of this file.

#include "AtlfastAlgs/SharedConeStrategy.h"
#include "AtlfastAlgs/ClusterConeStrategy.h"
#include "AtlfastEvent/Cell.h"
#include "AtlfastEvent/Cluster.h"

#include "AtlfastUtils/FunctionObjects.h"

// Gaudi includes
#include "GaudiKernel/DataSvc.h"
#include "StoreGate/DataHandle.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"

#include <assert.h>
#include <algorithm>
namespace Atlfast{

  SharedConeStrategy::SharedConeStrategy(double rConeBarrel,
                                         double rConeForward,
                                         double minInitiatorET, 
                                         double minClusterET,
                                         double barrelForwardEta) : m_rConeBarrel(rConeBarrel),
                                                                    m_rConeForward(rConeForward),
                                                                    m_minClusterET(minClusterET),
                                                                    m_barrelForwardEta(barrelForwardEta)
  {
     m_coneStrategy = new ClusterConeStrategy( rConeBarrel,   
                                               rConeForward,
                                               minInitiatorET,
                                               minInitiatorET,//crazy!!!!!
                                               true);
  }

  SharedConeStrategy::~SharedConeStrategy(){delete m_coneStrategy;}

  void SharedConeStrategy::makeClusters(MsgStream& log, 
                                        const localCellCollection& storedCells,
                                        localCellCollection& unusedCells,
                                        ClusterCollection* clusters) const
  {
    //Firstly Call the bog Standard ClusterConeStrategy
    m_coneStrategy->makeClusters(log,  storedCells, unusedCells, clusters);
    
    //Now recalibrate those clusters
    //============================================================
    //Partition away all clusters that are more than two R away 
    //from other clusters
    // JPC: NOT DONE YET!!!!!
    //Copy pointers to all associated cells to local vector
    
    localCellCollection usedCells;
    std::map<Cluster*,double> aMap;
    ClusterCollection::iterator cluIter = clusters->begin();
    for(; cluIter != clusters->end(); ++cluIter) {
      aMap[*cluIter] = 0.0;
      Cell cell;
      IAssociationManager* iam = *cluIter;
      localCellCollection smv = iam->ikinematics();
      std::copy(smv.begin(), smv.end(),std::back_inserter(usedCells));
    }
    //Iterate over used cells
    localCellCollectionIterator cellIter = usedCells.begin();
    for(; cellIter != usedCells.end(); ++cellIter) {
      this->CellAssociatedClusterEnergy(
                                        cellIter,
                                        clusters->begin(),
                                        clusters->end(),
                                        aMap
                                        );
    }
    
    //recalculate cluster energies
    cluIter = clusters->begin();
    for(; cluIter != clusters->end(); ++cluIter){
      if(aMap.find(*cluIter) != aMap.end() && aMap[*cluIter] != 0.0) {
        double eT = aMap[*cluIter]/cosh((*cluIter)->eta());
        double theta = atan( exp( - (*cluIter)->eta() ) ) * 2.0 ;
        double t = eT / sin( theta ) ;
        double x = eT * cos( (*cluIter)->phi() ) ;
        double y = eT * sin( (*cluIter)->phi() ) ;
        double z = t * cos( theta ) ;
        (*cluIter)->setMomentum(HepLorentzVector(x,y,z,t));
      }
    }
    //Partition away clusters below eT threshold
    ClusterCollection::iterator part = std::partition(clusters->begin(),
                                                 clusters->end(),
                                                 PartitionCondition::AboveThresholdET( m_minClusterET ));
    //retrieve cells from discarded clusters and delete clusters
    std::for_each(part,clusters->end(),GetBackCells(unusedCells));
    clusters->erase(part,clusters->end());
    //sort clusters by eT
    sort( clusters->begin(),clusters->end(),SortAttribute::DescendingET());
    return;
  }


  void SharedConeStrategy::CellAssociatedClusterEnergy
  (
   std::vector<const Cell*>::const_iterator cell,
   ClusterCollection::iterator cluStart,
   ClusterCollection::iterator cluEnd,
   std::map<Cluster*,double>& cluMap
   ) const{
    double tempEnergy = 0.0;
    
    ClusterCollection::iterator endAssClu = 
      partition(cluStart, cluEnd, 
                PartitionCondition::BelowThresholdDeltaR((*cell),m_rConeBarrel)
                );
    
    //    assert(endAssClu != cluStart);
    
    //calculate the energy of clusters associated to cells 
    
    for(ClusterCollection::iterator itr = cluStart;
        itr != endAssClu;
        ++itr) tempEnergy += ((*itr)->eT()*cosh((*itr)->eta()));
    
    //calculate the shared energy fractions
    for(ClusterCollection::iterator itr = cluStart;itr != endAssClu;++itr){
      cluMap[*itr] += 
        ((*cell)->eT()*cosh((*cell)->eta())*(*itr)->eT()*cosh((*itr)->eta()))/
        tempEnergy;
    }
    return;
  }

  IKinematic* CastAwayConst(const IKinematic* c){return const_cast<IKinematic*>(c);}

  void SharedConeStrategy::GetBackCells::operator()(IAssociationManager* a){
    localCellCollection assCells  = a->ikinematics();
    //    std::transform(assCells.begin(),
    //     assCells.end(),
    //     std::back_inserter(m_unusedCells),
    //     CastAwayConst
    //     );
    std::copy(assCells.begin(),
              assCells.end(),
              std::back_inserter(m_unusedCells),
              );
    //delete(a); JPC: SHOULD I DELETE THIS?????????
    return;
  }
  
}//end namespace

---