.. _program_listing_file_Root_TrackContainer.cxx:

Program Listing for File TrackContainer.cxx
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file_Root_TrackContainer.cxx>` (``Root/TrackContainer.cxx``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "xAODAnaHelpers/TrackContainer.h"
   #include <xAODAnaHelpers/HelperFunctions.h>
   #include <iostream>
   #include <xAODTracking/TrackParticle.h>
   
   using namespace xAH;
   
   TrackContainer::TrackContainer(const std::string& name, const std::string& detailStr, float units) : ParticleContainer(name,detailStr,units,true)
   
   {
     if(m_infoSwitch.m_fitpars){
       m_chiSquared = new std::vector<float >;
       m_d0 = new std::vector<float >;
       m_definingParametersCovMatrix = new std::vector<std::vector<float> >;
       m_expectInnermostPixelLayerHit = new std::vector< char >;
       m_expectNextToInnermostPixelLayerHit = new std::vector< char >;
       m_numberDoF = new std::vector<float >;
     }
   
     if(m_infoSwitch.m_numbers){
       m_numberOfInnermostPixelLayerHits = new std::vector< char >;
       m_numberOfNextToInnermostPixelLayerHits = new std::vector< char >;
       m_numberOfPhiHoleLayers = new std::vector< char >;
       m_numberOfPhiLayers = new std::vector< char >;
       m_numberOfPixelDeadSensors = new std::vector< char >;
       m_numberOfPixelHits = new std::vector< char >;
       m_numberOfPixelHoles = new std::vector< char >;
       m_numberOfPixelSharedHits = new std::vector< char >;
       m_numberOfPrecisionHoleLayers = new std::vector< char >;
       m_numberOfPrecisionLayers = new std::vector< char >;
       m_numberOfSCTDeadSensors = new std::vector< char >;
       m_numberOfSCTHits = new std::vector< char >;
       m_numberOfSCTHoles = new std::vector< char >;
       m_numberOfSCTSharedHits = new std::vector< char >;
       m_numberOfTRTHits = new std::vector< char >;
       m_numberOfTRTOutliers = new std::vector< char >;
     }
   
     m_phi = new std::vector<float >;
     m_qOverP = new std::vector<float >;
     m_theta = new std::vector<float >;
   
     if(m_infoSwitch.m_vertex){
       /*
         m_vertexLink = new std::vector<Int_t >;
         m_vertexLink_persIndex = new std::vector<UInt_t >;
         m_vertexLink_persKey = new std::vector<UInt_t >;
       */
       m_vz = new std::vector<float >;
       m_z0 = new std::vector<float >;
     }
   }
   
   TrackContainer::~TrackContainer()
   {
     if(m_debug) std::cout << " Deleting TrackContainer "<< std::endl;
   
     if(m_infoSwitch.m_fitpars){
       delete m_chiSquared;
       delete m_d0;
       delete m_definingParametersCovMatrix;
       delete m_expectInnermostPixelLayerHit;
       delete m_expectNextToInnermostPixelLayerHit;
       delete m_numberDoF;
     }
   
     if(m_infoSwitch.m_numbers){
       delete m_numberOfInnermostPixelLayerHits;
       delete m_numberOfNextToInnermostPixelLayerHits;
       delete m_numberOfPhiHoleLayers;
       delete m_numberOfPhiLayers;
       delete m_numberOfPixelDeadSensors;
       delete m_numberOfPixelHits;
       delete m_numberOfPixelHoles;
       delete m_numberOfPixelSharedHits;
       delete m_numberOfPrecisionHoleLayers;
       delete m_numberOfPrecisionLayers;
       delete m_numberOfSCTDeadSensors;
       delete m_numberOfSCTHits;
       delete m_numberOfSCTHoles;
       delete m_numberOfSCTSharedHits;
       delete m_numberOfTRTHits;
       delete m_numberOfTRTOutliers;
     }
   
     delete m_phi;
     delete m_qOverP;
     delete m_theta;
   
     if(m_infoSwitch.m_vertex){
       /*
         delete m_vertexLink;
         delete m_vertexLink_persIndex;
         delete m_vertexLink_persKey;
       */
       delete m_vz;
       delete m_z0;
     }
   }
   
   void TrackContainer::setTree(TTree *tree)
   {
     ParticleContainer::setTree(tree);
   
     if(m_infoSwitch.m_fitpars){
       connectBranch<float>(tree, "chiSquared", &m_chiSquared);
       connectBranch<float>(tree, "d0", &m_d0);
       connectBranch<std::vector<float> >(tree, "definingParametersCovMatrix", &m_definingParametersCovMatrix);
       connectBranch<char>(tree, "expectInnermostPixelLayerHit", &m_expectInnermostPixelLayerHit);
       connectBranch<char>(tree, "expectNextToInnermostPixelLayerHit", &m_expectNextToInnermostPixelLayerHit);
       connectBranch<float>(tree, "numberDoF", &m_numberDoF);
     }
   
     if(m_infoSwitch.m_numbers){
       connectBranch<char>(tree, "numberOfInnermostPixelLayerHits", &m_numberOfInnermostPixelLayerHits);
       connectBranch<char>(tree, "numberOfNextToInnermostPixelLayerHits", &m_numberOfNextToInnermostPixelLayerHits);
       connectBranch<char>(tree, "numberOfPhiHoleLayers", &m_numberOfPhiHoleLayers);
       connectBranch<char>(tree, "numberOfPhiLayers", &m_numberOfPhiLayers);
       connectBranch<char>(tree, "numberOfPixelDeadSensors", &m_numberOfPixelDeadSensors);
       connectBranch<char>(tree, "numberOfPixelHits", &m_numberOfPixelHits);
       connectBranch<char>(tree, "numberOfPixelHoles", &m_numberOfPixelHoles);
       connectBranch<char>(tree, "numberOfPixelSharedHits", &m_numberOfPixelSharedHits);
       connectBranch<char>(tree, "numberOfPrecisionHoleLayers", &m_numberOfPrecisionHoleLayers);
       connectBranch<char>(tree, "numberOfPrecisionLayers", &m_numberOfPrecisionLayers);
       connectBranch<char>(tree, "numberOfSCTDeadSensors", &m_numberOfSCTDeadSensors);
       connectBranch<char>(tree, "numberOfSCTHits", &m_numberOfSCTHits);
       connectBranch<char>(tree, "numberOfSCTHoles", &m_numberOfSCTHoles);
       connectBranch<char>(tree, "numberOfSCTSharedHits", &m_numberOfSCTSharedHits);
       connectBranch<char>(tree, "numberOfTRTHits", &m_numberOfTRTHits);
       connectBranch<char>(tree, "numberOfTRTOutliers", &m_numberOfTRTOutliers);
     }
   
     connectBranch<float>(tree, "phi", &m_phi);
     connectBranch<float>(tree, "qOverP", &m_qOverP);
     connectBranch<float>(tree, "theta", &m_theta);
   
     if(m_infoSwitch.m_vertex){
       /*
         connectBranch<Int_t>(tree, "vertexLink", &m_vertexLink);
         connectBranch<UInt_t>(tree, "vertexLink_persIndex", &m_vertexLink_persIndex);
         connectBranch<UInt_t>(tree, "vertexLink_persKey", &m_vertexLink_persKey);
       */
       connectBranch<float>(tree, "vz", &m_vz);
       connectBranch<float>(tree, "z0", &m_z0);
     }
   }
   
   void TrackContainer::updateParticle(uint idx, TrackPart& track)
   {
     if(m_debug) std::cout << "in TrackContainer::updateParticle" << std::endl;
     ParticleContainer::updateParticle(idx, track);
   
     if(m_infoSwitch.m_fitpars){
       track.chiSquared = m_chiSquared->at(idx);
       track.d0 = m_d0->at(idx);
       track.definingParametersCovMatrix = m_definingParametersCovMatrix->at(idx);
       track.expectInnermostPixelLayerHit = m_expectInnermostPixelLayerHit->at(idx);
       track.expectNextToInnermostPixelLayerHit = m_expectNextToInnermostPixelLayerHit->at(idx);
     }
   
     if(m_infoSwitch.m_numbers){
       track.numberDoF = m_numberDoF->at(idx);
       track.numberOfInnermostPixelLayerHits = m_numberOfInnermostPixelLayerHits->at(idx);
       track.numberOfNextToInnermostPixelLayerHits = m_numberOfNextToInnermostPixelLayerHits->at(idx);
       track.numberOfPhiHoleLayers = m_numberOfPhiHoleLayers->at(idx);
       track.numberOfPhiLayers = m_numberOfPhiLayers->at(idx);
       track.numberOfPixelDeadSensors = m_numberOfPixelDeadSensors->at(idx);
       track.numberOfPixelHits = m_numberOfPixelHits->at(idx);
       track.numberOfPixelHoles = m_numberOfPixelHoles->at(idx);
       track.numberOfPixelSharedHits = m_numberOfPixelSharedHits->at(idx);
       track.numberOfPrecisionHoleLayers = m_numberOfPrecisionHoleLayers->at(idx);
       track.numberOfPrecisionLayers = m_numberOfPrecisionLayers->at(idx);
       track.numberOfSCTDeadSensors = m_numberOfSCTDeadSensors->at(idx);
       track.numberOfSCTHits = m_numberOfSCTHits->at(idx);
       track.numberOfSCTHoles = m_numberOfSCTHoles->at(idx);
       track.numberOfSCTSharedHits = m_numberOfSCTSharedHits->at(idx);
       track.numberOfTRTHits = m_numberOfTRTHits->at(idx);
       track.numberOfTRTOutliers = m_numberOfTRTOutliers->at(idx);
     }
   
     track.phi = m_phi->at(idx);
     track.qOverP = m_qOverP->at(idx);
     track.theta = m_theta->at(idx);
   
     if(m_infoSwitch.m_vertex){
       /*
         track.vertexLink = m_vertexLink->at(idx);
         track.vertexLink_persIndex = m_vertexLink_persIndex->at(idx);
         track.vertexLink_persKey = m_vertexLink_persKey->at(idx);
       */
       track.vz = m_vz->at(idx);
       track.z0 = m_z0->at(idx);
     }
   
     if(m_debug) std::cout << "leaving TrackContainer::updateParticle" << std::endl;
     return;
   }
   
   void TrackContainer::setBranches(TTree *tree)
   {
     ParticleContainer::setBranches(tree);
   
     if(m_infoSwitch.m_fitpars){
     setBranch<float>(tree, "chiSquared", m_chiSquared);
     setBranch<float>(tree, "d0", m_d0);
     setBranch<std::vector<float>>(tree, "definingParametersCovMatrix", m_definingParametersCovMatrix);
     setBranch<char>(tree, "expectInnermostPixelLayerHit", m_expectInnermostPixelLayerHit);
     setBranch<char>(tree, "expectNextToInnermostPixelLayerHit", m_expectNextToInnermostPixelLayerHit);
     setBranch<float>(tree, "numberDoF", m_numberDoF);
     }
   
     if(m_infoSwitch.m_numbers){
       setBranch<char>(tree, "numberOfInnermostPixelLayerHits", m_numberOfInnermostPixelLayerHits);
       setBranch<char>(tree, "numberOfNextToInnermostPixelLayerHits", m_numberOfNextToInnermostPixelLayerHits);
       setBranch<char>(tree, "numberOfPhiHoleLayers", m_numberOfPhiHoleLayers);
       setBranch<char>(tree, "numberOfPhiLayers", m_numberOfPhiLayers);
       setBranch<char>(tree, "numberOfPixelDeadSensors", m_numberOfPixelDeadSensors);
       setBranch<char>(tree, "numberOfPixelHits", m_numberOfPixelHits);
       setBranch<char>(tree, "numberOfPixelHoles", m_numberOfPixelHoles);
       setBranch<char>(tree, "numberOfPixelSharedHits", m_numberOfPixelSharedHits);
       setBranch<char>(tree, "numberOfPrecisionHoleLayers", m_numberOfPrecisionHoleLayers);
       setBranch<char>(tree, "numberOfPrecisionLayers", m_numberOfPrecisionLayers);
       setBranch<char>(tree, "numberOfSCTDeadSensors", m_numberOfSCTDeadSensors);
       setBranch<char>(tree, "numberOfSCTHits", m_numberOfSCTHits);
       setBranch<char>(tree, "numberOfSCTHoles", m_numberOfSCTHoles);
       setBranch<char>(tree, "numberOfSCTSharedHits", m_numberOfSCTSharedHits);
       setBranch<char>(tree, "numberOfTRTHits", m_numberOfTRTHits);
       setBranch<char>(tree, "numberOfTRTOutliers", m_numberOfTRTOutliers);
     }
   
     setBranch<float>(tree, "phi", m_phi);
     setBranch<float>(tree, "qOverP", m_qOverP);
     setBranch<float>(tree, "theta", m_theta);
   
     if(m_infoSwitch.m_vertex){
       /*
         setBranch<Int_t>(tree, "vertexLink", m_vertexLink);
         setBranch<UInt_t>(tree, "vertexLink_persIndex", m_vertexLink_persIndex);
         setBranch<UInt_t>(tree, "vertexLink_persKey", m_vertexLink_persKey);
       */
       setBranch<float>(tree, "vz", m_vz);
       setBranch<float>(tree, "z0", m_z0);
     }
   }
   
   void TrackContainer::clear()
   {
     ParticleContainer::clear();
   
     if(m_infoSwitch.m_fitpars){
       m_chiSquared->clear();
       m_d0->clear();
       m_definingParametersCovMatrix->clear();
       m_expectInnermostPixelLayerHit->clear();
       m_expectNextToInnermostPixelLayerHit->clear();
       m_numberDoF->clear();
     }
   
     if(m_infoSwitch.m_numbers){
       m_numberOfInnermostPixelLayerHits->clear();
       m_numberOfNextToInnermostPixelLayerHits->clear();
       m_numberOfPhiHoleLayers->clear();
       m_numberOfPhiLayers->clear();
       m_numberOfPixelDeadSensors->clear();
       m_numberOfPixelHits->clear();
       m_numberOfPixelHoles->clear();
       m_numberOfPixelSharedHits->clear();
       m_numberOfPrecisionHoleLayers->clear();
       m_numberOfPrecisionLayers->clear();
       m_numberOfSCTDeadSensors->clear();
       m_numberOfSCTHits->clear();
       m_numberOfSCTHoles->clear();
       m_numberOfSCTSharedHits->clear();
       m_numberOfTRTHits->clear();
       m_numberOfTRTOutliers->clear();
     }
   
     m_phi->clear();
     m_qOverP->clear();
     m_theta->clear();
   
     if(m_infoSwitch.m_vertex){
       /*
         m_vertexLink->clear();
         m_vertexLink_persIndex->clear();
         m_vertexLink_persKey->clear();
       */
       m_vz->clear();
       m_z0->clear();
     }
   }
   
   void TrackContainer::FillTrack( const xAOD::TrackParticle* track ){
     return FillTrack(static_cast<const xAOD::IParticle*>(track));
   }
   
   void TrackContainer::FillTrack( const xAOD::IParticle* particle ){
     if(m_debug) std::cout << "In Fill Track" << std::endl;
     ParticleContainer::FillParticle(particle);
   
     const xAOD::TrackParticle* track=dynamic_cast<const xAOD::TrackParticle*>(particle);
     if(m_debug) std::cout << "Got TrackParticle" << std::endl;
   
     if(m_infoSwitch.m_fitpars){
       if(m_debug) std::cout << "Filling fitpars" << std::endl;
   
       m_chiSquared->push_back( track->chiSquared() );
       m_d0->push_back( track->d0() );
       m_numberDoF->push_back( track->numberDoF() );
       //m_definingParametersCovMatrix ->push_back(track->definingParametersCovMatrix() ); // fix this too
   
       static SG::AuxElement::ConstAccessor<unsigned char> expectInnermostPixelLayerHit("expectInnermostPixelLayerHit");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, expectInnermostPixelLayerHit, m_expectInnermostPixelLayerHit, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> expectNextToInnermostPixelLayerHit("expectNextToInnermostPixelLayerHit");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, expectNextToInnermostPixelLayerHit, m_expectNextToInnermostPixelLayerHit, -1);
     }
   
     if(m_infoSwitch.m_numbers){
       if(m_debug) std::cout << "Filling numbers" << std::endl;
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfInnermostPixelLayerHits, m_numberOfInnermostPixelLayerHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfNextToInnermostPixelLayerHits("numberOfNextToInnermostPixelLayerHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfNextToInnermostPixelLayerHits, m_numberOfNextToInnermostPixelLayerHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPhiHoleLayers("numberOfPhiHoleLayers");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPhiHoleLayers, m_numberOfPhiHoleLayers, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPhiLayers("numberOfPhiLayers");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPhiLayers, m_numberOfPhiLayers, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPixelDeadSensors("numberOfPixelDeadSensors");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPixelDeadSensors, m_numberOfPixelDeadSensors, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPixelHits("numberOfPixelHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPixelHits, m_numberOfPixelHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPixelHoles("numberOfPixelHoles");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPixelHoles, m_numberOfPixelHoles, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPixelSharedHits("numberOfPixelSharedHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPixelSharedHits, m_numberOfPixelSharedHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPrecisionHoleLayers("numberOfPrecisionHoleLayers");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPrecisionHoleLayers, m_numberOfPrecisionHoleLayers, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfPrecisionLayers("numberOfPrecisionLayers");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfPrecisionLayers, m_numberOfPrecisionLayers, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfSCTDeadSensors("numberOfSCTDeadSensors");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfSCTDeadSensors, m_numberOfSCTDeadSensors, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfSCTHits("numberOfSCTHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfSCTHits, m_numberOfSCTHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfSCTHoles("numberOfSCTHoles");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfSCTHoles, m_numberOfSCTHoles, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfSCTSharedHits("numberOfSCTSharedHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfSCTSharedHits, m_numberOfSCTSharedHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfTRTHits("numberOfTRTHits");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfTRTHits, m_numberOfTRTHits, -1);
   
       static SG::AuxElement::ConstAccessor<unsigned char> numberOfTRTOutliers("numberOfTRTOutliers");
       safeFill<unsigned char, char, xAOD::TrackParticle>(track, numberOfTRTOutliers, m_numberOfTRTOutliers, -1);
     }
   
     m_phi->push_back(track->phi() );
     m_qOverP->push_back(track->qOverP() );
     m_theta->push_back(track->theta() );
   
     if(m_infoSwitch.m_vertex){
       if(m_debug) std::cout << "Filling vertex" << std::endl;
   
       //static SG::AuxElement::ConstAccessor<int> vertexLink("vertexLink");
       /*
         m_vertexLink->push_back(vertexLink(*track) );
         //m_vertexLink_persIndex->push_back(track->vertexLink.m_persIndex() );
         //m_vertexLink_persKey->push_back(track->vertexLink.m_persKey() );
         m_vertexLink_persIndex->push_back( -999 );
         m_vertexLink_persKey->push_back( -999 );
       */
       m_vz->push_back(track->vz() );
       m_z0->push_back(track->z0() );
     }
   
     if(m_debug) std::cout << "Leave Fill Track" << std::endl;
     return;
   }