tally.h

#ifndef PYNE_IQ4M73STINHJDPRV6KWUZZXOYE
#define PYNE_IQ4M73STINHJDPRV6KWUZZXOYE

#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <string>

#ifndef PYNE_IS_AMALGAMATED
  #include "h5wrap.h"
  #include "utils.h"
#endif


namespace pyne
{
  // simplifying implementation...
  using std::vector;
  // default empty parameters for constructors
  const vector<double> null_v_dbl;
  const vector<int> null_v_int;
  
  class Tally 
  {
  public:
    std::map<std::string, std::string> rx2fluka;
    std::map<std::string, std::string> rx2mcnp5;
    std::map<std::string, std::string> rx2mcnp6;

    Tally (); 

    Tally(std::string type, std::string particle_name, int entity,
          std::string entity_type, std::string entity_name,
          std::string tally_name = "", double entity_size = 0.0, 
          double normalization = 1.0);
    
    Tally(std::string type, std::vector<std::string> part_names, int entity,
          std::string entity_type, std::string entity_name,
          std::string tally_name = "", double entity_size = 0.0, 
          double normalization = 1.0);
 
    Tally(std::string particle_name, std::string entity_geom, vector<double> orgn,
    vector<double> i_mesh, vector<double> j_mesh, vector<double> k_mesh,
    vector<int> i_ints = null_v_int, 
    vector<int> j_ints = null_v_int, 
    vector<int> k_ints = null_v_int, 
    vector<double> e_bounds = null_v_dbl, vector<int> e_ints = null_v_int,
    vector<double> axs =null_v_dbl, vector<double> vec = null_v_dbl,
    std::string tally_name = "", double norm = 1.0);

    ~Tally();  
 
    // Create hdf5 datatable for tallies
    hid_t create_dataspace(hid_t file, std::string datapath);

    // create filetype of data
    hid_t create_filetype();

    // create memory type for tally struct
    hid_t create_memtype();

    void from_hdf5(char* filename, char* datapath, int row = -1);

    void from_hdf5(std::string filename, std::string datapath, int row = -1);

    void write_hdf5(char* filename, char* datapath);

    void write_hdf5(std::string filename, std::string datapath);

    // mcnp tally
    std::string mcnp(int tally_index = 1, std::string mcnp_version = "mcnp5",
                     std::string out = "");

    template<typename T> bool is_zero(T vect);

    // Form the mcnp tally line as function of its properties
    std::string form_mcnp_tally(int tally_index, int type,
                                std::string particle_token, int entity_id,
                                double entity_size, double normalization);
    // Form the mesh tally line as function of its properties
    std::string form_mcnp_meshtally(
        int tally_index, std::string particle_token, std::string entity_geometry,
        std::vector<double> axs, std::vector<double> vec,
        std::vector<double> origin, std::vector<double> meshes[3],
        std::vector<int> ints[3], std::vector<double> e_bounds,
        std::vector<int> e_ints, std::string out);
    
    // fluka tally
    std::string fluka(std::string unit_number = "-21");

    std::string entity_type;   
    std::string entity_name;   
    std::vector<std::string> particle_names; 
    std::string tally_type;    
    std::string tally_name;    
    int entity_id;             
    double entity_size;        
    double normalization;      

    std::string entity_geometry;   
    std::vector<double> origin;    
    std::vector<double> vec;       
    std::vector<double> axs;       
    std::vector<double> meshes[3]; 
    std::vector<int> ints[3];      
    std::vector<double> e_bounds;  
    std::vector<int> e_ints;       
  };

  std::ostream& operator<< (std::ostream& os, Tally tally);


  typedef struct tally_struct {
    int entity_id;
    int entity_type;
    int tally_type;
    const char* particle_name;
    const char* entity_name;
    const char* tally_name;
    double entity_size;
    double normalization;
  } tally_struct;

// End pyne namespace
}

#endif