io_ascii.hh File Reference

#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include "Evt.hh"
#include "Hit.hh"
#include "Trk.hh"
#include "Head.hh"
#include "Exception.hh"
#include "TDatabasePDG.h"

Go to the source code of this file.

Namespaces
	mc_keys
	mc_usr_keys
	io_stringutil

Functions
bool	io_stringutil::startswith (const std::string &a, const std::string &b)
	Check if string starts with given text. More...
std::string	io_stringutil::trim (const std::string &s)
	Remove leading and trailing white spaces. More...
int	pdg_code (int geant3_code)
	Convert Geant3 to PDG particle type. More...
int	geant3_code (int pdg_code)
	Convert PDG to Geant3 particle type. More...
bool	read (Vec &v, std::istream &is)
	Read a Vec(tor) from a stream. More...
bool	write (const Vec &v, std::ostream &os)
	Write a Vec(tor) to a stream. More...
bool	read (Hit &h, std::istream &is, bool read_mc=false)
	Read a hit from a stream. More...
bool	write (const Hit &h, std::ostream &os, const std::string &tag=mc_keys::hit_t)
	Write a hit to a stream. More...
bool	read (Trk &t, std::istream &is, const std::string &tag=mc_keys::track_in_t)
	Read track from a stream. More...
bool	write (const Trk &t, std::ostream &os, std::string tag=mc_keys::track_in_t)
	Write track to a stream. More...
std::vector< double >	read_line_to_vector (std::istream &is)
	Read data. More...
template<typename T >
void	push_front (std::vector< T > &vec, T &value)
	Put value in front of data. More...
bool	read (Evt &evt, std::istream &is, bool skip_hits=false)
	Read event from a stream. More...
bool	write (const Evt &evt, std::ostream &os)
	Write event to a stream. More...
bool	read (Head &hdr, std::istream &is)
	Read header from a stream. More...
bool	write (const Head &hdr, std::ostream &os)
	Write header to a stream. More...

Variables
const char *const	mc_keys::auto_t = "auto"
const char *const	mc_keys::start_run_t = "start_run:"
const char *const	mc_keys::start_event_t = "start_event:"
const char *const	mc_keys::hit_t = "hit:"
const char *const	mc_keys::hit_raw_t = "hit_raw:"
const char *const	mc_keys::track_in_t = "track_in:"
const char *const	mc_keys::track_t = "track:"
const char *const	mc_keys::track_fit_t = "track_fit:"
const char *const	mc_keys::neutrino_t = "neutrino:"
const char *const	mc_keys::track_primary_t = "track_primary:"
const char *const	mc_keys::primarylepton_t = "primarylepton:"
const char *const	mc_keys::weights_t = "weights:"
const char *const	mc_keys::w2list_t = "w2list:"
const char *const	mc_keys::w3list_t = "w3list:"
const char *const	mc_keys::hourangle_t = "hourangle:"
const char *const	mc_keys::center_on_can_t = "center_on_can:"
const char *const	mc_keys::muon_decay_t = "muon_decay:"
const char *const	mc_keys::end_event_t = "end_event:"
const char *const	mc_usr_keys::energy_lost_in_can = "energy_lost_in_can"
const char *const	mc_usr_keys::bx = "bx"
const char *const	mc_usr_keys::by = "by"
const char *const	mc_usr_keys::ichan = "ichan"
const char *const	mc_usr_keys::cc = "cc"
const char *const	mc_usr_keys::muon_decay_x = "muon_decay_x"
const char *const	mc_usr_keys::muon_decay_y = "muon_decay_y"
const char *const	mc_usr_keys::muon_decay_z = "muon_decay_z"
const char *const	mc_usr_keys::center_on_can_x = "center_on_can_x"
const char *const	mc_usr_keys::center_on_can_y = "center_on_can_y"
const char *const	mc_usr_keys::center_on_can_z = "center_on_can_z"
const char *const	mc_usr_keys::hourangle = "hourangle"

Function Documentation

pdg_code()

int pdg_code ( int  geant3_code )

inline

Convert Geant3 to PDG particle type.

Parameters

geant3_code

Geant3 code

Returns

PDG code

Definition at line 110 of file io_ascii.hh.

{  
  if ( geant3_code==-1 ) return -1; // used for k40 hits
  if ( geant3_code < 0 ) return pdg_code( -geant3_code ); // used for scattered
 
  return TDatabasePDG::Instance()->ConvertGeant3ToPdg( geant3_code );  
}

geant3_code()

int geant3_code ( int  pdg_code )

inline

Convert PDG to Geant3 particle type.

Parameters

pdg_code

PDG code

Returns

Geant3 code

Definition at line 124 of file io_ascii.hh.

{
  if (pdg_code == -1 )   return -1;  
  if (pdg_code == +311 ) return geant3_code( 130 ); // K0 -> K0long
  if (pdg_code == -311 ) return geant3_code( 130 ); // K0bar -> K0long
 
  return TDatabasePDG::Instance()->ConvertPdgToGeant3( pdg_code );  
}

read() [1/5]

bool read ( Vec &  v, std::istream &  is  )

inline

Read a Vec(tor) from a stream.

Parameters

v	vector
is	input stream

Returns

true if correctly read; else false

Definition at line 141 of file io_ascii.hh.

{
  is >> v.x >> v.y >> v.z;
  return !is.fail();
}

write() [1/5]

bool write ( const Vec &  v, std::ostream &  os  )

inline

Write a Vec(tor) to a stream.

Parameters

v	vector
os	output stream

Returns

true if correctly written; else false

Definition at line 154 of file io_ascii.hh.

{
  os << v.x << ' ' << v.y << ' ' << v.z;
  return !os.fail();
}

read() [2/5]

bool read ( Hit &  h, std::istream &  is, bool  read_mc = false  )

inline

Read a hit from a stream.

Parameters

h	hit
is	input stream
read_mc	option to read also type and origin

Returns

true if correctly read; else false

Definition at line 168 of file io_ascii.hh.

{
  h.dom_id     = 0; // need a proper det file to
  h.channel_id = 0; // set these.
 
  is >> h.id >> h.pmt_id >> h.a >> h.t;
  if ( !read_mc ) 
    {
      return !is.fail();
    }
  else
    {
      is >> h.type >> h.origin;
    }
 
  // If we get here without failing, we will return true, but
  // will attempt to read also pure_a and pure_t which may
  // or may not be present, depending on the km3 version.
 
  bool r = !is.fail(); 
  is >> h.pure_a >> h.pure_t; 
  if (is.fail())
    {
      h.pure_a = h.pure_t =0 ;
      is.clear();
    }
  return r;
}

write() [2/5]

bool write ( const Hit &  h, std::ostream &  os, const std::string &  tag = mc_keys::hit_t  )

inline

Write a hit to a stream.

Parameters

h	hit
os	output stream
tag	tag

Returns

true if correctly written; else false

Definition at line 206 of file io_ascii.hh.

{
  int om_id = h.pmt_id; // todo: deal with this better.
 
  os << tag << ' ' << h.id << ' ' << om_id << ' ' << h.a << ' ' << h.t;
  if ( tag != mc_keys::hit_raw_t ) {
    os << ' ' << h.type  << ' ' << h.origin << ' ' << h.pure_a << ' ' << h.pure_t; 
  }
  os << std::endl;
  return !os.fail();
}

read() [3/5]

bool read ( Trk &  t, std::istream &  is, const std::string &  tag = mc_keys::track_in_t  )

inline

Read track from a stream.

Parameters

t	track
is	input stream
tag	tag

Returns

true if correctly read; else false

Definition at line 227 of file io_ascii.hh.

{
  using namespace std;
 
  string line;
  getline( is, line );
  istringstream ii(line);
 
  ii >> t.id >> t.pos >> t.dir >> t.E >> t.t;
 
  if (!ii) return false;  
 
  t.len = 0.0;
  t.clearusr();
  t.comment = tag;
 
  if ( tag == mc_keys::track_in_t) 
    {
      ii >> t.type; if (!ii) return false;
      t.type = pdg_code( t.type );
      ii >> t.len;  
      if (!ii) return true; // missing length is not an error
 
      double eloss=0;
      ii >> eloss;
      if (!ii) return true; // missing eloss is not an error
 
      //dbg(eloss);
      t.setusr( mc_usr_keys::energy_lost_in_can, eloss); 
    }
 
  if (tag == mc_keys::primarylepton_t)
    {      
      ii >> t.type;  if (!ii) return false;
      t.type = pdg_code( t.type ); // treat the same as track_in
    }
 
 
  if ( tag == mc_keys::neutrino_t ) 
    {
      double bx,by;
      int cc, ichan;
      ii >> bx >> by >> ichan >> t.type >> cc;
 
      t.clearusr();
      t.setusr(mc_usr_keys::bx, bx);
      t.setusr(mc_usr_keys::by ,by);
      t.setusr(mc_usr_keys::ichan, ichan);
      t.setusr(mc_usr_keys::cc, cc);
    }
 
  if ( tag == mc_keys::track_primary_t )
    {
      ii >> t.type; // nucleus id (in pdg format or not?)
    }
 
  if ( ii.fail() )
    {
      ostream& out = Exception::getOstream();
 
      out << "Error reading trk ";
 
      t.print(out);
 
      throw Exception(static_cast<ostringstream&>(out).str());
    }
 
  return !ii.fail();
}

write() [3/5]

bool write ( const Trk &  t, std::ostream &  os, std::string  tag = mc_keys::track_in_t  )

inline

Write track to a stream.

Parameters

t	track
os	output stream
tag	tag

Returns

true if correctly read; else false

Definition at line 305 of file io_ascii.hh.

{
  using namespace std;
 
  int type = t.type;
 
  if ( tag == mc_keys::auto_t )
    {
      tag = t.comment;
    }
 
  os << tag << ' ' << t.id <<' '<< t.pos <<' '<< t.dir <<' '<< t.E << ' ' << t.t;
 
  if ( tag == mc_keys::track_in_t)
    {
      os << ' ' << geant3_code(type) << ' ' << t.len;
 
      if ( t.haveusr( mc_usr_keys::energy_lost_in_can ) )
        {
          os << ' ' << t.getusr( mc_usr_keys::energy_lost_in_can );
        }
      os << endl;
    }
 
  else if (tag == mc_keys::track_primary_t)
    {
      os << ' ' << t.type << endl;
    }
 
  else if (tag == mc_keys::primarylepton_t)
    {
      os << ' ' << geant3_code(type) << endl;
    }
 
  else if ( tag == mc_keys::neutrino_t )
    {
      os << ' ' << t.getusr(mc_usr_keys::bx)
         << ' ' << t.getusr(mc_usr_keys::by)
         << ' ' << t.getusr(mc_usr_keys::ichan)
         << ' ' << t.type
         << ' ' << t.getusr(mc_usr_keys::cc)  
         << endl;
    }
 
  else
    os << endl;
 
  return !os.fail();
}

read_line_to_vector()

std::vector<double> read_line_to_vector ( std::istream &  is )

inline

Read data.

Parameters

is	input stream

Returns

data

Definition at line 362 of file io_ascii.hh.

{
  using namespace std;
 
  vector<double> r;
 
  string ss;
  getline(is,ss);
  istringstream il(ss);
  for ( double x; il >> x ; ) r.push_back( x );
 
  return r;
}

push_front()

template<typename T >

void push_front ( std::vector< T > &  vec, T &  value  )

inline

Put value in front of data.

Parameters

vec	data
value	value

Definition at line 384 of file io_ascii.hh.

{
  vec.insert( vec.begin(), value );
}

read() [4/5]

bool read ( Evt &  evt, std::istream &  is, bool  skip_hits = false  )

inline

Read event from a stream.

Parameters

evt	event
is	input stream
skip_hits	option to skip reading of hits

Returns

true if correctly read; else false

Definition at line 398 of file io_ascii.hh.

{
  using namespace std;
 
  string w;
 
  // find next start_event
 
  while ( w != mc_keys::start_event_t && is.good() ) is >> w;
 
  int mc_event_type;   // dummy - this is always 1 in all files.
  is >> evt.mc_id >> mc_event_type;
 
  Trk trk_nu, trk_primary, trk_primary_lepton; 
  bool have_trk_nu(false), have_trk_primary(false), have_trk_primary_lepton(false); 
 
 
  evt.mc_trks.clear();
  evt.hits.clear();
  evt.mc_hits.clear();
 
  string w_old;
 
  while ( is )
    {
      static Hit h;
      static Trk t;
 
      is >> w;
 
      if (skip_hits && ( w == mc_keys::hit_t || w == mc_keys::hit_raw_t) )
        {
          is.ignore( 1000, '\n' );
          continue;
        }
 
      if ( w == mc_keys::hit_t ) 
        {         
          read( h, is, true ); 
          evt.mc_hits.push_back( h );
        }
      else if ( w == mc_keys::hit_raw_t )
        {
          read( h, is, false); 
          evt.hits.push_back( h );
        }
      else if ( w == mc_keys::track_in_t )
        {
          read( t, is , w);
          evt.mc_trks.push_back( t );
        }
      else if ( w == mc_keys::track_t )
        {
          read( t, is );
          evt.trks.push_back( t );
        }
      else if ( w == mc_keys::neutrino_t)
        {
          read( trk_nu ,is,  w);
          have_trk_nu = true;
        } 
      else if ( w == mc_keys::track_primary_t)
        {         
          read( trk_primary, is,  w);
          have_trk_primary = true;
        }
      else if ( w == mc_keys::primarylepton_t)
        {         
          read( trk_primary_lepton, is,  w);
          have_trk_primary_lepton = true;
        }      
      else if ( w == mc_keys::weights_t)
        {
          evt.w = read_line_to_vector( is );    
        }
      else if ( w == mc_keys::w2list_t) 
        {
          evt.w2list = read_line_to_vector( is );       
        }
      else if ( w == mc_keys::w3list_t) 
        {
          evt.w3list = read_line_to_vector( is );       
        }
      else if ( w == mc_keys::hourangle_t )
        {
          double ha;
          is >> ha;
          evt.setusr(mc_usr_keys::hourangle, ha );
        }
 
 
      else if ( w == mc_keys::center_on_can_t) 
        {
          // in corsika files, there is the (undocumented?) center_on_can tag,
          // which denoets the projection of the primary on the can. The direction
          // of the center_on_can 'track' is by defintion the direction of the
          // primary. We record the position in the usr data.
 
          vector<double> v = read_line_to_vector( is ); 
          if ( v.size() > 3 )
            {
              evt.setusr(mc_usr_keys::center_on_can_x, v[1] );
              evt.setusr(mc_usr_keys::center_on_can_y, v[2] );
              evt.setusr(mc_usr_keys::center_on_can_z, v[3] );
            }
        }
 
      else if ( w == mc_keys::muon_decay_t) 
        {
          // in km3sim files, there are additional tags, including this one
          vector<double> v = read_line_to_vector( is ); 
          if ( v.size() > 3 )
            {
              evt.setusr(mc_usr_keys::muon_decay_x, v[2] );
              evt.setusr(mc_usr_keys::muon_decay_y, v[3] );
              evt.setusr(mc_usr_keys::muon_decay_z, v[4] );
            }
        }
 
 
      else if ( w == mc_keys::end_event_t)
        {
          // finalize
 
          Trk none;
 
          if ( have_trk_primary_lepton )
            {
              Trk* p_primlep = 0 ;
 
              double min_edif = 1e100;
              for( auto& t: evt.mc_trks )
                {
                  if ( t.type != trk_primary_lepton.type ) continue;
 
                  // since we are reading ascii, we cannot demand an exact match
                  // in the floating point... so take the one that best matches
                  double edif = fabs( (t.E / trk_primary_lepton.E) -1 );
                  if (edif < min_edif )
                    {
                      min_edif = edif;
                      p_primlep = &t;
                    }
                }
 
              if ( p_primlep ) p_primlep -> comment =mc_keys:: primarylepton_t;
            }
 
 
          // If there is both a primary, and a neutrino, then the primary
          // will go second (mc_trks[1]) and the neutrino will be mc_trks[0].
          // The primarylepton tag is not stored as a seperate Trk.
 
          if ( have_trk_primary  )
            {
              trk_primary.id = 0;
              push_front( evt.mc_trks, trk_primary);
            }
 
          if ( have_trk_nu )
            {
              trk_nu.id = 0;
              push_front( evt.mc_trks, trk_nu);
            }
 
 
          return true;
        }
      else
        {
          //cout << "unknown tag " << w << endl;
          //cout << "previous = " << w_old << endl;
          is.ignore( 1000, '\n' );
        }
      w_old = w;
    }
 
  if (!is.eof()) 
    {
      THROW(Exception, "Error while reading ascii event" << w << ' ' << evt.id);
    }
 
  //else cout << "eof"<< endl;
  return false; 
}

write() [4/5]

bool write ( const Evt &  evt, std::ostream &  os  )

inline

Write event to a stream.

Parameters

evt	event
os	output stream

Returns

true if correctly read; else false

Definition at line 592 of file io_ascii.hh.

{
  using namespace std;
 
  os << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;
 
  for( auto& trk: evt.mc_trks )  write ( trk, os, mc_keys::auto_t );
  for( auto& trk: evt.trks    )  write ( trk, os, mc_keys::track_fit_t );
  for( auto& hit: evt.mc_hits )  write ( hit, os, mc_keys::hit_t);
  for( auto& hit: evt.hits    )  write ( hit, os, mc_keys::hit_raw_t);
 
  os << mc_keys::weights_t; for (auto&  w: evt.w      ) os << ' ' << w; os << endl;
  os << mc_keys::w2list_t;  for (auto&  w: evt.w2list ) os << ' ' << w; os << endl;
  os << mc_keys::w3list_t;  for (auto&  w: evt.w3list ) os << ' ' << w; os << endl;
  os << mc_keys::end_event_t << endl;
 
  return true;
}

read() [5/5]

bool read ( Head &  hdr, std::istream &  is  )

inline

Read header from a stream.

The stream may be positioned at any point before the tag mc_keys::start_run_t, which marks the beginning of the header. Information before the header (if any) is disgarded.

Parameters

hdr	header
is	input stream

Returns

true if correctly read; else false

Definition at line 624 of file io_ascii.hh.

{
  using namespace std;
 
  string line;
 
  bool start = false;
 
  while (getline( is, line ))
    {
      if ( io_stringutil::startswith(line, mc_keys::end_event_t))
        {
          break;
        }
 
      if ( io_stringutil::startswith(line, mc_keys::start_run_t))
        {
          start = true;
        }
 
      if ( io_stringutil::startswith(line, mc_keys::start_event_t))
        {
          // this should not happen:
          THROW(Exception, "Unexpected tag " << mc_keys::start_event_t << " found while reading header at " << line << " (could mean the evt file has no header)");
        }
 
      if (!start) continue; 
 
      vector<string> v = splitstring( line, ':' );
      if (v.size() < 2 )
        {
          THROW(Exception, "Invalid line found when reading header at " << line);
          continue;
        }
 
      // make sure key is unique
      string key = v[0];
      for (int i=1; hdr.find(key) != hdr.end() ; i++)
        {
          key = v[0]+"_"+to_string(i);
        }
 
      hdr[key] = io_stringutil::trim(v[1]);
    }
 
  if (!start)
    {
      THROW(Exception, "Reading of MC header terminated before finding a start_run: tag. Please check your file");
    }
 
  return start;
}

write() [5/5]

bool write ( const Head &  hdr, std::ostream &  os  )

inline

Write header to a stream.

Parameters

hdr	header
os	output stream

Returns

true if correctly written; else false

Definition at line 685 of file io_ascii.hh.

{
  hdr.print(os);
  return true;
}