TTTRHeader.h

Go to the documentation of this file.

#ifndef TTTRLIB_READHEADER_H
#define TTTRLIB_READHEADER_H
 
#include <stdlib.h>     /* malloc, calloc, realloc, exit, free */
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath> /* floor, ceil */
#include <string>
#include <string.h> /* strcmp */
#include <algorithm>
#include <vector>
#include <array>
#include <memory>
#include <numeric>
#include <iostream>
#include <sstream>      // std::stringstream
#include <iomanip> /* std::setfill */
#include <fstream> /* ifstream */
 
#include <any>
// #include <boost/any.hpp>
//#include <boost/filesystem.hpp>
//#include <boost/locale.hpp>
 
#include "json.hpp"
 
#include "Histogram.h"
#include "TTTRRecordReader.h"
#include "TTTRRecordTypes.h"
#include "TTTRHeaderTypes.h"
 
// some important Tag Idents (TTagHead.Ident) that we will need to read the most common content of a PTU file
// check the output of this program and consult the tag dictionary if you need more
const std::string TTTRTagRes = "MeasDesc_Resolution";              // Resolution for the Dtime (T3 Only) - in seconds
const std::string TTTRTagGlobRes = "MeasDesc_GlobalResolution";    // Global Resolution of TimeTag(T2) /NSync (T3) - in seconds
const std::string TTTRSyncRate = "SyncRate";                       // SyncRate - in Hz
const std::string TTTRNMicroTimes = "MeasDesc_NumberMicrotimes";   // The number of micro time channels
const std::string TTTRRecordType = "MeasDesc_RecordType";         // Internal record type (see tttrlib record type identifier definitions)
const std::string TTTRContainerType = "MeasDesc_ContainerType";   // Internal container type (see tttrlib record type identifier definitions)
const std::string TTTRTagTTTRRecType = "TTResultFormat_TTTRRecType";
const std::string TTTRTagBits = "TTResultFormat_BitsPerRecord";    // Bits per TTTR record
const std::string FileTagEnd = "Header_End";                       // Always appended as last tag (BLOCKEND)
 
 
class TTTRHeader {
 
    friend class TTTR;
 
protected:
 
    // JSON object used to store all the header information
    nlohmann::json json_data;
 
    size_t header_end = 0;
 
public:
 
    int get_tttr_record_type(){
        return (int) json_data[TTTRRecordType];
    }
 
    void set_tttr_record_type(int v){
        json_data[TTTRRecordType] = v;
    }
 
    int get_tttr_container_type(){
        return (int) json_data[TTTRContainerType];
    }
 
    void set_tttr_container_type(int v){
        json_data[TTTRContainerType] = v;
    }
 
    static nlohmann::json get_tag(
            nlohmann::json json_data,
            const std::string &name,
            int idx = -1
    );
 
    static int find_tag(
        nlohmann::json &json_data,
        const std::string &name,
        int idx = -1
    );
 
    static void add_tag(
            nlohmann::json &json_data,
            const std::string &name,
            std::any value,
            // boost::any value,
            unsigned int type = tyAnsiString,
            int idx = -1
    );
 
    size_t get_bytes_per_record(){
        return (size_t) get_tag(json_data, TTTRTagBits)["value"] / 8;
    }
 
    size_t end() const{
        return header_end;
    }
 
    size_t size(){
        return json_data["tags"].size();
    }
 
    nlohmann::json& operator[](std::size_t idx){
        return json_data["tags"][idx];
    }
 
    const nlohmann::json& operator[](std::size_t idx) const {
        return json_data["tags"][idx];
    }
 
     unsigned int get_number_of_micro_time_channels(){
        return (unsigned int) get_tag(json_data, TTTRNMicroTimes)["value"];
     }
 
    double get_macro_time_resolution();
 
    double get_micro_time_resolution(){
        return get_tag(json_data, TTTRTagRes)["value"];
    }
 
    int get_pixel_duration(){
        double pixel_duration_d = TTTRHeader::get_tag(
                json_data, "$TimePerPixel")["value"];
        double global_res = TTTRHeader::get_tag(
                json_data, "MeasDesc_GlobalResolution")["value"];
        long pixel_duration = std::round(pixel_duration_d / global_res);
        return pixel_duration;
    }
 
    int get_line_duration(){
        double pixel_duration_d = TTTRHeader::get_tag(
                json_data, "$TimePerPixel")["value"];
        double global_res_d = TTTRHeader::get_tag(
                json_data, "MeasDesc_GlobalResolution")["value"];
        double n_pixel = TTTRHeader::get_tag(json_data, "ImgHdr_PixX")["value"];
        return std::ceil((pixel_duration_d * n_pixel) / global_res_d);
    }
 
    unsigned int get_effective_number_of_micro_time_channels(){
        double macro_time_resolution = get_macro_time_resolution();
        double micro_time_resolution = get_micro_time_resolution();
        return (unsigned int) std::floor(macro_time_resolution / micro_time_resolution);
    }
 
    TTTRHeader();
    TTTRHeader(int tttr_container_type);
 
    TTTRHeader(const TTTRHeader &p2);
 
    TTTRHeader(std::FILE *fpin, int tttr_container_type=0, bool close_file=false);
    TTTRHeader(std::string fn, int tttr_container_type=0);
    ~TTTRHeader() = default;
 
    static size_t read_ptu_header(
            std::FILE *fpin,
            int &tttr_record_type,
            nlohmann::json &json_data,
            bool rewind = true
    );
 
    static size_t read_ht3_header(
            std::FILE *fpin,
            nlohmann::json &data,
            bool rewind = true
    );
 
    static size_t read_bh132_header(
            std::FILE *fpin,
            nlohmann::json &data,
            bool rewind = true
    );
 
    static size_t read_cz_confocor3_header(
            std::FILE *fpin,
            nlohmann::json &data,
            bool rewind = true
    );
 
    static void write_spc132_header(
            std::string fn,
            TTTRHeader* header,
            std::string modes = "w"
    );
 
    static void write_ptu_header(
            std::string fn,
            TTTRHeader* header,
            std::string modes = "wb"
    );
 
    static void write_ht3_header(
            std::string fn,
            TTTRHeader* header,
            std::string modes = "wb"
    );
 
    std::string get_json(std::string tag_name="", int idx=-1, int indent=1);
 
    void set_json(std::string json_string){
        json_data = nlohmann::json::parse(json_string);
    }
 
};
 
 
#endif //TTTRLIB_READHEADER_H