---

Instrument.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/instrument/src/Instrument.cxx,v 1.10 2001/03/03 04:42:08 igable Exp $

#include "instrument/Instrument.h"
// Test program for the instrument classes

#include "instrument/ResponseFile.h"
#include "instrument/GlastDetector.h"
#include "xml/IFileManager.h"
#include <dom/DOM_Element.hpp>
#include "xml/IFile.h"           // probably need this
#include "xml/XmlParser.h"
#include <iostream>

Instrument::Instrument(): m_rootDetector(0), m_respFile(0), m_ownsDetector(true){}
    
    
Instrument::~Instrument(){
  // get rid of a glast detector hierarchy
  if(m_ownsDetector)delete m_rootDetector;
  m_rootDetector = 0;
  // kill the IFileManager
  xml::IFileManager::destroy ();
  // close the IRF file
  delete m_respFile;
  m_respFile = 0;
}
void Instrument::setDetector(GlastDetector* d)
{
    m_ownsDetector=false;
    m_rootDetector= d;
}


// initialize
int Instrument::initialize (std::string iniFile, std::string xmlFile) 
{
  ResponseFile::createFactories();

  const char * instrument_root = ::getenv("INSTRUMENTROOT");
  std::string root = std::string(instrument_root? instrument_root : ""); 
  m_iniFile = ( iniFile.empty())? root + "/xml/instrument.xml": iniFile;
  m_xmlFile = ( xmlFile.empty())? root + "/xml/glast.prs" : xmlFile;
    
  // attempt to load the ini data from the instrument.xml file
  if( loadIniFile () ) {
    std::cerr << "Could not load ini file: " <<  iniFile << std::endl;
    return 1;
  }
    
  if( xmlFile=="(none)" ) return 0; //if don't need

  // attempt to create the persistency data file
  int count = loadPersFile ();
  if ( count ==0 ) {
    std::cerr <<  
      "Failed to load detector elements from the persistency file: " 
              <<  xmlFile << std::endl;  
    return 1;
  }
  return 0;
}
//--->    do something with this method   <-----
int Instrument::loadPersFile () {
    
  // find and parse the xml file
  xml::XmlParser* parser = new xml::XmlParser;
  DOM_Document doc = parser->parse(m_xmlFile.c_str());

  if (doc == DOM_Document()) return -1;   // parse failed


  DOM_Element root = doc.getDocumentElement();
  if (!((root.getTagName()).equals("root")) ) {
    delete parser;
    return -1;
  }
  
  // create a detector for the root element's first child
  GlastDetector*  det = 0;  // detector to create

  DOM_Element glastChild = xml::Dom::findFirstChildByName(root, "*");

  if (glastChild == DOM_Element() ) {
    delete parser;
    return -1;
  }
  
  det = (GlastDetector*)(GlastDetector::createPersistence(glastChild));
  
  // now clean up.  We don't need the dom anymore or the parser.
//  delete parser;
  
  // check the object we created
  if (det)    m_rootDetector = det;
  else  return 0;
  
  return  GlastDetector::detector_count();
}

int Instrument::loadIniFile (){
  // load the ini style XML file to pull in all of the various
  // instrument parameters
  xml::IFileManager::instance()->load (new xml::IFile(m_iniFile.c_str()));
  
  return 0;
}



// loadNextEvent - attempt to load the next event from the
//                 IRF file.
int  Instrument::readIRF ()
{
  if (m_rootDetector) {
    // clear out the old detectors
    m_rootDetector->clear_all ();
    
    // try to load the next event
    if (!m_respFile->read_event ()) return 1;
  }
  else return 1;
  
  return 0;
}

int Instrument::openIRF(std::string filename)
{
  // assign the response (IRF) file
  m_respFile = new ResponseFile ( filename.c_str(), true );
  
  // check validity
  if (m_respFile ==0 || !m_respFile->good() ) {
    delete m_respFile;
    m_respFile = 0;
    return 1;
  }
  m_irfFile = filename;
  return 0;
}

void Instrument::accept(DetectorConverter& dc) const {
  
  static_cast<const GlastDetector*>(m_rootDetector)->accept(dc);
}


int Instrument::detector_count() const { 
  return m_rootDetector? GlastDetector::detector_count():0;
}

int Instrument::detectors_with_data() const { 
  return m_respFile? m_respFile->ndet_read(): 0;
}

const xml::IFile* Instrument::iniFile()const {
    return xml::IFileManager::instance()->ifile();
}

std::string Instrument::irfFileName() const { return m_irfFile; }
std::string Instrument::iniFileName() const { return m_iniFile; }
std::string Instrument::xmlFileName() const { return m_xmlFile; }
GlastDetector* Instrument::rootDetector() const { return m_rootDetector;}

---