Atlfast::KIsolator Class Reference

Associates ReconstructedParticles to Clusters and evaluates isolation, for FastShower. More...

#include <KIsolator.h>

Collaboration diagram for Atlfast::KIsolator:

[legend]List of all members.

Public Member Functions
	KIsolator (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~KIsolator ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
Private Member Functions
double	gapResponse (double eta)
bool	isIsolated (MsgStream &, ReconstructedParticleCollection::const_iterator, std::vector< ITwoCptCell * > &, std::vector< ICluster * > &)
Private Attributes
double	m_rClusterMatch
double	m_rClusterIsolation
double	m_eClusterIsolation
double	m_rCellIsolation
double	m_eCellIsolation
std::string	m_inputLocation
std::string	m_isolatedOutputLocation
std::string	m_nonIsolatedOutputLocation
std::string	m_cellLocation
std::string	m_clusterLocation
TesIO *	m_tesIO
std::string	m_mcLocation
KinematicHelper	m_kinehelp
HepMC_helper::IMCselector *	m_visibleToCal

---

Detailed Description

Associates ReconstructedParticles to Clusters and evaluates isolation, for FastShower.

KIsolator is the FastShower version of Isolator. It has an additional gap response method.

The associations are established by searching in a user-defined cone around the RP position for unassociated Clusters.
The isolation is calculated by searching in user-defined cones around the RP position for Clusters and unused (unclustered) Cells. The corresponding energies are then compared to user-defined limits.

Sequence same as Isolator:

See also:

Atlfast::Isolator

Definition at line 84 of file KIsolator.h.

---

Constructor & Destructor Documentation

Atlfast::KIsolator::KIsolator	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard Athena-Algorithm Constructor

Definition at line 41 of file KIsolator.cxx.

    : Algorithm( name, pSvcLocator ),
      m_tesIO(0) {
    
    // Setting the parameter defaults.
    m_rClusterMatch      = 0.150;
    m_rClusterIsolation  = 0.400;
    m_eClusterIsolation  = 0.0*GeV;
    m_rCellIsolation     = 0.200;
    m_eCellIsolation     = 10.0*GeV;
    
    // Default paths for entities in the TES
    m_inputLocation                 = "/Event/AtlfastElectrons";
    m_cellLocation                  = "/Event/AtlfastCells";
    m_clusterLocation               = "/Event/AtlfastClusters";
    m_isolatedOutputLocation        = "/Event/AtlfastIsolatedElectrons";
    m_nonIsolatedOutputLocation     = "/Event/AtlfastNonIsolatedElectrons";
    
    // This is how you declare the paramemters to Gaudi so that
    // they can be over-written via the job options file
    
    declareProperty( "RClusterMatch",             m_rClusterMatch ) ;
    declareProperty( "RClusterIsolation",         m_rClusterIsolation ) ;
    declareProperty( "EClusterIsolation",         m_eClusterIsolation ) ;
    declareProperty( "RCellIsolation",            m_rCellIsolation ) ;
    declareProperty( "ECellIsolation",            m_eCellIsolation ) ;
    
    declareProperty( "InputLocation",             m_inputLocation ) ;
    declareProperty( "CellLocation",              m_cellLocation ) ;
    declareProperty( "ClusterLocation",           m_clusterLocation ) ;
    declareProperty( "IsolatedOutputLocation",    m_isolatedOutputLocation ) ;
    declareProperty( "NonIsolatedOutputLocation", m_nonIsolatedOutputLocation ) ;
    
  }

Atlfast::KIsolator::~KIsolator

(

)

[virtual]

Default Destructor

Definition at line 77 of file KIsolator.cxx.

                        {
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "destructor" << endreq;
    if (m_tesIO) delete m_tesIO;
  } 

---

Member Function Documentation

StatusCode Atlfast::KIsolator::initialize

(

)

Standard Athena-Algorithm method

Definition at line 88 of file KIsolator.cxx.

                                  {
    MsgStream log( messageService(), name() ) ;
    log << MSG::DEBUG << "Initialising" << endreq;
    
    
    //get the Global Event Data using singleton pattern
    GlobalEventData* ged = GlobalEventData::Instance();
    m_visibleToCal   = ged -> visibleToCal();
    m_mcLocation     = ged -> mcLocation();
    //    m_tesIO = new TesIO(eventDataService());
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter());


    HeaderPrinter hp("Atlfast KIsolator:", log);
    
    hp.add("TES Locations:             ");
    hp.add(" Particles from            ", m_inputLocation); 
    hp.add(" Cells from                ", m_cellLocation);    
    hp.add(" Clusters from             ", m_clusterLocation); 
    hp.add(" Isolated Particles to     ", m_isolatedOutputLocation);
    hp.add(" Non-Isolated Particles to ", m_nonIsolatedOutputLocation);
    hp.add("Cluster match DeltaR       ", m_rClusterMatch);
    hp.add("Cluster isolation DeltaR   ", m_rClusterIsolation);
    hp.add("Cluster isolation E thresh ", m_eClusterIsolation);
    hp.add("Cell isolation DeltaR      ", m_rCellIsolation);
    hp.add("Cell isolation E thresh    ", m_eCellIsolation);
    hp.print();
    
    
    return StatusCode::SUCCESS ;
  }

StatusCode Atlfast::KIsolator::execute

(

)

Standard Athena-Algorithm method

Definition at line 145 of file KIsolator.cxx.

                                {
    
    //................................
    // make a message logging stream
    
    MsgStream log( messageService(), name() ) ;
    std::string mess;
    //...............................
    // Extract the input particles which are to be tested for isolation.
    
    //std::vector<ReconstructedParticle*> particles;
    const ReconstructedParticleCollection* particles(0);
    if(!m_tesIO->getDH(particles, m_inputLocation)){
      log << MSG::DEBUG 
          << "No reconstructed particles in TES to treat" 
          << endreq ;
      return StatusCode::SUCCESS ;
    }
    
    log << MSG::DEBUG 
        << "Found " 
        << particles->size() 
        << " particles in TES "
        << endreq ;
    
    
    //.........................................................
    // Extract the (pointers to) cells and clusters from the TES into 
    // locally defined arrays.
    
    
    std::vector<ITwoCptCell*> cells;
    if(!m_tesIO->copy<ITwoCptCellCollection> (cells, m_cellLocation)){
      
      log << MSG::DEBUG 
          << "No Cells found in TES at " 
          << m_cellLocation 
          << endreq ;
    }
    
    
    std::vector<ICluster*> clusters;
    if(!m_tesIO->copy<IClusterCollection>(clusters, m_clusterLocation)){
      log << MSG::DEBUG 
          << "No Clusters found in TES at " 
          << m_clusterLocation 
          << endreq ;
    }
    
    
    // ......................
    // Make an empty container object which will store (pointers to) all 
    // sucessfully isolated and non isolated electrons.  
    
    ReconstructedParticleCollection* isolatedParticles = 
      new ReconstructedParticleCollection ;
    
    ReconstructedParticleCollection* nonIsolatedParticles = 
      new ReconstructedParticleCollection ;
    
    
    //.........................................................
    // For each particle in the input list test if it is isolated.
    // If so copy it into the output collection.
    
    ReconstructedParticleCollection::const_iterator particle ;
    
    for( particle = particles->begin(); 
         particle != particles->end(); 
         ++particle)
      {       
        if( this->isIsolated( log, particle, cells, clusters ) )     
          isolatedParticles->push_back
            ( new ReconstructedParticle( *particle ) ); 
        else
          nonIsolatedParticles->push_back
            ( new ReconstructedParticle( *particle ) );         
      }
    
    
    //......................................
    // Register particles in the transient event store. 
    
    TesIoStat tis;
    tis = m_tesIO->store(isolatedParticles, m_isolatedOutputLocation );  
    if( tis.isNotValid() ) {
      log << MSG::ERROR << "Failed to register output in TES at " 
          << m_isolatedOutputLocation <<  endreq ;
      return tis;
    } else{
      log << MSG::DEBUG << "Written " << isolatedParticles->size() 
          << " isolated particles to TES " << endreq;
    }
    
    tis = m_tesIO->store(nonIsolatedParticles, m_nonIsolatedOutputLocation );
    if( tis.isNotValid() ) {
      log << MSG::ERROR << "Failed to register output in TES at " 
          << m_nonIsolatedOutputLocation <<  endreq ;
    } else {
      log << MSG::DEBUG << "Written " << nonIsolatedParticles->size() 
          << " NON-isolated particles to TES " << endreq;
    }
    
    return tis;
    
  }

StatusCode Atlfast::KIsolator::finalize

(

)

Standard Athena-Algorithm method

Definition at line 124 of file KIsolator.cxx.

                                {
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "finalizing" << endreq;
    return StatusCode::SUCCESS ;
  }

double Atlfast::KIsolator::gapResponse

(

double

eta

)

[private]

Definition at line 256 of file KIsolator.cxx.

                                         {
    double aEta = std::abs(eta);
    double p1 = 1.1095;
    double p2 = -7.494*std::pow((aEta - p1),2);
    double p3 = -25.275*std::pow((aEta - p1),2);
    double p4 = 14.52;
    return ((aEta>1.3)&&(aEta<1.9))? 
      1.0 - std::exp(p2 - p4*std::exp(p3)) : 1.0;
  }

bool Atlfast::KIsolator::isIsolated	(	MsgStream &	,
		ReconstructedParticleCollection::const_iterator	,
		std::vector< ITwoCptCell * > &	,
		std::vector< ICluster * > &
	)			[private]

This is the heart of this algorithm: the bit that does the isolation

Definition at line 275 of file KIsolator.cxx.

     {
    
    log << MSG::DEBUG << "\n\t Treating particle: " << *particle ;
    
    // Things we need to remember until the end of the method
    // If, during processing of Clusters, we identify an "associated cluster"
    // we remember it for use if the particle is finally judged to be isolated
    bool associated = false ;
    ICluster* associatedCluster = NULL ;
    
    
    
    //....................................
    // Cluster isolation
    
      
    if( !storedClusters.empty() ) {
      
      // Make a local copy as we want to mutate the list of pointers
      std::vector<ICluster*>  clusters( 
                                      storedClusters.begin(), 
                                      storedClusters.end() 
                                      );
      
      // My own test: would be removed
      std::vector<ICluster*>::iterator it;
      for (it=clusters.begin(); it!=clusters.end(); ++it) {
        double dR = m_kinehelp.deltaR(*particle,*it);
        if (dR>m_rClusterMatch) continue;
        log << "\n\t -->  cluster: " << *it ;
        log << "\n\t -->   DeltaR: " << dR;
        log << "\n\t -->  EtC-EtP: " 
            << (*it)->eT() - 
          (*particle)->eT()*gapResponse((*particle)->eta());
        log << "\n\t ---------------------------------------- " <<endreq;
      }
      
      
      //Only use clusters not already claimed by ReconstructedParticles
      std::vector<ICluster*>::iterator firstNonAssociatedCluster ;
      firstNonAssociatedCluster = 
        std::partition(
                       clusters.begin(),
                       clusters.end(),
                       IsAssociated<ReconstructedParticle>
                       );
      if(firstNonAssociatedCluster != clusters.begin()){
        log<<MSG::DEBUG<<"First "
           <<firstNonAssociatedCluster-clusters.begin()
           <<" clusters are associated to ReconstructedParticles "
           <<clusters.end()-firstNonAssociatedCluster
           <<" cluster(s) remain"
           <<endreq;
      }else{
        log<<MSG::DEBUG
           <<"No clusters are associated to ReconstructedParticles"
           <<endreq;
      }
      if(clusters.end()!=firstNonAssociatedCluster){
        // .....................
        // Associate unclaimed clusters with current particle. 
        // This looks at the nearest cluster only, and decides whether
        // it is within an "association" cone
        
        partial_sort(
                     firstNonAssociatedCluster,
                     firstNonAssociatedCluster+1,
                     clusters.end(), 
                     SortAttribute::DeltaR( *particle )
                     );
        
        log<<MSG::DEBUG<<"Sorted clusters "<<endreq;
        
        associated =
          (m_kinehelp.deltaR(*particle, *firstNonAssociatedCluster) <  
           m_rClusterMatch);
        
        if( associated ) 
          {
            log << "\n\t -->Found associated cluster: "  
                << *clusters.begin() ;
            
            // Remember the relevant cluster until the end of this method
            associatedCluster = *firstNonAssociatedCluster ;
            
            // Set the first nonassociated cluster
            ++firstNonAssociatedCluster;
            
          }
        
        
        //............................................
        // Now we can check Cluster Isolation 
        // (if there is at least one more cluster to check)
        
        // Use kinematic helper to do all work
        double eClusterSum = m_kinehelp.sumETInCone( 
                                                    firstNonAssociatedCluster, 
                                                    clusters.end(), 
                                                    *particle,
                                                    m_rClusterIsolation
                                                    );
        
        // Apply the cut criteria
        
        if( eClusterSum  > m_eClusterIsolation ) 
          log  << "\n\t -->Excess Cluster energy in cone = " << eClusterSum 
               << "   => NOT-ISOLATED " << endreq;       
        else
          log  << "\n\t -->Excess Cluster energy in cone = " << eClusterSum 
               << "   => ISOLATED "  ;
        
        if( eClusterSum  > m_eClusterIsolation )  return false ;
        
      }
      
    }
    
    //............................................
    // Cell Isolation: 
    
    if( !storedCells.empty() ) {
      
      // Test on isolation in respect of the total transverese energy of all 
      // Cells within a given r-cone


      // dummy ReconstructedParticle to heve simple access to
      // unsmeared 4-vector to do isolation
      ReconstructedParticle* rp = 
        new ReconstructedParticle(
                                  (*particle)->pdg_id(),
                                  (*particle)->momentum(),
                                  (*particle)->truth()
                                  );


      // Use kinematic helper to do all work
      double eCoreSum = m_kinehelp.sumETInCone(
                                               storedCells.begin(), 
                                               storedCells.end(), 
                                               rp,
                                               m_rCellIsolation
                                               );
      

      // delete the dummy ReconstructedParticle
      delete rp;


      // Subtract the energy associated with particle under test
      // as the cells summed will have included its deposit
      //    CalSelect depositsInCal;
      //    if(depositsInCal( *particle) ) eCellSum -= (*particle)->eT() ;
      bool itDeposits = m_visibleToCal->operator()( (*particle)->truth() );


      // consider the effect of transition region (from FastShower)
      log << "\n\t -->Applying gap correction factor: "
          << gapResponse((*particle)->eta()) << endreq ; 

      double eCoreIsolation = eCoreSum;
      if(itDeposits) eCoreIsolation -=  
                       ((*particle)->eT())*gapResponse((*particle)->eta());
      
      
      // Apply isolation criteria
      
      if( eCoreIsolation  > m_eCellIsolation ) 
        log  
          << "\n\t -->Excess energy in core (R<0.2) = " << eCoreIsolation 
          << "   => NOT-ISOLATED " << endreq ;    
      else
        log   
          << "\n\t -->Excess energy in core (R<0.2) = " << eCoreIsolation
          << "   => ISOLATED " << endreq ;
                  
      if( eCoreIsolation  > m_eCellIsolation )return false;
      
    }
    
    //..........................................
    // If we get here then the candidate was judged to be isolated
    
    // It is only now that we wish to set associations between isolated
    // particles and clusters. I.e we dont want to flag associations for 
    // non-isolated particles
    
    if( associated ) {
      
      // Set the association from Particle -> Cluster
      IAOO* iamp = *particle;
      iamp->associate( associatedCluster ) ;

      log  << MSG::DEBUG 
           << "Particle of type "<< (*particle)->pdg_id()<<" associated to Cluster" 
           << endreq;
      //assert(IsAssociated<Cluster>( *particle ));

      // Set the association from Cluster -> Particle
      IAOO* iamc = associatedCluster;
      iamc->associate( *particle ) ;

      log  << MSG::DEBUG 
           << "Cluster associated to Particle of type "<< (*particle)->pdg_id() 
           << endreq;
      
      //assert(IsAssociated<ReconstructedParticle>( associatedCluster ));
    }
    
    log << endreq ;
    
    return true ;
  }

---

Member Data Documentation

double Atlfast::KIsolator::m_rClusterMatch [private]

R-cone for associating a Cluster to a particle

Definition at line 111 of file KIsolator.h.

double Atlfast::KIsolator::m_rClusterIsolation [private]

R-cone in which to sum unassociated Cluster eT

Definition at line 114 of file KIsolator.h.

double Atlfast::KIsolator::m_eClusterIsolation [private]

eT threshold to apply to summed Cluster eT

Definition at line 117 of file KIsolator.h.

double Atlfast::KIsolator::m_rCellIsolation [private]

R-cone in which to sum Cell eT

Definition at line 120 of file KIsolator.h.

double Atlfast::KIsolator::m_eCellIsolation [private]

eT threshold to apply to excess summed Cluster eT

Definition at line 123 of file KIsolator.h.

std::string Atlfast::KIsolator::m_inputLocation [private]

Location in TES to obtain input particles to be isolated

Definition at line 126 of file KIsolator.h.

std::string Atlfast::KIsolator::m_isolatedOutputLocation [private]

Location in TES to write out isolated list.

Definition at line 129 of file KIsolator.h.

std::string Atlfast::KIsolator::m_nonIsolatedOutputLocation [private]

Location in TES to write out isolated list.

Definition at line 131 of file KIsolator.h.

std::string Atlfast::KIsolator::m_cellLocation [private]

Location of Cells in TES

Definition at line 134 of file KIsolator.h.

std::string Atlfast::KIsolator::m_clusterLocation [private]

Location of Clusters in TES

Definition at line 136 of file KIsolator.h.

TesIO* Atlfast::KIsolator::m_tesIO [private]

For accessing StoreGate

Definition at line 140 of file KIsolator.h.

std::string Atlfast::KIsolator::m_mcLocation [private]

holds the Storegate MC location

Definition at line 143 of file KIsolator.h.

KinematicHelper Atlfast::KIsolator::m_kinehelp [private]

Definition at line 151 of file KIsolator.h.

HepMC_helper::IMCselector* Atlfast::KIsolator::m_visibleToCal [private]

Definition at line 152 of file KIsolator.h.

---

The documentation for this class was generated from the following files:

• /afs/cern.ch/user/s/sdean/project_builds/AtlasOffline-rel_1/Simulation/Atlfast/AtlfastAlgs/AtlfastAlgs/KIsolator.h
• /afs/cern.ch/user/s/sdean/project_builds/AtlasOffline-rel_1/Simulation/Atlfast/AtlfastAlgs/src/KIsolator.cxx

---