io_ascii.hh File Reference

#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Exception.hh"
#include "km3net-dataformat/definitions/w2list_gseagen.hh"
#include "km3net-dataformat/definitions/trkmembers.hh"
#include "TDatabasePDG.h"

Go to the source code of this file.

Namespaces
namespace	mc_keys
namespace	mc_usr_keys
namespace	io_stringutil

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

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::track_bundle_t = "track_bundle:"
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::eventtime_t = "eventtime:"
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::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 111 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 125 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/4]

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 142 of file io_ascii.hh.

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

write() [1/4]

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 155 of file io_ascii.hh.

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

read() [2/4]

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 169 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;
  }
 
  // at this point, an additional pure_a and pure_t may be present,
  // but we do not read them.
 
  return !is.fail();
}

write() [2/4]

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 199 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; // not writing pure_a and pure_t
  }
  os << std::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 218 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, const T & value )

inline

Put value in front of data.

Parameters

vec	data
value	value

Definition at line 240 of file io_ascii.hh.

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

read() [3/4]

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 254 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;
  bool have_trk_nu(false), have_trk_primary(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     ||
                w == mc_keys::track_t        ||
                w == mc_keys::neutrino_t     ||
                w == mc_keys::track_bundle_t ||
                w == mc_keys::track_primary_t ) {
 
      t.id  = 0;
      t.len = 0.0;
      t.clearusr();
      t.comment = w;
      
      string line;
      getline( is, line );
      istringstream ii(line);
 
      if ( w != mc_keys::track_bundle_t ) {
        ii >> t.id;
      } else {
        ii >> t.len;
      }
      
      ii >> t.pos >> t.dir >> t.E;
 
      if (!ii.fail()) {
 
        if ( w == mc_keys::track_in_t) {
 
          t.status = TRK_ST_FINALSTATE;
        
          ii >> t.t >> t.type;
 
          if (!ii.fail()) {
        
            t.type = pdg_code( t.type );
        
            ii >> t.len;
        
            if ( ii.fail() ) { // missing length is not an error
              evt.mc_trks.push_back( t );
              continue;
            } 
 
            double eloss = 0;
            ii >> eloss;
        
            if ( ii.fail() ) { // missing eloss is not an error
              evt.mc_trks.push_back( t );
              continue;
            } 
 
            t.setusr( mc_usr_keys::energy_lost_in_can, eloss);
 
            evt.mc_trks.push_back( t );
          }
          
        } else if ( w == mc_keys::track_t ) {
 
          ii >> t.t;
        
          evt.trks.push_back( t );
          
        } else if ( w == mc_keys::neutrino_t ) {
 
          t.status = TRK_ST_PRIMARYNEUTRINO;
        
          // the last item we will read is W2LIST_GSEAGEN_CC, make enough space;
          if (evt.w2list.size() < W2LIST_GSEAGEN_CC+1 ) evt.w2list.resize(W2LIST_GSEAGEN_CC+1);
 
          ii >> t.t >>
            evt.w2list[W2LIST_GSEAGEN_BX]    >> 
            evt.w2list[W2LIST_GSEAGEN_BY]    >> 
            evt.w2list[W2LIST_GSEAGEN_ICHAN] >> 
            t.type                           >> 
            evt.w2list[W2LIST_GSEAGEN_CC];
 
          trk_nu = t;
          have_trk_nu = true;
          
        } else if ( w == mc_keys::track_primary_t ) {
        
          t.status = TRK_ST_PRIMARYCOSMIC;
        
          ii >> t.t >> trk_primary.type; // nucleus id (in pdg format or not?)
 
          trk_primary = t;
          have_trk_primary = true;
          
        } else if ( w == mc_keys::track_bundle_t ) {
 
          t.type   = PDG_MUONBUNDLE;
          t.status = TRK_ST_MUONBUNDLE;
 
          evt.mc_trks.push_back( t );
          
        } else {
          
          ostream& out = Exception::getOstream();
          out << "Unknown tag " << w << " for trk ";
          t.print(out);
          throw Exception(static_cast<ostringstream&>(out).str());
        }
      }
 
      if ( ii.fail() ) {
        ostream& out = Exception::getOstream();
        out << "Error reading trk ";
        t.print(out);
        throw Exception(static_cast<ostringstream&>(out).str());
      }
      
    } else if ( w == mc_keys::weights_t) {
      
      evt.w = read_line_to_vector( is );
      
    } else if ( w == mc_keys::w2list_t) {
      
      auto v = read_line_to_vector( is );
      evt.w2list.resize( std::max( evt.w2list.size(), v.size()));
      std::copy( v.begin(), v.end() , evt.w2list.begin() );
      
    } 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::eventtime_t ) {
      
      unsigned nsec, n16ns_ticks;
      is >> nsec >> n16ns_ticks;
      evt.mc_event_time.SetSec( nsec );
      evt.mc_event_time.SetNanoSec( n16ns_ticks * 16 );
      
    } 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() > 4 )
      {
        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 the mc_tracks -- as best we can.
 
      // If there is both a primary, and a neutrino, then the primary
      // will go second (mc_trks[1]) with id=-1 and the neutrino will
      // be mc_trks[0] with id=0. Unless they are same particle (identical
      // pos,dir,E); in that case the primary is skipped.
      // The primarylepton tag is not stored as a seperate Trk.
 
      if ( have_trk_primary && have_trk_nu ) {
        
        bool same = trk_nu.pos == trk_primary.pos &&
                    trk_nu.dir == trk_primary.dir &&
                    trk_nu.E   == trk_primary.E;
 
        if (!same) {
          trk_primary.id = -1;
          push_front( evt.mc_trks, trk_primary);
        }
 
        trk_nu.id = 0;
        push_front( evt.mc_trks, trk_nu);
        
      } else if ( have_trk_primary  ) {
        
        trk_primary.id = 0;
        push_front( evt.mc_trks, trk_primary);
        
      } else if ( have_trk_nu ) {
        
        trk_nu.id = 0;
        push_front( evt.mc_trks, trk_nu);
      }
 
      return true;
      
    } else {
      is.ignore( 1000, '\n' );
    }
    
    w_old = w;
  }
 
  if (!is.eof()) {
    THROW(Exception, "Error while reading ascii event" << w << ' ' << evt.id);
  }
 
  return false;
}

write() [3/4]

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 521 of file io_ascii.hh.

{
  using namespace std;
 
  // set precision to 12 digits.
  const int precision = 12;
  auto old_flags = os.flags();
  auto old_precision = os.precision( precision );
  os.unsetf( std::ios_base::scientific | std::ios_base::fixed ); // default behaviour
 
  os << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;
 
  for ( auto& trk : evt.mc_trks ) {
    
    const std::string& tag = trk.comment;
 
    os <<  tag                                                << ' '
       << (tag != mc_keys::track_bundle_t ? trk.id : trk.len) << ' '
       << trk.pos                                             << ' '
       << trk.dir                                             << ' '
       << trk.E;
    
    if ( tag == mc_keys::track_in_t ) {
      
      os << ' ' << trk.t << ' ' << geant3_code(trk.type) << ' ' << trk.len;
 
      if ( trk.haveusr( mc_usr_keys::energy_lost_in_can ) ) {
        os << ' ' << trk.getusr( mc_usr_keys::energy_lost_in_can );
      }
 
      os << endl;
      
    } else if ( tag == mc_keys::track_primary_t ) {
 
      os << ' ' << trk.t << ' ' << trk.type << endl;
      
    } else if ( tag == mc_keys::neutrino_t ) {
 
      double bx(0), by(0);
      int ichan(0), cc(0);
 
      if ( evt.w2list.size() > W2LIST_GSEAGEN_CC ) {
        bx    = evt.w2list[W2LIST_GSEAGEN_BX];
        by    = evt.w2list[W2LIST_GSEAGEN_BY];
        ichan = evt.w2list[W2LIST_GSEAGEN_ICHAN];
        cc    = evt.w2list[W2LIST_GSEAGEN_CC];
      }
 
      os << ' ' << trk.t
         << ' ' << bx
         << ' ' << by
         << ' ' << ichan
         << ' ' << trk.type
         << ' ' << cc
         << endl;
      
    } else {
 
      os << endl;
    }
  }
  
  for ( auto& trk : evt.trks    ) {
    os << mc_keys::track_fit_t << ' ' << trk.id << ' ' << trk.pos << ' ' << trk.dir << ' ' << trk.E << ' ' << trk.t << endl;
  }
  
  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::eventtime_t << evt.mc_event_time.GetSec() << " "
     << evt.mc_event_time.GetNanoSec() / 16 << endl;
 
  os << mc_keys::end_event_t << endl;
 
  // restore os to how we found it.
  os.flags( old_flags );
  os.precision( old_precision );
 
  return true;
}

read() [4/4]

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 619 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))
    {
      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 )
    {
      std::cout << "Warning: line with empty tag found when reading header" << endl;
      std::cout << "        "<< line << endl;
      std::cout << "         will be skipped" << endl;
      continue;
    }
 
    // the following with unsure key in the map is unique by adding _1 _2 etc.
    hdr.set_line( io_stringutil::trim(v[0]), 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() [4/4]

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 676 of file io_ascii.hh.

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