Atlfast::JetMaker Class Reference

Makes Atlfast::Jets from acceptable Atlfast::Clusters. More...

#include <JetMaker.h>

Collaboration diagram for Atlfast::JetMaker:

[legend]List of all members.

Public Member Functions
	JetMaker (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~JetMaker ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
Jet *	create (ICluster *)
bool	isAcceptable (Jet *)
void	addMuons (Jet *, MuonCollection &)
MsgStream &	dumpParameters (MsgStream &) const
Private Types
typedef std::vector< ICluster * >	localClusterCollection
typedef localClusterCollection::iterator	localClusterIterator
typedef std::vector< ReconstructedParticle * >	MuonCollection
typedef MuonCollection::iterator	MuonIterator
Private Member Functions
int	getJetLabel (MCparticleCollection &mcParticles, Jet *jet, double maxDeltaR, double &deltaR) const
int	getTauLabel (MCparticleCollection &mcParticles, Jet *jet, double maxDeltaR, double &deltaR) const
void	label (Jet *jet, MCparticleCollection &mcParticles_b, MCparticleCollection &mcParticles_c, MCparticleCollection &mcParticles_tau) const
HepLorentzVector	addCells (MsgStream &)
void	getUnusedCells (std::vector< const ITwoCptCell * > &, MsgStream &)
void	getIsolationCorrectionCells (std::vector< const ITwoCptCell * > &, std::vector< const ITwoCptCell * > &, std::string, MsgStream &)
Private Attributes
HepMC_helper::IMCselector *	m_bSelector
HepMC_helper::IMCselector *	m_cSelector
HepMC_helper::IMCselector *	m_tauSelector
double	m_minPT
double	m_maxEta
bool	m_doSmearing
double	m_barrelForwardEta
double	m_rconeb
double	m_rconef
double	m_bPtMin
double	m_bMaxDeltaR
double	m_cPtMin
double	m_cMaxDeltaR
double	m_tauPtMin
double	m_tauMaxDeltaR
double	m_etaTagMax
double	m_tauJetPtRatio
bool	m_adjustMissETForIsolation
double	m_sumET
ISmearer *	m_smearer
ISmearer *	m_cellSmearer
TesIO *	m_tesIO
std::string	m_mcLocation
std::string	m_inputLocation
std::string	m_outputLocation
std::string	m_muonLocation
std::string	m_unusedCellLocation
std::string	m_missingMomentumLocation
std::string	m_isolatedElectronLocation
std::string	m_isolatedPhotonLocation
KinematicHelper	m_kinehelp

---

Detailed Description

Makes Atlfast::Jets from acceptable Atlfast::Clusters.

Acceptability is based on ET and eta cuts. Once accepted as a jet, the energy is smeared. Initial labelling is performed by searching in the truth block for proximity to b, c and hadronic taus.

JetMaker sequence

Definition at line 102 of file JetMaker.h.

---

Member Typedef Documentation

typedef std::vector<ICluster*> Atlfast::JetMaker::localClusterCollection [private]

Definition at line 110 of file JetMaker.h.

typedef localClusterCollection::iterator Atlfast::JetMaker::localClusterIterator [private]

Definition at line 111 of file JetMaker.h.

typedef std::vector<ReconstructedParticle*> Atlfast::JetMaker::MuonCollection [private]

Definition at line 112 of file JetMaker.h.

typedef MuonCollection::iterator Atlfast::JetMaker::MuonIterator [private]

Definition at line 113 of file JetMaker.h.

---

Constructor & Destructor Documentation

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

Standard Athena-Algorithm Constructor

Definition at line 89 of file JetMaker.cxx.

    : Algorithm( name, pSvcLocator ),
      m_bSelector(0),
      m_cSelector(0),
      m_tauSelector(0),
      m_smearer(0),
      m_cellSmearer(0),
      m_tesIO(0)
  {
    
    // Setting the parameter defaults.
    m_minPT            = 10*GeV;     // Min jet trans momentum
    m_maxEta           = 5.0;          //Max jet eta 
    m_doSmearing       = true;       //smearing is done
    m_rconeb           = 0.400;
    m_rconef           = 0.400;
    
    m_bPtMin           = 5.0*GeV;    //min pt for bquark to label jet
    m_bMaxDeltaR       = 0.3;        //max dR for bquark to label jet
    
    m_cPtMin           = 5.0*GeV;    //min pt for cquark to label jet
    m_cMaxDeltaR       = 0.3;
    
    m_tauPtMin         = 10.0*GeV;
    m_tauMaxDeltaR     = 0.3;
    
    m_etaTagMax        = 2.5;

    m_tauJetPtRatio    = 0;
    
    m_adjustMissETForIsolation = true;

    // Default paths for entities in the TES
    m_inputLocation             = "/Event/AtlfastClusters";
    m_outputLocation            = "/Event/AtlfastJets";
    m_muonLocation              = "/Event/AtlfastNonIsolatedMuons";
    m_unusedCellLocation        = "/Event/AtlfastUnusedCells";
    m_missingMomentumLocation   = "/Event/AtlfastMissingMomentum";
    m_isolatedElectronLocation  = "/Event/AtlfastIsolatedElectrons";
    m_isolatedPhotonLocation    = "/Event/AtlfastIsolatedPhotons";
    
    // This is how you declare the paramemters to Gaudi so that
    // they can be over-written via the job options file
    declareProperty( "MinimumPT",                m_minPT ) ;
    declareProperty( "MaximumEta",               m_maxEta ) ;
    declareProperty( "DoSmearing",               m_doSmearing ); 
    declareProperty( "RconeB",                   m_rconeb );
    declareProperty( "RconeF",                   m_rconef );
    declareProperty( "bPtMin",                   m_bPtMin );
    declareProperty( "bMaxDeltaR",               m_bMaxDeltaR );
    declareProperty( "cPtMin",                   m_cPtMin );
    declareProperty( "cMaxDeltaR",               m_cMaxDeltaR );
    declareProperty( "tauPtMin",                 m_tauPtMin );
    declareProperty( "tauMaxDeltaR",             m_tauMaxDeltaR );
    declareProperty( "etaTagMax",                m_etaTagMax );
    declareProperty( "tauJetPtRatio",            m_tauJetPtRatio);
    declareProperty( "adjustMissETForIsolation", m_adjustMissETForIsolation);

    declareProperty( "InputLocation",            m_inputLocation ) ;
    declareProperty( "OutputLocation",           m_outputLocation ) ;
    declareProperty( "UnusedCellLocation",       m_unusedCellLocation ) ;
    declareProperty( "MuonLocation",             m_muonLocation );
    declareProperty( "MissingMomentumLocation",  m_missingMomentumLocation );
    declareProperty( "IsolatedElectronLocation", m_isolatedElectronLocation );
    declareProperty( "IsolatedPhotonLocation",   m_isolatedPhotonLocation );

  }

Atlfast::JetMaker::~JetMaker

(

)

[virtual]

Default Destructor

Definition at line 157 of file JetMaker.cxx.

                      {
    
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "Destructor Called" << endreq;
    
    if (m_smearer) {
      log << MSG::INFO << "Deleting jet Smearer" << endreq;
      delete m_smearer;
    }
    if (m_cellSmearer) {
      log << MSG::INFO << "Deleting Cell Smearer" << endreq;
      delete m_cellSmearer;
    }
    if (m_tesIO) {
      delete m_tesIO;
    }
  } 

---

Member Function Documentation

int Atlfast::JetMaker::getJetLabel	(	MCparticleCollection &	mcParticles,
		Jet *	jet,
		double	maxDeltaR,
		double &	deltaR
	)			const [private]

Definition at line 603 of file JetMaker.cxx.

                                                  {
    
    MsgStream log( messageService(), name() ) ;

    int pdgId    = 0;
    double drMin = 999.;
    
    //Construct an object to select IKinematics within DeltaR of the current jet
    PartitionCondition::BelowThresholdDeltaR labelSelector(jet, maxDeltaR); 
    MCparticleCollectionCIter src ;
    for( src = mcParticles.begin(); src != mcParticles.end(); ++src ){
      SimpleKinematic sk(*src);
      if(labelSelector(sk)){
        pdgId = (*src)->pdg_id();
      }      
      Phi dPhi( sk.phi() - jet->phi() );
      double dR = sqrt((dPhi*dPhi) + 
                       (sk.eta()-jet->eta())*(sk.eta()-jet->eta()));
      if (dR < drMin) drMin = dR;
    }
    deltaR = drMin;
    return pdgId;
  }

int Atlfast::JetMaker::getTauLabel	(	MCparticleCollection &	mcParticles,
		Jet *	jet,
		double	maxDeltaR,
		double &	deltaR
	)			const [private]

Definition at line 632 of file JetMaker.cxx.

                                                  {
    
    MsgStream log( messageService(), name() ) ;
    
    int pdgId    = 0;
    double drMin = 999.;

    //Construct an object to select IKinematics within DeltaR of the current jet
    PartitionCondition::BelowThresholdDeltaR labelSelector(jet, maxDeltaR);
    MCparticleCollectionCIter src ;
    for( src = mcParticles.begin() ; src != mcParticles.end() ; ++src )
      {
        HepLorentzVector tauHlv = (*src)->momentum();
        HepLorentzVector neuHlv;

        // Find Tau children
        HepMC::GenVertex*  endVertex = (*src)->end_vertex();
        if(!endVertex) continue;

        HepMC::GenVertex::particle_iterator firstChild = 
          endVertex->particles_begin(HepMC::children);
        
        HepMC::GenVertex::particle_iterator endChild = 
          endVertex->particles_end(HepMC::children);
        
        HepMC::GenVertex::particle_iterator thisChild = firstChild; 
        
        // Find Pt of Taus tau-neutrino
        for(; thisChild!=endChild; ++thisChild){
          if(  abs((*thisChild)->pdg_id()) == 16){
            neuHlv = (*thisChild)->momentum();
          }
        }
        double sigma;
        double sqrtene = sqrt(jet->momentum().e()/GeV);
        if ( fabs(jet->eta()) < m_barrelForwardEta )
          sigma = 0.5/sqrtene;
        else
          sigma = 1.0/sqrtene;

        double cutQuantity = (m_tauJetPtRatio) ? m_tauJetPtRatio : 1.0 - 2*sigma;

        log << MSG::DEBUG << "m_tauJetPtRatio = " << m_tauJetPtRatio
            << ", cutQuantity = " << cutQuantity << endreq;

        HepMC::GenParticle trueHadSystem;
        trueHadSystem.set_momentum(tauHlv-neuHlv); 
        SimpleKinematic sk(trueHadSystem);
        if (labelSelector(sk) &&
            (tauHlv-neuHlv).perp()/jet->pT() >= cutQuantity){
          Phi dPhi( sk.phi() - jet->phi() );
          deltaR = sqrt((dPhi*dPhi) +
                        (sk.eta()-jet->eta())*(sk.eta()-jet->eta()));
          pdgId = (*src)->pdg_id();
        }
        Phi dPhi( sk.phi() - jet->phi() );
        double dR = sqrt((dPhi*dPhi) + 
                         (sk.eta()-jet->eta())*(sk.eta()-jet->eta()));
        if (dR < drMin) drMin = dR;
      }
    
    deltaR = drMin;
    return pdgId;
  }   

void Atlfast::JetMaker::label	(	Jet *	jet,
		MCparticleCollection &	mcParticles_b,
		MCparticleCollection &	mcParticles_c,
		MCparticleCollection &	mcParticles_tau
	)			const [private]

Definition at line 562 of file JetMaker.cxx.

                                                                   {
    
    MsgStream log( messageService(), name() ) ;
    
    double dR = 0.;

    // The getJetLabel and getTauLabel functions loop over the input particle collections
    // and return the PDGID of a particle if within maxdeltaR of the jet (0 otherwise). 
    // dR is also set to the lowest found particle-jet delta R value

    int bLabel = getJetLabel(mcParticles_b, jet, m_bMaxDeltaR, dR);
    jet->setdRbquark(dR);
    int cLabel = getJetLabel(mcParticles_c, jet, m_cMaxDeltaR, dR);
    jet->setdRcquark(dR);
    int tauLabel = getTauLabel( mcParticles_tau, jet, m_tauMaxDeltaR, dR);
    jet->setdRhadtau(dR);

    // Set jet label (order dependent)
    if(bLabel){
      jet->setPdg_id(bLabel);
      return;
    }
    if(cLabel){
      jet->setPdg_id(cLabel);
      return;
    }
    if(tauLabel){
      jet->setPdg_id(tauLabel);
      return;
    }

    jet->setPdg_id(0);
    return; 

  }

HepLorentzVector Atlfast::JetMaker::addCells

(

MsgStream &

)

[private]

Definition at line 700 of file JetMaker.cxx.

                                                   {
    
    std::vector<const ITwoCptCell*> cellsToSmear(0);
    std::vector<const ITwoCptCell*> newCellsVector(0);
    
    getUnusedCells(cellsToSmear,log);
    
    if (m_adjustMissETForIsolation){
      getIsolationCorrectionCells(cellsToSmear,newCellsVector,m_isolatedElectronLocation,log);
      getIsolationCorrectionCells(cellsToSmear,newCellsVector,m_isolatedPhotonLocation,log);
    }
    
    log << MSG::DEBUG << "Smearing a total of " << cellsToSmear.size() << " cells" << endreq;
    log << MSG::DEBUG << "sumET before adding cells: " << m_sumET << endreq;
    
    // accumulate used to compute vectorial sum of Cell HepLorentzVectors
    // m_sumET also passed into SmearCell to compute sum of smeared cell ETs
    HepLorentzVector temp(0., 0., 0., 0.);
    HepLorentzVector sum = std::accumulate(cellsToSmear.begin(),
                                           cellsToSmear.end(),
                                           temp,
                                           SmearCell(m_cellSmearer,&m_sumET));
    //if (eHitCellPtr) delete eHitCellPtr;

    std::vector<const ITwoCptCell*>::iterator itccItr   = newCellsVector.begin();
    std::vector<const ITwoCptCell*>::iterator itccItrE  = newCellsVector.end();

    for (;itccItr!=itccItrE;++itccItr) delete *itccItr;
    newCellsVector.clear();

    return sum;
  }

void Atlfast::JetMaker::getUnusedCells	(	std::vector< const ITwoCptCell * > &	,
		MsgStream &
	)			[private]

Definition at line 733 of file JetMaker.cxx.

                                                                                          {
    
    std::vector<const TwoCptCell*> unusedCells(0);
    if( !m_tesIO->copy<std::vector<const TwoCptCell*> >(unusedCells,
                                                        m_unusedCellLocation)){
      log << MSG::INFO << "No unused cells  in TES " << endreq;
      return;
    }
    
    log << MSG::DEBUG << unusedCells.size() << " unused cells in TES" << endreq;
    
    std::copy(unusedCells.begin(),unusedCells.end(),std::back_inserter(cellsToSmear));
    
    log << MSG::DEBUG  << "Added " << unusedCells.size() << " unused cells to cellToSmear" << endreq;
    
    return;
    
  }

void Atlfast::JetMaker::getIsolationCorrectionCells	(	std::vector< const ITwoCptCell * > &	,
		std::vector< const ITwoCptCell * > &	,
		std::string	,
		MsgStream &
	)			[private]

Definition at line 752 of file JetMaker.cxx.

                                                            {
    
    
    std::vector<const ITwoCptCell*> isolationCorrectionCells(0);
    
    const ReconstructedParticleCollection* dh(0);
    if( !m_tesIO->getDH(dh, tesAddress) ) throw "Error in numberInList";
    
    ReconstructedParticleCollection::const_iterator iter = dh->begin();
    
    for (; iter != dh->end(); ++iter){
      
      const HepMC::GenParticle* gp = (*iter)->truth();

      // Get associations of ReconstructedParticle associations 
      const IAOO* iaooRP = (*iter);
      TypeVisitor tv =
        ContainerAssocsDispatcher( iaooRP->begin(), iaooRP->end(), TypeVisitor() );
      
      // Select the TwoCptCells
      std::vector<const TwoCptCell*> tccv = tv.typeVector(TwoCptCell());
      log << MSG::DEBUG << "TypeVisitor found " << tccv.size() 
          << " TwoCptCells in this cluster" << endreq;
      
      std::vector<const TwoCptCell*>::iterator tccvi;

      for ( tccvi = tccv.begin(); tccvi != tccv.end();){
        const ICell* ic = (*tccvi);

        // See if this TwoCptCell contains the GenParticle that made the
        // original ReconstructedParticle
        std::vector<const GenParticle*> gpv = ic->particles();
        std::vector<const GenParticle*>::iterator gpi;
        gpi = std::find(gpv.begin(),gpv.end(),gp);

        if ( gpi == gpv.end() ) ++tccvi;     // If not, go onto next TwoCptCell
        else{                                // It's in this one
          log << MSG::DEBUG << "GenParticle found in this cell, one of " 
              << gpv.size() << " GenParticles" << endreq;
          log << MSG::DEBUG << "GenParticle momentum = " << (*gpi)->momentum() << endreq;
          log << MSG::DEBUG << "Cell momentum = " << ic->momentum() << endreq;

          if ( gpv.size() > 1){
            // Make a new cell with pT reduced by that of the originating GenParticle
            ITwoCptCell* newcell_itcc = (*tccvi)->cloneITCC();
            newcell_itcc->resetCell();
            ICell* newcell = newcell_itcc;
            double newpT = ic->momentum().perp() - (*gpi)->momentum().perp();
            newpT = ( fabs(newpT) < 1e-10 ) ? 0 : newpT; // problem with precision
            newcell->newHit( newpT );
            
            // Add the new, adjusted hit cell
            isolationCorrectionCells.push_back(newcell_itcc);
            newcellsVector.push_back(newcell_itcc);
          }
          
          // Remove the pointer to the hit cell
          tccvi = tccv.erase(tccvi);
          
        }
      }
      // After adjustment, copy all cells into isolationCorrectionCells
      std::copy(tccv.begin(),tccv.end(),std::back_inserter(isolationCorrectionCells));
    }
    
    log << MSG::DEBUG << "Added " << isolationCorrectionCells.size() 
        << " isolation correction cells to cellsToSmear" << endreq;
   
    // Add isolationCorrectionCells cells to vector of cells for smearing
    std::copy(isolationCorrectionCells.begin(),
              isolationCorrectionCells.end(),
              std::back_inserter(cellsToSmear));
    
    return;
    
  }

StatusCode Atlfast::JetMaker::initialize

(

)

Standard Athena-Algorithm method

Definition at line 179 of file JetMaker.cxx.

                                 {
    MsgStream log( messageService(), name() ) ;
    
    log << MSG::DEBUG << "instantiating a JetSmearer" << endreq;
    
    
    //get the Global Event Data using singleton pattern
    GlobalEventData* ged = GlobalEventData::Instance();
    int lumi                  = ged->lumi();
    int randSeed              = ged->randSeed() ;
    m_barrelForwardEta        = ged->barrelForwardEta();
    m_mcLocation              = ged->mcLocation();

    // Pass this into GlobalEventData for EventHeaderMaker to read later
    ged->set_adjustMissEtForIsolation(m_adjustMissETForIsolation);

    //    m_tesIO = new TesIO(eventDataService());
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter());
    
    if(m_doSmearing){
      m_smearer                 = new JetSmearer(randSeed, 
                                                 lumi,
                                                 m_rconeb, 
                                                 m_rconef, 
                                                 m_barrelForwardEta);    
      m_cellSmearer             = new JetSmearer(randSeed, 
                                                 lumi,
                                                 0., 
                                                 0., 
                                                 m_barrelForwardEta);    
    } else {
      m_smearer = NULL;
      m_cellSmearer = NULL;
    }

    const int BQUARK(ParticleCodes::BQUARK);
    const int CQUARK(ParticleCodes::CQUARK);

    //.........................................................
    // Construct objects to select b, c and tau quarks with kine conditions
    
    HepMC_helper::IMCselector* selector;
    
    std::vector<HepMC_helper::IMCselector*> bSelectors;
    selector = new HepMC_helper::IsFromHardScatter();
    bSelectors.push_back( selector );
    selector = new HepMC_helper::SelectJetTag(BQUARK, m_bPtMin, m_etaTagMax);
    bSelectors.push_back( selector );
    m_bSelector = new HepMC_helper::NCutter(bSelectors);

    std::vector<HepMC_helper::IMCselector*> cSelectors;
    selector = new HepMC_helper::IsFromHardScatter();
    cSelectors.push_back( selector );
    selector = new HepMC_helper::SelectJetTag(CQUARK, m_cPtMin, m_etaTagMax);
    cSelectors.push_back( selector );
    m_cSelector = new HepMC_helper::NCutter(cSelectors);

    std::vector<HepMC_helper::IMCselector*> tauSelectors;
    selector = new HepMC_helper::IsFromHardScatter();
    tauSelectors.push_back( selector );
    selector = new HepMC_helper::SelectTauTag(m_tauPtMin, m_etaTagMax);
    tauSelectors.push_back( selector );
    m_tauSelector = new HepMC_helper::NCutter(tauSelectors);

    //.........................................................
    // Tidy up selectors
    std::vector<HepMC_helper::IMCselector*>::iterator iter;
    for(iter=bSelectors.begin();   iter!=bSelectors.end();   delete *iter, ++iter);
    for(iter=cSelectors.begin();   iter!=cSelectors.end();   delete *iter, ++iter);
    for(iter=tauSelectors.begin(); iter!=tauSelectors.end(); delete *iter, ++iter);
    
    

    HeaderPrinter hp("Atlfast JetMaker:", log);
    
    hp.add("TES Locations:              ");
    hp.add(" Muons from                 ", m_muonLocation); 
    hp.add(" Clusters from              ", m_inputLocation); 
    hp.add(" MC Input Location          ", m_mcLocation);
    hp.add(" Jets to                    ", m_outputLocation);
    hp.add(" unused cell,cluster sum to ", m_missingMomentumLocation);
    hp.add("Smearing on                 ", m_doSmearing);
    hp.add("Cluster min Pt              ", m_minPT);
    hp.add("Cluster max Eta             ", m_maxEta);           
    hp.add("Luminosity                  ", lumi);
    hp.add("Initial random seed         ", randSeed);      
    hp.add("End cap Cone size           ", m_rconef);
    hp.add("Barrel  Cone size           ", m_rconeb);
    hp.add("Eta of start of end cap     ", m_barrelForwardEta);
    hp.add("Parameters for labels       ", "       ");
    hp.add(" Max eta                    ", m_etaTagMax);
    hp.add(" b-quark min pt             ", m_bPtMin);
    hp.add(" b-quark max DeltaR         ", m_bMaxDeltaR);
    hp.add(" c-quark min pt             ", m_cPtMin);
    hp.add(" c-quark max DeltaR         ", m_cMaxDeltaR);
    hp.add(" tau lep min pt             ", m_tauPtMin);
    hp.add(" tau lep max DeltaR         ", m_tauMaxDeltaR);
    hp.add(" tau/Jet Pt Ratio           ", m_tauJetPtRatio);
    hp.print();
    


    return StatusCode::SUCCESS ;
  }

StatusCode Atlfast::JetMaker::execute

(

)

Standard Athena-Algorithm method

Definition at line 317 of file JetMaker.cxx.

                               {
    
    MsgStream log( messageService(), name() ) ;    

    std::string mess;
    // make a message logging stream
    
    //.............................
    // Make some locals stores which be used to keep pointers to
    // all of the entities from the event store which are needed by
    // this algorithm. These are all local and are typedefed in this class
    
    localClusterCollection      my_Clusters ;
    MuonCollection              my_Muons ;
    //................................
    
    //    if( ! m_tesIO->copy( my_Clusters, m_inputLocation ) ) {
    if( ! m_tesIO->copy<IClusterCollection> ( my_Clusters, m_inputLocation ) ) {
      log << MSG::INFO << "No Clusters in TES " << endreq;
    } else {
      log << MSG::DEBUG << my_Clusters.size()<<" Clusters from TES " << endreq;
    }
    // get non-isolated muons for jet construction
    
    if( ! m_tesIO->copy<ReconstructedParticleCollection>
        ( my_Muons, m_muonLocation ) ) {
      log << MSG::DEBUG << "No muons in TES " << endreq;
    }  

    // ......................
    // Make a container object which will store pointers to all isolated 
    // Jetss which are successfully created.  Since it is going to go 
    // into the event store, it has to be a special Gaudi type of container. 
    // This is typedefined in the entity include file
    // As it is going into the TES it needs to be created on the heap with new.
    
    JetCollection* myJets = new JetCollection ;
    
    //.........................................................
    // From each Cluster create a reconstructed Jet. 
    // If all requirements are satisfied add to the collection
    
    Jet* candidate ;
    localClusterIterator src ;
    m_sumET = 0.;
    HepLorentzVector missingMomentum(0.,0.,0.,0.);
    
    MCparticleCollection  mcParticles_b ;
    MCparticleCollection  mcParticles_c ;
    MCparticleCollection  mcParticles_tau ;

    //.........................................................
    // Get quarks used in tagging from TES using tesio

    TesIoStat stat = m_tesIO->getMC( mcParticles_b, m_bSelector ) ;
    if(!stat){
      log << MSG::ERROR <<"Problem getting b-quarks" << endreq; 
      return stat;
    }
    stat = m_tesIO->getMC( mcParticles_c, m_cSelector ) ;
    if(!stat){
      log << MSG::ERROR <<"Problem getting c-quarks" << endreq; 
      return stat;
    }
    stat = m_tesIO->getMC( mcParticles_tau, m_tauSelector ) ;
    if(!stat){
      log << MSG::ERROR <<"Problem getting taus" << endreq; 
      return stat;
    }
 
    for( src = my_Clusters.begin() ; src != my_Clusters.end() ; ++src ) { 
      //
      //      ReconstructedParticle rp;
      //      std::vector<IAOO*> v;
      //      v.push_back(*src);
      //      AssocTypeRecoverer atr(v.begin(), v.end());
      //      if ((atr.typeVector(rp))->size() == 0){
      if ( !IsAssociated<ReconstructedParticle>( *src ) ){
        // Make a new jet
        candidate = this->create( *src );
        
        //Make a temp HepLorentzVector from candidates 4-mom
        //before muon is added in
        HepLorentzVector temp4Vec = candidate->momentum();
        
        // add isolated muons
        this->addMuons(candidate, my_Muons);
        
        
        // add to missing momentum vector if not used in a jet.
        // remember, these are smeared momenta if smearing is enabled
        if( this->isAcceptable( candidate ) ) {    
          
          // if the jet is acceptable label the jet
          this->label(candidate,mcParticles_b,mcParticles_c,mcParticles_tau);
          
          log << MSG::DEBUG << "Pushing back a Jet" << endreq;
          myJets->push_back( candidate ) ; 
          log<<MSG::DEBUG<<"jet "<<*candidate<<endreq;
        }else {
          log << MSG::DEBUG << "Jet fails cuts" << endreq;
          //add in temp4Vec to avoid muon double counting
          missingMomentum += temp4Vec;
          m_sumET += temp4Vec.perp();
          delete candidate;
        }
      }else{
        log << MSG::DEBUG << "Cluster is associated, so ignored" << endreq;
      }
    }
    
    log<<MSG::DEBUG<<"Missing momentum: clusters "<<missingMomentum<<endreq;
    missingMomentum += addCells(log);
    log << MSG::DEBUG << "sumET after adding cells: " << m_sumET << endreq;
    log<<MSG::DEBUG<<"Missing momentum: cells+clstrs "
       <<missingMomentum<<endreq;

    //......................................
    // Register any Jets which have been successfilly created in the 
    // transient event store. Allow modification further along the line
    // for tagging routines.
    log<<MSG::DEBUG<<"Storing "<< myJets->size() <<" Jets"<<endreq;
    stat = m_tesIO->store( myJets, m_outputLocation, true) ;
    if(!stat){
      log<<MSG::ERROR<<"Could not store jets"<<endreq;
      return stat;
    }


    MissingMomentum* mm = new MissingMomentum(missingMomentum,m_sumET);
    stat = m_tesIO->store(mm,m_missingMomentumLocation ) ;
    std::string message = stat? "Stored missing mom":"Failed to store missing mom";
    log<<MSG::DEBUG<<message<<endreq;
  

    return StatusCode::SUCCESS;
  }

StatusCode Atlfast::JetMaker::finalize

(

)

Standard Athena-Algorithm method

Definition at line 288 of file JetMaker.cxx.

                               {

    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "finalizing" << endreq;    

    if (m_bSelector)    delete m_bSelector;
    if (m_cSelector)    delete m_cSelector;
    if (m_tauSelector)  delete m_tauSelector;

    return StatusCode::SUCCESS ;
  }

Jet * Atlfast::JetMaker::create

(

ICluster *

)

Takes a single Cluster and smears it to create a Jet

Definition at line 468 of file JetMaker.cxx.

  {
    Jet* jet;
    MsgStream log( messageService(), name() ) ;
    HepLorentzVector vec = src->momentum();
    
    if (m_doSmearing) 
      {
        // Ask our Smearer make a smeared 4-vector
        vec = m_smearer->smear(vec);      
      }
    
    jet = new Jet(vec, *src);
    log << MSG::DEBUG << "Unsmeared Cluster: " << *src << endreq;
    log << MSG::DEBUG << "Smeared Jet      : " << jet << endreq ;
    
    //IAOO* js = jet;
    //assert(!js->unAssociated());
    // return Jet
    return jet;
    
    
  }

bool Atlfast::JetMaker::isAcceptable

(

Jet *

)

Decides whether a candidate jet passes ET and eta cuts

Definition at line 534 of file JetMaker.cxx.

  {
    
    MsgStream log( messageService(), name() ) ;
    
    // Apply kinematic criteria to the candidate jet
    
    if( candidate->pT() < m_minPT ) {        
      log << MSG::DEBUG << "Candidate failed pt cut: pt " << candidate->pT() 
          << " min was " << m_minPT << endreq;
      return false ;
    }
    
    if( abs(candidate->eta()) > m_maxEta ) {
      log << MSG::DEBUG << "Candidate failed max eta cut: eta " 
          << candidate->eta() 
          << " max was " << m_maxEta << endreq;
      return false ;
    }
    
    return true ;
  }

void Atlfast::JetMaker::addMuons	(	Jet *	,
		MuonCollection &
	)

Adds non-isolated muons to the jets

Definition at line 497 of file JetMaker.cxx.

  {
    
    MsgStream log( messageService(), name() ) ;
    
    if (muons.size() == 0) return;
    
    MuonIterator first = muons.begin() ;
    MuonIterator last  = muons.end() ;
    
    // Partition muons to get those that satisfy the dR condition in either eta region
    MuonIterator partitionLast = 
      partition(first,last,PartitionCondition::BelowThresholdDeltaR(jet,m_rconeb,m_rconef,m_barrelForwardEta));
    
    if (partitionLast == first){
      log << MSG::DEBUG << "No muons in R cone" << endreq;
      return;
    }

    log << MSG::DEBUG << "Adding " << partitionLast-first << " muons to Jet" << endreq;

    // Add muon momenta to jet
    for (MuonIterator muItr = first; muItr != partitionLast;++muItr) jet->addMuon(*muItr);
    
    // Remove muons from list
    muons.erase(first,partitionLast);
    
  }

MsgStream& Atlfast::JetMaker::dumpParameters

(

MsgStream &

)

const

Dump jet parameters (not implemented)

---

Member Data Documentation

HepMC_helper::IMCselector* Atlfast::JetMaker::m_bSelector [private]

Definition at line 119 of file JetMaker.h.

HepMC_helper::IMCselector* Atlfast::JetMaker::m_cSelector [private]

Definition at line 120 of file JetMaker.h.

HepMC_helper::IMCselector* Atlfast::JetMaker::m_tauSelector [private]

Definition at line 121 of file JetMaker.h.

double Atlfast::JetMaker::m_minPT [private]

Definition at line 129 of file JetMaker.h.

double Atlfast::JetMaker::m_maxEta [private]

Definition at line 130 of file JetMaker.h.

bool Atlfast::JetMaker::m_doSmearing [private]

Definition at line 131 of file JetMaker.h.

double Atlfast::JetMaker::m_barrelForwardEta [private]

Definition at line 133 of file JetMaker.h.

double Atlfast::JetMaker::m_rconeb [private]

Definition at line 134 of file JetMaker.h.

double Atlfast::JetMaker::m_rconef [private]

Definition at line 135 of file JetMaker.h.

double Atlfast::JetMaker::m_bPtMin [private]

Definition at line 137 of file JetMaker.h.

double Atlfast::JetMaker::m_bMaxDeltaR [private]

Definition at line 138 of file JetMaker.h.

double Atlfast::JetMaker::m_cPtMin [private]

Definition at line 139 of file JetMaker.h.

double Atlfast::JetMaker::m_cMaxDeltaR [private]

Definition at line 140 of file JetMaker.h.

double Atlfast::JetMaker::m_tauPtMin [private]

Definition at line 141 of file JetMaker.h.

double Atlfast::JetMaker::m_tauMaxDeltaR [private]

Definition at line 142 of file JetMaker.h.

double Atlfast::JetMaker::m_etaTagMax [private]

Definition at line 143 of file JetMaker.h.

double Atlfast::JetMaker::m_tauJetPtRatio [private]

Definition at line 144 of file JetMaker.h.

bool Atlfast::JetMaker::m_adjustMissETForIsolation [private]

Definition at line 146 of file JetMaker.h.

double Atlfast::JetMaker::m_sumET [private]

Definition at line 149 of file JetMaker.h.

ISmearer* Atlfast::JetMaker::m_smearer [private]

Definition at line 157 of file JetMaker.h.

ISmearer* Atlfast::JetMaker::m_cellSmearer [private]

Definition at line 158 of file JetMaker.h.

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

Definition at line 161 of file JetMaker.h.

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

Definition at line 163 of file JetMaker.h.

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

Definition at line 171 of file JetMaker.h.

std::string Atlfast::JetMaker::m_outputLocation [private]

Definition at line 172 of file JetMaker.h.

std::string Atlfast::JetMaker::m_muonLocation [private]

Definition at line 173 of file JetMaker.h.

std::string Atlfast::JetMaker::m_unusedCellLocation [private]

Definition at line 174 of file JetMaker.h.

std::string Atlfast::JetMaker::m_missingMomentumLocation [private]

Definition at line 175 of file JetMaker.h.

std::string Atlfast::JetMaker::m_isolatedElectronLocation [private]

Definition at line 176 of file JetMaker.h.

std::string Atlfast::JetMaker::m_isolatedPhotonLocation [private]

Definition at line 177 of file JetMaker.h.

KinematicHelper Atlfast::JetMaker::m_kinehelp [private]

Definition at line 183 of file JetMaker.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/JetMaker.h
• /afs/cern.ch/user/s/sdean/project_builds/AtlasOffline-rel_1/Simulation/Atlfast/AtlfastAlgs/src/JetMaker.cxx

---