#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"

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, Evt &evt, std::istream &is, const std::string &tag=mc_keys::track_in_t)
	Read track from a stream. More...

bool	write (const Trk &t, const Evt &evt, 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::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

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 );
 }

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 );
 }

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();
 }

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();
 }

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

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 198 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();
 }

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

inline

Read track from a stream.

Parameters

t	track
evt	event (for storing nu info in w2list)
is	input stream
tag	tag

Returns: true if correctly read; else false

Definition at line 220 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)
   {
     t.status = TRK_ST_FINALSTATE;
     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
 
     t.setusr( mc_usr_keys::energy_lost_in_can, eloss);
   }
 
   if ( tag == 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 >> evt.w2list[W2LIST_GSEAGEN_BX] >> 
     evt.w2list[W2LIST_GSEAGEN_BY] >> 
     evt.w2list[W2LIST_GSEAGEN_ICHAN] >> 
     t.type >> 
     evt.w2list[W2LIST_GSEAGEN_CC];
   }
 
   if ( tag == mc_keys::track_primary_t )
   {
     t.status = TRK_ST_PRIMARYCOSMIC;
     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();
 }

bool write	(	const Trk &	t,
		const Evt &	evt,
		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 291 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::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 << ' ' << bx
        << ' ' << by
        << ' ' << ichan
        << ' ' << t.type
        << ' ' << cc
        << endl;
   }
 
   else
     os << endl;
 
   return !os.fail();
 }

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

inline

Read data.

Parameters

is	input stream

Returns: data

Definition at line 354 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;
 }

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

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

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 390 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 )
     {
       read( t, evt, is , w);
       evt.mc_trks.push_back( t );
     }
     else if ( w == mc_keys::track_t )
     {
       read( t, evt, is );
       evt.trks.push_back( t );
     }
     else if ( w == mc_keys::neutrino_t)
     {
       read( trk_nu , evt, is,  w );
       have_trk_nu = true;
     }
     else if ( w == mc_keys::track_primary_t)
     {
       read( trk_primary, evt, 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)
     {
       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;
 }

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 583 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 )  write ( trk, evt, os, mc_keys::auto_t );
   for ( auto& trk : evt.trks    )  write ( trk, evt, 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::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;
 }

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 631 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;
 }

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

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

Namespaces

Functions

Variables

Function Documentation