TestTrackViewer.cxx

Go to the documentation of this file.

// ================================================
// TestTrackViewer class Implementation
// ================================================
//
//
// Namespace ATLFast
//
#include "AtlfastAlgs/TestTrackViewer.h"
#include "AtlfastAlgs/GlobalEventData.h"
#include "AtlfastAlgs/ITrackViewer.h"
#include "AtlfastAlgs/AtlfTrackViewer.h"
#include "AtlfastAlgs/ITrackParameterView.h"
#include "AtlfastAlgs/AtlfTrackParameterView.h"

#include "AtlfastEvent/ITrackParameters.h"
#include "AtlfastEvent/CollectionDefs.h"

// Utilities
#include <cmath> 
#include <cassert> 
#include <stdexcept>
#include <sstream>
#include "AtlfastEvent/Phi.h"
#include "AtlfastUtils/HeaderPrinter.h"

// This is part of the STL and allows you to use
// generic sort algorithms (amongst other things)
#include <algorithm>
#include "AtlfastUtils/FunctionObjects.h"

// Athena/Gaudi includes
#include "GaudiKernel/DataSvc.h"

//#include "AtlfastEvent/MsgStreamDefs.h"

// A somewhat nicer assert...
class atl_test_err
  : public std::exception
{
public:
  explicit atl_test_err (const char* file,
                        int line,
                        const char* what);
  virtual ~atl_test_err() throw() {}
  virtual const char* what() const throw() { return m_what.c_str(); }
private:
  std::string m_what;
};


atl_test_err::atl_test_err (const char* file,
                            int line,
                            const char* what)
{
  std::ostringstream os;
  os << file << ":" << line << " assertion failure: " << what;
  m_what = os.str();
}


void throw_atl_test_err (const char* file, int line, const char* what)
{
  throw (atl_test_err (file, line, what));
}

#define ATL_ASSERT(X) do {     \
    if (!(X)) { \
      throw_atl_test_err (__FILE__, __LINE__, #X); \
    } \
  } while (0)

//

namespace Atlfast {
  using std::abs;
  using std::endl;
  
  
  //--------------------------------
  // Constructors and destructors
  //--------------------------------
  
  TestTrackViewer::TestTrackViewer ( const std::string& name, 
                               ISvcLocator* pSvcLocator ) 
    : Algorithm( name, pSvcLocator ){
    
    // Setting the parameter defaults.
    m_trackLocation      = "/Event/AtlfastTracks";
    declareProperty( "TrackLocation",    m_trackLocation ) ;
    
  }
  
  // Destructor
  TestTrackViewer::~TestTrackViewer() {
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "Destructor called" << endreq;
  } 
  
  
  //---------------------------------
  // initialise() 
  //---------------------------------
  
  StatusCode TestTrackViewer::initialize(){
    
    // We must here instantiate items which can only be made after
    // any job options have been set
    
    MsgStream log( messageService(), name() ) ;
    log << MSG::DEBUG << "Initialising" << endreq;
    HeaderPrinter hp("TestTrackViewer:",log);
    hp.add( "TrackLocation   ",   m_trackLocation ) ;
    hp.print();

    m_nevents = 0;
    m_ntracks = 0;

    GlobalEventData* ged = GlobalEventData::Instance();
    // load the location of the MC in StoreGate
    m_mcLocation       = ged -> mcLocation();

    //    m_tesIO = new TesIO(eventDataService());
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter());
    
    return StatusCode::SUCCESS ;
  }
  
  
  //---------------------------------
  // finalise() 
  //---------------------------------
  
  StatusCode TestTrackViewer::finalize(){
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "Finalizing" << endreq;
    log<<  MSG::INFO  << "Events Processed: "<<m_nevents<<endreq;
    log<<  MSG::INFO  << "Tracks Processed: "<<m_ntracks<<endreq;
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  //
  
  
  StatusCode TestTrackViewer::execute( ){
    
    //................................
    // make a message logging stream 
    
    MsgStream log( messageService(), name() ) ;
    ++m_nevents;
    
    
    //.........................................................
    // This is how you extract the things you want to look at. 
    // Look at the userguide for details of ReconstructedParticle, Cell
    // and Cluster classes
    std::vector<Track*> tracks;
    if(!m_tesIO->copy<TrackCollection >(tracks, m_trackLocation)){
      log << MSG::DEBUG 
          << "No Tracks found in TES at " 
          << m_trackLocation 
          << endreq ;
    }else{
      log << MSG::DEBUG 
          << "No. of Tracks found in TES  = " 
          << tracks.size() 
          << endreq ;
    }
    
    //.........................................................
    // Here are example things you might do
    
    
    if( tracks.size() ) this->testViewer( log, tracks ) ;
    
    return StatusCode::SUCCESS ;
    
  }
  
  
  //-------------------------------------------
  // private: testViewer
  //------------------------------------------
  
  void TestTrackViewer::testViewer ( MsgStream& log, 
                                     std::vector<Track*>& tracks){
    
    log << MSG::DEBUG << "Starting track view tester" << endreq ;
    
    
    
    // traverse collection of particles
    std::vector<Track*>::const_iterator track;
    
    for( track = tracks.begin(); track < tracks.end(); ++track ){
      
      log << MSG::DEBUG << *track << endreq;
      ++m_ntracks;
      TrackTrajectory traj = (*track)->trajectory();
      AtlfAna::AtlfTrackViewer trackViewer(*track);
      AtlfAna::ITrackParameterView& parameterView =  trackViewer;
      log<<MSG::DEBUG<<parameterView.trackParameters()<<endreq;
      const ITrackParameters& tp = parameterView.trackParameters();
      double eps = 0.0000001;
      TrackParameters testParam = (*track)->trajectory().parameters();
      ATL_ASSERT(abs( tp.eta()-testParam.eta() )                         < eps);
      ATL_ASSERT(abs( tp.phi()-testParam.phi() )                         < eps);
      ATL_ASSERT(abs( tp.cotTheta()-testParam.cotTheta() )               < eps);
      ATL_ASSERT(abs( tp.impactParameter()-testParam.impactParameter() ) < eps);
      ATL_ASSERT(abs( tp.zPerigee()-testParam.zPerigee() )               < eps);
      ATL_ASSERT(abs( tp.invPtCharge()-testParam.invPtCharge() )         < eps);
    }
    
  }
  
  
} // end of namespace bracket

---