---

AOrecon.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/aoRecon/src/AOrecon.cxx,v 1.9 2001/08/31 14:57:55 burnett Exp $

// Include files

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/Algorithm.h"

#include "GlastSvc/GlastDetSvc/IGlastDetSvc.h"

#include "xml/IFile.h"

#include "reconstruction/GlastTuple.h"
#include "reconstruction/PrintReconData.h"
#include "reconstruction/SummaryData.h"

// TDS class declarations: input data, 
#include "GlastEvent/data/TdGlastData.h"

#include "GuiSvc/IGuiSvc.h"
#include "gui/GuiMgr.h"
#include "gui/DisplayControl.h"

// Include files
#include "instrument/MCTruth.h"
#include "instrument/FluxGenerator.h"

#include "reconstruction/SummaryData.h"
#include "reconstruction/ReconData.h"

#include "GaudiTuple.h"
#include "ntupleWriterSvc/INTupleWriterSvc.h"


//------------------------------------------------------------------------------
class AOrecon : public Algorithm {
    
public:
    AOrecon(const std::string& name, ISvcLocator* pSvcLocator); 
    
    StatusCode initialize();
    StatusCode execute();
    StatusCode finalize();
    
private:
    // the GlastDetSvc used for access to detector info
    IGlastDetSvc*    m_detSvc;
    // ptr to the GlastRecon object used to do the analysis
    GlastRecon*    m_recon;
    
    // constants from the "instrument.xml" file.
    xml::IFile * m_ini;
    SummaryData<GaudiTuple>* m_gsummary;

    INTupleWriterSvc* m_ntupleWriterSvc; //pointer to Heather's ntupleWriterSvc 
    

    std::string m_tuple_name; 
};

//------------------------------------------------------------------------------
static const AlgFactory<AOrecon>  Factory;
const IAlgFactory& AOreconFactory = Factory;
//------------------------------------------------------------------------------
AOrecon::AOrecon(const std::string& name, ISvcLocator* pSvcLocator) :
Algorithm(name, pSvcLocator), m_detSvc(0)
, m_recon(0), m_gsummary(0){

    declareProperty("tuple_name",  m_tuple_name="");

}

//------------------------------------------------------------------------------
StatusCode AOrecon::initialize() {
    
    MsgStream log(msgSvc(), name());
    
    // Use the Job options service to set the Algorithm's parameters
    setProperties();
    
    // now try to find the GlastDevSvc service
    StatusCode sc = service("GlastDetSvc", m_detSvc);
    
    
    if (!sc.isSuccess ()){
        log << MSG::ERROR << "Couldn't find the GlastDetSvc!" << endreq;
        return sc;
    }
    
    // test: get a constant from the ini file
    m_ini = const_cast<xml::IFile*>(m_detSvc->iniFile()); //OOPS!
    int nx = m_ini->getInt("glast", "xNum");
    
    m_recon=new GlastRecon;
    

    // get the Gui service (not required)
    IGuiSvc* guiSvc=0;
    sc = service("GuiSvc", guiSvc);

    if (!sc.isSuccess ()){
        log << MSG::WARNING << "No GuiSvc, so no display" << endreq;
        sc =StatusCode::SUCCESS; 
    }else{
       guiSvc->guiMgr()->display().add(m_recon->displayRep(), "Glast reco");
    }

        // access heather ntupleWiterSvc so that it can be passed
        // to GaudiTuple
        sc = service("ntupleWriterSvc", m_ntupleWriterSvc);

        if (!sc.isSuccess()){
                log << MSG::ERROR << "Unable to get ntupleWriterSvc" << endreq;
                return sc;
        }


    if( !m_tuple_name.empty() ) {
        // create and set the entries into a Gaudi Tuple
        m_gsummary = new SummaryData<GaudiTuple>(
            *new GaudiTuple(m_ntupleWriterSvc,"AO Recon output", m_tuple_name.c_str() ));
        m_recon->accept(*m_gsummary);   
        log << MSG::INFO << "Generating n-tuple to logical file " << m_tuple_name << endreq;
    }

    // make sure exists
    if(MCTruth::instance() ==0) new MCTruth();
    return sc;
}


//------------------------------------------------------------------------------
StatusCode AOrecon::execute() {
    
 
    StatusCode  sc = StatusCode::SUCCESS;
    MsgStream   log( msgSvc(), name() );
    
    static std::string path("/Event/TdGlastData");
    SmartDataPtr<TdGlastData> data(eventSvc(), path);
    
    if( 0==data) { log << MSG::ERROR << "could not find \""<< path <<"\"" << endreq;
       return StatusCode::FAILURE;
    }

 
    // see what is there
    if( msgSvc()->outputLevel()<3 ) data->printOn(std::cout);
    
    
    m_recon->clear();
    //  pass data to the GlastRecon object.
    m_recon->accept(ReconData(data));

    
    // see how many tracks found
    log << MSG::DEBUG << "Found " 
        <<  (m_recon->getTracker()->data.getData("No_Tracks")) << " tracks" << endreq;

    // print out the  tuple
    if( msgSvc()->outputLevel()<3 ) m_recon->accept(PrintReconData(std::cout));
    

    // fill and write out the Gaudi tuple   
    if( m_gsummary !=0)  m_gsummary->tuple()->fill();

    return sc;
}


//------------------------------------------------------------------------------
StatusCode AOrecon::finalize() {
    StatusCode  sc = StatusCode::SUCCESS;
    
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "finalize" << endreq;
    delete m_recon;
    delete m_gsummary;
#if 0 // does not work
    //try to read tuple back
    NTuplePtr nt(ntupleSvc(), "/NTUPLES/CALRECON/1");
    if( nt) {
        int count=0;
        NTuple::Item<float>esum;
        sc = nt->item("CsI_Energy_Sum", esum);
        while( ntupleSvc()->readRecord(nt.ptr()).isSuccess() ) {
            log << MSG::INFO << " Entry [" << (count++) <<"]" << "Etot=" << esum << endreq;
        }
        log << MSG::INFO << count << " entries " << endreq;
               
    }else {
        log << MSG::INFO << "Could not open tuple  /NTUPLES/AOrecon/1" << endreq;
    }
#endif   
    return StatusCode::SUCCESS;
}

//------------------------------------------------------------------------------
#if 0
StatusCode AOrecon::printNewNTuple(std::string dname) {
    StatusCode status;
    MsgStream log(msgSvc(), name());
    
    NTuplePtr nt = m_gsummary->tuple()->getNTuple();
    if( nt) {
        NTuple::Item<float> data;
        status = nt->item(dname ,data);
       
        if(status.isSuccess()) {
            log << MSG::INFO << "Test Value of :"
                << dname << "= " << data << endreq;
        } else {
            log << MSG::ERROR << "Didn't load the Item!" << endreq;
        }
    } else {
        log << MSG::ERROR << "Dead NTuple !" << endreq;
    }
    return status;
}


#endif

---