WriterCompressedAscii.hh

// -*- C++ -*-
//
// This file is part of HepMC
// Copyright (C) 2014-2019 The HepMC collaboration (see AUTHORS for details)
//
#ifndef HEPMC3_WRITERCOMPRESSEDASCII_H
#define HEPMC3_WRITERCOMPRESSEDASCII_H
#include "Rivet/Tools/RivetHepMC.hh"
#include "HepMC3/Writer.h"
#include "HepMC3/GenEvent.h"
#include "HepMC3/GenRunInfo.h"
#include <string>
#include <fstream>
 
namespace Rivet {
 
class WriterCompressedAscii : public HepMC3::Writer {
 
public:
 
  typedef HepMC3::GenRunInfo GenRunInfo;
  typedef HepMC3::FourVector FourVector;
  typedef HepMC3::ConstGenVertexPtr ConstGenVertexPtr;
  typedef HepMC3::ConstGenParticlePtr ConstGenParticlePtr;
 
  WriterCompressedAscii(const std::string& filename,
                        shared_ptr<GenRunInfo> run = shared_ptr<GenRunInfo>());
 
  WriterCompressedAscii(std::ostream& stream,
                        shared_ptr<GenRunInfo> run = shared_ptr<GenRunInfo>());
  
  ~WriterCompressedAscii();
 
  void write_event(const GenEvent& evt);
 
  void write_run_info();
 
  bool failed() { return (bool)m_file.rdstate(); }
 
  void close();
 
  void use_doubles() {
    m_use_integers = false;
  }
 
  void use_integers() {
    m_use_integers = true;
  }
 
  void add_stripid(long pdgid) {
    m_stripid.insert(pdgid);
  }
 
  void strip(GenEvent & e);
 
    void set_precision(int prec) {
        m_precision = prec;
    }
 
    void set_precision_phi(double prec) {
        m_precision_phi = prec;
    }
 
    void set_precision_eta(double prec) {
        m_precision_eta = prec;
    }
 
    void set_precision_e(double prec) {
        m_precision_e = prec;
    }
 
    void set_precision_m(double prec) {
        m_precision_m = prec;
    }
 
    int precision() const {
      return m_precision;
    }
 
    double precision_phi() const {
      return m_precision_phi;
    }
 
    double precision_eta() const {
      return m_precision_eta;
    }
 
    double precision_e() const {
      return m_precision_e;
    }
 
    double precision_m() const {
      return m_precision_m;
    }
 
    double psrap(const FourVector & p) const;
 
private:
 
    std::string escape(const std::string& s)  const;
 
 
 
 
 
    void write_position(FourVector pos);
 
    void write_momentum(FourVector p);
 
    void write_mass(ConstGenParticlePtr p);
 
    void write_vertex(ConstGenVertexPtr v);
 
  void write_particle(ConstGenParticlePtr p);
 
    ConstGenVertexPtr rootvertex() {
      vector<ConstGenParticlePtr> beams = m_current->beams();
      if ( beams.empty() ) return ConstGenVertexPtr();
      return beams[0]->production_vertex();
    }
 
private:
 
  bool m_use_integers;        
 
  std::ofstream m_file;       
  std::ostream* m_stream;     
 
  double m_precision_phi;     
  double m_precision_eta;     
  double m_precision_e;       
  double m_precision_m;       
  int m_precision;            
  set<long> m_stripid;        
  map<long,long> m_masses;    
 
  const GenEvent * m_current; 
  std::ostringstream os;      
 
};
 
 
} // namespace HepMC3
 
#endif