---

ResponseFile.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/instrument/src/ResponseFile.cxx,v 1.8 2001/08/08 01:44:05 burnett Exp $
//  ResponseFile.cxx
//  Author:     Sawyer Gillespie
//              Department of Physics, University of Washington
//              hgillesp@u.washington.edu
//
//  Implementation of the ResponseFile class
//

#include "instrument/ResponseFile.h"
#include "instrument/CsIDetector.h"
#include "instrument/MCTruth.h"
#include "instrument/Scintillator.h"
#include "instrument/SiDetector.h"
#include "instrument/Calorimeter.h"
#include "instrument/Glast.h"
#include "instrument/Tower.h"
#include "instrument/DetectorVolumes.h"
#include "instrument/SiTracker.h"


#include "xml/IFileManager.h"
#include "xml/IFile.h"

#include <iterator>

// class implementation

const char* ResponseFile::s_version = "1.0.0";
const char* ResponseFile::s_revision = "1.0";

namespace {
  bool responsefileParamLoad = 
    xml::IFileManager::loadParams(ResponseFile::loadParameters);
}

void ResponseFile::createFactories(){
  //  handles loading all of the factories for the 
  // various GlastDetector classes
  DetectorBox::_PersistKey detvl(DetectorBox::classPersistKey);
  Calorimeter::_PersistKey cal(Calorimeter::classPersistKey);
  SiDetector::_PersistKey  si(SiDetector::classPersistKey);
  MCTruth::_PersistKey     mc(MCTruth::classPersistKey);
  CsIDetector::_PersistKey csi = CsIDetector::classPersistKey;
  Glast::_PersistKey       glast(Glast::classPersistKey);
  Tower::_PersistKey       tow(Tower::classPersistKey);
  SiTracker::_PersistKey   track(SiTracker::classPersistKey);
  Scintillator::_PersistKey scin(Scintillator::classPersistKey);

}
// constructors

ResponseFile::ResponseFile (std::ostream* o, bool owns, ios_mode mode) 
  : m_binin (0), m_stdin(0), m_ownsin (false), m_binout(0), m_stdout(0), m_ownsout (false)
  , m_version(""), m_revision("")
{
  setout (o, mode, owns);
}

ResponseFile::ResponseFile (std::istream* i, bool owns, ios_mode mode) 
  : m_binin (0), m_stdin(0), m_ownsin (false), m_binout(0), m_stdout(0), 
    m_ownsout (false), m_version(""), m_revision("")
{
  setin (i, mode, owns);
}

ResponseFile::ResponseFile (const char* fname, bool read, ios_mode mode)
  : m_binin (0), m_stdin(0), m_ownsin (false), m_binout(0), m_stdout(0), 
    m_ownsout (false), m_version(""), m_revision("")
{
  if (read) {
    std::ifstream*  inf = new std::ifstream (fname, (mode == binary_mode) ?
                                             std::ios::binary : std::ios::in);
    if (inf->good())
      setin (inf, mode, true);
    else    
      delete inf;
  } else {
    std::ofstream*  off = new std::ofstream (fname, (mode == binary_mode) ? 
                                             std::ios::binary : std::ios::out);
    if (off->good())
      setout (off, mode, true);
    else
      delete off;
  }
}

void    ResponseFile::setin (std::istream* in, ios_mode mode, bool owns)
{
  if (m_ownsin)   {
    delete m_stdin;
    delete m_binin;
  }
  if (mode == binary_mode) {
#ifdef _MSC_VER
    m_binin = new bpkt::istream (in);
#else
    m_binin = in;
#endif
  } else 
    m_stdin = in;

  m_ownsin = true;

  if (!verify ((mode == binary_mode) ? *m_binin : *m_stdin, mode)) { 
    // check response file validity
    // warn user & dump the file.
    WARNING ("Incompatible IRF file format");
    // delete m_in;    
    // m_in = 0;
  }
}

void    ResponseFile::setout (std::ostream* out, ios_mode mode, bool owns)
{
  if (m_ownsout)  {
    delete m_stdout;
    delete m_binout;
  }
  if (mode == binary_mode) {
#ifdef _MSC_VER
    m_binout = new bpkt::ostream (out);
#else
    m_binout = out;
#endif
  } else
    m_stdout = out;

  m_ownsout = true;

  // write the version control sequence
  verify ((mode == binary_mode) ? *m_binout : *m_stdout, mode); 
}

// destructor

ResponseFile::~ResponseFile ()
{
  if (m_ownsin) {
    delete m_stdin;    // close files
    delete m_binin;
  }
  if (m_ownsout) {
    delete m_stdout;
    delete m_binout;
  }
}

// loadParameters - read paramter data from an INI structure
void    ResponseFile::loadParameters (xml::IFile& ini)
{
  s_version = ini.getString("configuration", "version", s_version);
  s_revision = ini.getString("configuration", "revision", s_revision);
}

// verify - write version control sequence (determines compatibility)

void    ResponseFile::verify (std::ostream& o, ios_mode mode)
{
  if (o.good()) {
    m_version = s_version;
    m_revision = s_revision;
    o << m_version << '\n';
    o << m_revision << '\n';
    if (mode == binary_mode)    o << '\0' << std::flush;
  }
}

// verify - read the response file and determine its validity

bool    ResponseFile::verify (std::istream& i, ios_mode mode)
{
  std::getline(i, m_version, '\n');
  std::getline(i, m_revision, '\n');

  if (m_revision != s_revision) {
    std::strstream msg; 
    msg << "Response file has was created using a different instrument.ini revision ("
        << m_revision << "), than currently ("
        << s_revision << "). Results MAY be unreliable" << std::ends;
    WARNING(msg.str());
    msg.freeze(false);
  } 
  if (mode == binary_mode)    i.sync();

  if (m_version == s_version) return true;
  return false;
}

// write_event - dump event data to a file

void    ResponseFile::write_event ()
{
  if (!good() || (!m_stdout && !m_binout))    return;

  GlastDetector::MemberList::const_iterator it;
  for (it = GlastDetector::allbegin(); it != GlastDetector::allend(); ++it) {
    (*this) << *(*it).second;
  }
  end_event ();
}

void    ResponseFile::write_event (std::vector<int> header)
{
  if (!good() || (!m_stdout && !m_binout))    return;
  if( m_stdout ) {
          (*m_stdout) << "\n0 " ; // this is a pseudo-id, that should not match any real ones!
          std::copy(header.begin(), header.end(), 
                  std::ostream_iterator<int> (*m_stdout, " "));
          (*m_stdout) << "|" ;
  }
  write_event();

}

// read_event - read event data in from a file: returns true if successful,
// false otherwise

bool    ResponseFile::read_event ()
{
  if (!good() || (!m_stdin && !m_binin))  return false;

  //clear_all(); // perhaps not, if overlapping
  int i = 0;
  m_det_read=0;

  // read in all of the event data...
  while(1) {
    if (!good()) break;
    i = next_id(); if(i<0) break;   // if in < 0 (event boundary)
    m_det_read ++;

    GlastDetector*  d = GlastDetector::findDetector (i);
    if (d) {
      (*this) >> *d;
    } else {
    }
    flush_record ();
  }

  return true;
}

// read the individual GlastDetector subclasses:

void    ResponseFile::backward (CsIDetector& d)
{
  if (good()) {
    float Le, Re, E;
    *this >> Le >> Re >> E;
    d.addEnergy (Le, Re, E);
  }
}

void    ResponseFile::backward (MCTruth& d)
{
  if (good()) {
    unsigned int    id;
    if (m_binin)    *m_binin >> id;
    if (m_stdin)    *m_stdin >> id;
    d.id (id); 
    if (d.particle()) {
      if (m_binin)    d.particle()->read_data (*m_binin);
      if (m_stdin)    d.particle()->read (*m_stdin);
    }
  }
}

void    ResponseFile::backward (Scintillator& d)
{
  if (good()) {
    float e;
    *this >> e;
    d.addEnergy (e);
  }
}

void    ResponseFile::backward (SiDetector& d)
{
  if (good()) {
    float   maxE;
    *this >> maxE;
    d.maxELoss (maxE);

    int count;
    *this >> count;

    while ((count--) && (good()))
    {
      int id;
      float e;
      bool noise;
      *this >> id >> e >> noise;
      d.addStrip (id, e, noise);
    }
  }
}

// write the individual GlastDetector subclasses

void    ResponseFile::forward (const CsIDetector& d)
{
  if (good()) {
    *this << d.Lresp() << d.Rresp() << d.energy();
  }
}

void    ResponseFile::forward (const MCTruth& d)
{
  if (good()) {
    *this << d.id();
    if (m_binout)   d.particle()->write_data (*m_binout);
    if (m_stdout)   {
      d.particle()->write (*m_stdout);
      (*m_stdout) << ' ';
    }
  }
}

void    ResponseFile::forward (const Scintillator& d)
{
  if (good()) {
    *this << d.energy();
  }
}

void    ResponseFile::forward (const SiDetector& d)
{
  if (good()) {
    *this << d.maxELoss ();;

    int count = d.size ();
    *this << count;

    for (SiDetector::const_iterator it = d.begin(); it != d.end(); ++it) {
      *this << (*it).index() << (*it).energy() << (*it).noise();
    }
  }
}

---