HiggsAnalysis/HiggsAnalysis-00-01-00/src/VertexCollector.cxx

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 18.08.2007, AUTHOR: OLIVER KORTNER
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//::::::::::::::::::::::::::::::::::::::::::::::::::
//:: METHODS DEFINED IN THE CLASS VertexCollector ::
//::::::::::::::::::::::::::::::::::::::::::::::::::

//::::::::::::::::::
//:: HEADER FILES ::
//::::::::::::::::::

// standard C++ //
#include <iostream>
#include <fstream>

// track particles //
#include "Particle/TrackParticleContainer.h"

// HiggsAnalysis //
#include "HiggsAnalysis/VertexCollector.h"

//::::::::::::::::::::::::
//:: NAMESPACE SETTINGS ::
//::::::::::::::::::::::::

using namespace std;
using namespace MPIHiggsAnalysis;

//*****************************************************************************

//:::::::::::::::::
//:: CONSTRUCTOR ::
//:::::::::::::::::

VertexCollector::VertexCollector(const std::string & name,
                        ISvcLocator * svcloc) : Algorithm(name, svcloc) {

// JOB OPTIONS //

        m_track_particle_container_name = string("TrackParticleCandidate");
        declareProperty("TrackParticleContainer",
                                        m_track_particle_container_name);

        m_primary_vertex_container = string("VxPrimaryCandidate");
        declareProperty("vertexContainer", m_primary_vertex_container);

        m_vert_coll_svc_name = string("MPIHiggsAnalysis::VertexCollectionSvc");
        declareProperty("VertexCollectionSvc", m_vert_coll_svc_name);

// RESET POINTERS //

        m_storeGate = 0;
        m_log = 0;
        m_vert_coll = 0;

}

//*****************************************************************************

//::::::::::::::::
//:: DESTRUCTOR ::
//::::::::::::::::

VertexCollector::~VertexCollector(void) {
}

//*****************************************************************************

//:::::::::::::::::::::::
//:: METHOD initialize ::
//:::::::::::::::::::::::

StatusCode VertexCollector::initialize(void) {

// VARIABLES //

        m_log = new MsgStream(msgSvc(), name());

// MESSAGE //

        *m_log << MSG::INFO << "Initializing tool..." << endl;

// SET POINTERS //

// store gate //
        StatusCode sc(service("StoreGateSvc", m_storeGate));
        if (!sc.isSuccess()) {
                *m_log << MSG::FATAL << "Cannot retrieve StoreGateSvc!"
                        << endreq;
                return sc;
        }

// VertexCollectionSvc //
        sc = service(m_vert_coll_svc_name, m_vert_coll);
        if (!sc.isSuccess()) {
                *m_log << MSG::FATAL << "Cannot retrieve "
                        << m_vert_coll_svc_name
                        << "!"
                        << endreq;
                return sc;
        }

        return StatusCode::SUCCESS;

}

//*****************************************************************************

//::::::::::::::::::::
//:: METHOD execute ::
//::::::::::::::::::::

StatusCode VertexCollector::execute(void) {

// VARIABLES //

        const Rec::TrackParticleContainer *track_particle_container(0);
                                        // pointer to the track particles
        const VxContainer *vertex_container(0); // pointer to the vertices

// GET A POINTER TO THE VERTEX CONTAINER //

        StatusCode sc(m_storeGate->retrieve(vertex_container,
                                                m_primary_vertex_container));
        if (sc.isFailure() || vertex_container==0) {
                *m_log << MSG::ERROR
                        << "No vertex container "
                        << m_primary_vertex_container
                        << " found in the store gate!"
                        << endreq;
                return StatusCode::FAILURE;
        }

        *m_log << MSG::DEBUG
                << "Vertex container "
                << m_primary_vertex_container
                << " retrieved successfully!"
                << endreq;

        if (vertex_container->size()==0) {
                return StatusCode::FAILURE;
        }

// CALCULATE SUM OF TRANSVERSE ENERGIES EMERGING FROM THE VERTICES //

// retrieve track particles //
        sc = (m_storeGate->retrieve(track_particle_container,
                                        m_track_particle_container_name));
        if (sc.isFailure() || track_particle_container==0) {
                *m_log << MSG::WARNING
                        << "No track particle container found in store gate!"
                        << endreq;
                return StatusCode::FAILURE;
        }
        *m_log << MSG::DEBUG
                << "Track particle container retrieved successfully!"
                << endreq;

// loop over the vertices //
        vector<double> Et_vert(vertex_container->size(), 0.0); // Et(vertex)
        vector<int> nb_tracks(vertex_container->size(), 0); // number of
                                                              // tracks(vertex)
        for (unsigned int k=0; k<track_particle_container->size(); k++) {
        
            if((*track_particle_container)[k]->reconstructedVertex() == NULL){
                continue;
            }

            // if ((*track_particle_container)[k]->hlv().perp()<500.) {
//                 continue;
//             }
              
//             const Trk::TrackSummary* trksum = (*track_particle_container)[k]->trackSummary();
//             int trk_num_SCTHit  = trksum->get(Trk::numberOfSCTHits);
//             int trk_num_PHit    = trksum->get(Trk::numberOfPixelHits);   
            
//             if((trk_num_SCTHit+trk_num_PHit)<7){
//                 continue;
//             }
            

            for (unsigned int l=0; l<vertex_container->size(); l++) {
                
                Trk::RecVertex vert((*vertex_container)[l]->recVertex());
                
                if ((*track_particle_container)[k]->reconstructedVertex()->position()
                    ==vert.position()) {
                    
                    Et_vert[l] += (*track_particle_container)[k]->hlv().et();
                    nb_tracks[l]++;
                }
            }
        }

// CREATE THE VERTICES AND STORE THEM //

        std::vector<MPIHiggsAnalysis::Vertex> vertices(Et_vert.size());
        for (unsigned int k=0; k<vertices.size(); k++) {
                Trk::RecVertex vert((*vertex_container)[k]->recVertex());
                Trk::ErrorMatrix err(vert.errorPosition());
                Hep3Vector error(err.error(Trk::x), err.error(Trk::y),
                                                        err.error(Trk::z));
                vertices[k] = MPIHiggsAnalysis::Vertex(vert.position(), error,
                                vert.chi2(), vert.ndf(), Et_vert[k],
                                nb_tracks[k]);
        }

        m_vert_coll->setVertices(vertices);
        m_vert_coll->sortVerticesAscendingInEt();

        
        return StatusCode::SUCCESS;

}

//*****************************************************************************

//:::::::::::::::::::::
//:: METHOD finalize ::
//:::::::::::::::::::::

StatusCode VertexCollector::finalize(void) {

// MESSAGE //

        *m_log << MSG::INFO << "Finalizing tool..." << endl;

        return StatusCode::SUCCESS;

}

---