DstEventMaker.cxx

Go to the documentation of this file.

#include "DstEventMaker.h"
 
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/SmartDataPtr.h"
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <vector>
 
#include "DstEvent/DstEmcShower.h"
#include "DstEvent/DstEvent.h"
#include "DstEvent/DstExtTrack.h" // track extrapolation  add 2005-09-02
#include "DstEvent/DstMdcDedx.h"
#include "DstEvent/DstMdcKalTrack.h" //Mdc Kal add 2005-09-24
#include "DstEvent/DstMdcTrack.h"
#include "DstEvent/DstMucTrack.h"
#include "DstEvent/DstTofTrack.h"
#include "EmcRecEventModel/RecEmcShower.h"
#include "EventModel/Event.h"
#include "EventModel/EventHeader.h"
#include "EventModel/EventModel.h"
#include "ExtEvent/RecExtTrack.h" // track extrapolation  add 2005-09-02
#include "MdcRecEvent/RecMdcDedx.h"
#include "MdcRecEvent/RecMdcDedxHit.h"
#include "MdcRecEvent/RecMdcHit.h"
#include "MdcRecEvent/RecMdcKalTrack.h" // Mdc Kal Add 2005-09-24
#include "MdcRecEvent/RecMdcTrack.h"
#include "MucRecEvent/MucRecHit.h"
#include "MucRecEvent/RecMucTrack.h"
#include "TofRecEvent/RecTofTrack.h"
 
using namespace std;
using namespace Event;
// using CLHEP::HepVector;
using CLHEP::Hep3Vector;
using CLHEP::HepSymMatrix;
 
// typedef std::vector<MdcRecHit*> HitRefVec;
 
/////////////////////////////////////////////////////////////////////////////
DECLARE_COMPONENT( DstEventMaker )
DstEventMaker::DstEventMaker( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( name, pSvcLocator ) {}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DstEventMaker::initialize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in initialize()" << endmsg;
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DstEventMaker::execute() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
 
  // Part 1: Get the event header, print out event and run number
 
  SmartDataPtr<Event::EventHeader> eventHeader( eventSvc(), "/Event/EventHeader" );
  if ( !eventHeader )
  {
    log << MSG::FATAL << "Could not find Event Header" << endmsg;
    return ( StatusCode::FAILURE );
  }
 
  int eventId = eventHeader->eventNumber();
  int runId   = eventHeader->runNumber();
  log << MSG::INFO << "DstEventMaker: retrieved event: "
      << "  Event Number  " << eventId << "  run: " << runId << endmsg;
 
  StatusCode sc = StatusCode::SUCCESS;
  int        trackID;
 
  // register ReconEvent Data Object to TDS; 2005/09/14
  DstEvent* dstEvt = new DstEvent();
  // dstEvt->setEventId(eventId);
  // dstEvt->setRunId(runId);
  sc = eventSvc()->registerObject( EventModel::Dst::Event, dstEvt );
 
  // Part 2: Retrieve Mdc Track
  SmartDataPtr<RecMdcTrackCol> recMdcTrackCol( eventSvc(), "/Event/Recon/RecMdcTrackCol" );
  if ( !recMdcTrackCol ) { log << MSG::INFO << "Could not find RecMdcTrackCol" << endmsg; }
  else
  {
    DstMdcTrackCol*          dstMdcTrackCol = new DstMdcTrackCol();
    RecMdcTrackCol::iterator iter_mdc       = recMdcTrackCol->begin();
    trackID                                 = 0;
    for ( ; iter_mdc != recMdcTrackCol->end(); iter_mdc++, trackID++ )
    {
      DstMdcTrack* dstMdcTrack = new DstMdcTrack();
      *dstMdcTrack             = **iter_mdc;
      ( *dstMdcTrackCol ).push_back( dstMdcTrack );
 
      log << MSG::INFO << " Mdc Track ID = " << trackID
          << " Mdc Track Nster = " << ( *iter_mdc )->nster() << endmsg;
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstMdcTrackCol, dstMdcTrackCol );
  }
 
  // Part 3: Retrieve Tof Track
  SmartDataPtr<RecTofTrackCol> tofTrackCol( eventSvc(), "/Event/Recon/RecTofTrackCol" );
  if ( !tofTrackCol ) { log << MSG::INFO << "Could not find TofTrackCol" << endmsg; }
  else
  {
    DstTofTrackCol*          dstTofTrackCol = new DstTofTrackCol();
    RecTofTrackCol::iterator iter_tof       = tofTrackCol->begin();
    for ( ; iter_tof != tofTrackCol->end(); iter_tof++ )
    {
      DstTofTrack* dstTofTrack = new DstTofTrack();
      *dstTofTrack             = **iter_tof;
      ( *dstTofTrackCol ).push_back( dstTofTrack );
 
      log << MSG::INFO << "Tof Track ID = " << ( *iter_tof )->tofTrackID()
          << " Track ID = " << ( *iter_tof )->trackID()
          << " Tof Counter ID = " << ( *iter_tof )->tofID()
          << " Quality = " << ( *iter_tof )->quality() << endmsg;
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstTofTrackCol, dstTofTrackCol );
  }
 
  // Part 4: Retrieve Muc Track
  SmartDataPtr<RecMucTrackCol> mucTrackCol( eventSvc(), "/Event/Recon/RecMucTrackCol" );
  if ( !mucTrackCol ) { log << MSG::INFO << "Could not find RecMucTrackCol" << endmsg; }
  else
  {
    DstMucTrackCol*          dstMucTrackCol = new DstMucTrackCol();
    RecMucTrackCol::iterator iter_muc       = mucTrackCol->begin();
    trackID                                 = 0;
    for ( ; iter_muc != mucTrackCol->end(); iter_muc++, trackID++ )
    {
      DstMucTrack* dstMucTrack = new DstMucTrack();
      *dstMucTrack             = **iter_muc;
      ( *dstMucTrackCol ).push_back( dstMucTrack );
      log << MSG::INFO << "Muc Track ID = " << trackID
          << " Muc NumHits  = " << ( *iter_muc )->GetTotalHits()
          << " Muc Pos x = " << ( *iter_muc )->getMucPos().x()
          << " Muc Pos y = " << ( *iter_muc )->getMucPos().y()
          << " Muc Pos z = " << ( *iter_muc )->getMucPos().z() << endmsg;
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstMucTrackCol, dstMucTrackCol );
  }
 
  // Part 5: Retrieve MdcDedx Track
 
  SmartDataPtr<RecMdcDedxCol> mdcDedxCol( eventSvc(), "/Event/Recon/RecMdcDedxCol" );
  if ( !mdcDedxCol ) { log << MSG::INFO << "Could not find RecMdcDedxCol" << endmsg; }
  else
  {
    trackID                               = 0;
    DstMdcDedxCol*          dstMdcDedxCol = new DstMdcDedxCol();
    RecMdcDedxCol::iterator iter_dedx     = mdcDedxCol->begin();
    for ( ; iter_dedx != mdcDedxCol->end(); iter_dedx++, trackID++ )
    {
      DstMdcDedx* dstMdcDedx = new DstMdcDedx();
      *dstMdcDedx            = **iter_dedx;
      ( *dstMdcDedxCol ).push_back( dstMdcDedx );
      log << MSG::INFO << " Dedx TrackID = "
          << trackID
          //      << " Num Sigma E = " << (*iter_dedx)->getSigmaDedx(1)
          //     << " Num Sigma Mu = " << (*iter_dedx)->getSigmaDedx(2)
          << endmsg;
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstMdcDedxCol, dstMdcDedxCol );
  }
 
  // Part 6: Retrieve Emc shower
 
  SmartDataPtr<RecEmcShowerCol> emcRecShowerCol( eventSvc(), "/Event/Recon/RecEmcShowerCol" );
  if ( !emcRecShowerCol )
  {
    log << /* MSG::FATAL*/ MSG::INFO << "Could not find RecEmcShowerCol" << endmsg;
    // return( StatusCode::FAILURE);
  }
  else
  {
    trackID                                  = 0;
    DstEmcShowerCol*          dstEmcTrackCol = new DstEmcShowerCol();
    RecEmcShowerCol::iterator iter_emc       = emcRecShowerCol->begin();
    for ( ; iter_emc != emcRecShowerCol->end(); iter_emc++, trackID++ )
    {
      DstEmcShower* dstEmcTrack = new DstEmcShower( *( *iter_emc ) );
      ( *dstEmcTrackCol ).push_back( dstEmcTrack );
      log << MSG::INFO << " Emc Track Id =  "
          << trackID
          //<< " Emc Shower Cell Id = " << (*iter_emc)->ShowerId()
          << endmsg;
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstEmcShowerCol, dstEmcTrackCol );
  }
 
  // Part 7: Retrieve Ext shower
 
  SmartDataPtr<RecExtTrackCol> extTrackCol( eventSvc(), "/Event/Recon/RecExtTrackCol" );
  if ( !extTrackCol )
  {
    log << /* MSG::FATAL*/ MSG::INFO << "Could not find RecExtTrackCol" << endmsg;
    // return( StatusCode::FAILURE);
  }
  else
  {
    trackID                                 = 0;
    DstExtTrackCol*          dstExtTrackCol = new DstExtTrackCol();
    RecExtTrackCol::iterator iter_ext       = extTrackCol->begin();
    for ( ; iter_ext != extTrackCol->end(); iter_ext++, trackID++ )
    {
      DstExtTrack* dstExtTrack = new DstExtTrack();
      *dstExtTrack             = **iter_ext;
      ( *dstExtTrackCol ).push_back( dstExtTrack );
      log << MSG::INFO << " Ext Track Id =  " << trackID
          << "volume name of Tof1 : " << ( *iter_ext )->tof1VolumeName()
          << " Ext Tof1 Error Z = " << ( *iter_ext )->tof1PosSigmaAlongZ()
          << " Ext Tof2 Error Z = " << ( *iter_ext )->tof2PosSigmaAlongZ()
          << " Ext Emc Error theta = " << ( *iter_ext )->emcPosSigmaAlongTheta()
          << " Ext Muc Error Z = " << ( *iter_ext )->mucPosSigmaAlongZ() << endmsg;
    }
 
    sc = eventSvc()->registerObject( EventModel::Dst::DstExtTrackCol, dstExtTrackCol );
  }
  // Part 8: Retrieve MdcKal track
 
  SmartDataPtr<RecMdcKalTrackCol> mdcKalTrackCol( eventSvc(),
                                                  "/Event/Recon/RecMdcKalTrackCol" );
  if ( !mdcKalTrackCol )
  {
    log << /* MSG::FATAL*/ MSG::INFO << "Could not find MdcKalTrackCol" << endmsg;
    // return( StatusCode::FAILURE);
  }
  else
  {
    trackID = 0;
    int   nhits[5];
    int   stat[2][5];
    float chisq[2][5];
    int   ndf[2][5];
    int   nster[2][5];
    int   fL[2][5];
    int   lL[2][5];
 
    DstMdcKalTrackCol*          dstMdcKalTrackCol = new DstMdcKalTrackCol();
    RecMdcKalTrackCol::iterator iter_kal          = mdcKalTrackCol->begin();
    for ( ; iter_kal != mdcKalTrackCol->end(); iter_kal++, trackID++ )
    {
      DstMdcKalTrack* dstMdcKalTrack = new DstMdcKalTrack();
      *dstMdcKalTrack                = **iter_kal;
 
      /*
      for (int i=0; i<5; i++){
        nhits[i] = (*iter_kal)->getNhits(i);
        stat[i]  =  (*iter_kal)->getStat(0,i);
        chisq[i] = (*iter_kal)->getChisq(0,i);
        ndf[i]   = (*iter_kal)->getNdf(0,i);
        nster[i]   = (*iter_kal)->getNster(0,i);
        fL[i]  = (*iter_kal)->getFirstLayer(0,i);
        lL[i]  = (*iter_kal)->getLastLayer(0,i);
 
        dstMdcKalTrack->setNhits(nhits[i],i);
        dstMdcKalTrack->setStat(stat[i],i);
        dstMdcKalTrack->setChisq(chisq[i],i);
        dstMdcKalTrack->setNdf(ndf[i],i);
        dstMdcKalTrack->setNster(nster[i],i);
        dstMdcKalTrack->setFirstLayer(fL[i],i);
        dstMdcKalTrack->setLastLayer(lL[i],i);
      }
      dstMdcKalTrack->setTrackId((*iter_kal)->getTrackId());
 
      for(int j=0; j<5; j++){
        dstMdcKalTrack->setPoca((*iter_kal)->getPoca(j),j);
        dstMdcKalTrack->setZHelix((*iter_kal)->getZHelix(j),j);
        dstMdcKalTrack->setZError((*iter_kal)->getZError(j),j);
      }
 
      */
 
      ( *dstMdcKalTrackCol ).push_back( dstMdcKalTrack );
 
      log << MSG::INFO << " * * * * * * * * * * * * * * * * * * * * * * * * * * *" << endmsg;
      for ( int i = 0; i < 5; i++ )
      {
        log << MSG::INFO << "dstMdcKalTrack ZHelix[" << i
            << "] = " << dstMdcKalTrack->getZHelix( i ) << endmsg;
        log << MSG::INFO << "number of total hits contained [" << i << "]" << nhits[i]
            << endmsg;
        log << MSG::INFO << "status flag [" << i << "]" << stat[i] << endmsg;
        log << MSG::INFO << "dstMdcKalTrack ZError [" << i << "]"
            << dstMdcKalTrack->getZError( i ) << endmsg;
        log << MSG::INFO << "dstMdcKalTrack Poca [" << i << "]" << dstMdcKalTrack->getPoca( i )
            << endmsg;
      }
    }
    sc = eventSvc()->registerObject( EventModel::Dst::DstMdcKalTrackCol, dstMdcKalTrackCol );
  }
 
  return sc;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DstEventMaker::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
 
  return StatusCode::SUCCESS;
}