nexuswriter.h

Go to the documentation of this file.

#ifndef NEXUSWRITER_H
#define NEXUSWRITER_H

typedef void (*nx_error_t)(void* arg, char* text);

#include "napi.h"
#include "NeXusFile.hpp"
#include "NeXusStream.hpp"

#include "selogger.h"

extern const char* detector_base;
extern const char* detector_format;

class IXNeXusFile : public ISIS::Base
{
        NXhandle m_fileid;
    int m_options;
        int m_compression_type;
        int m_spectra_chunk;
        nx_error_t m_error_func;
        void* m_error_arg;

public:

        int clone(const IXNeXusFile& orig);
        IXNeXusFile* clone();

        int flush()
        {
                return NXflush(&m_fileid);
        }

        template<typename T>
        int writeData(const char* data_name, const std::vector<T>& value)
        {
                if (value.size() > 0)
                {
                        return writeData(data_name, &(value[0]), static_cast<int>(value.size()));
                }
                else
                {
                        return writeData(data_name, static_cast<T*>(NULL), 0);
                }
        }

        static bool string_len_lt(const std::string& s1, const std::string& s2)
        {
                return s1.size() < s2.size();
        }

        template<>
        int writeData(const char* data_name, const std::vector<std::string>& value)
        {
                int dims_array[2];
                std::vector<std::string>::const_iterator it = std::max_element(value.begin(), value.end(), string_len_lt);
                if (value.size() > 0 && it != value.end())
                {
                        dims_array[0] = static_cast<int>(value.size());
                        dims_array[1] = static_cast<int>(it->size());
                        int n = dims_array[0] * dims_array[1];
                        char* char_array = new char[n];
                        memset(char_array, ' ', n);
                        for(int i=0; i<dims_array[0]; i++)
                        {
                                strncpy(char_array + i * dims_array[1], value[i].c_str(), value[i].size());  
                        }
                        writeData(data_name, char_array, dims_array[0], dims_array[1]);
                        delete[] char_array;
                        return 0;
                }
                else
                {
                        return 0;
                }
        }


        enum Options { None = 0x0, WriteDummyOnNULL = 0x1, Read = 0x2, Write = 0x4, HDF4 = 0x8, HDF5 = 0x10, Update = 0x20 };
        enum NXReturnCodes { OK = NX_OK, Error = NX_ERROR };
        IXNeXusFile(nx_error_t error_func = NULL, void* error_arg = NULL);
        void setErrorReporter(nx_error_t error_func, void* error_arg);
        int open(const char* filename, int mode, int type = IXNeXusFile::HDF5);
        int close();
        int closeData() { return NXclosedata(m_fileid); }
        int openData(const char* name) { return NXopendata(m_fileid, name); }
        int getLink(const char* name, const char* nxclass, NXlink& link);
        int makeLink(const char* name, const char* nxclass, NXlink& link);
        int getLink(const char* name, NXlink& link) { return getLink(name, NULL, link); }
        int makeLink(const char* name, NXlink& link) { return makeLink(name, NULL, link); }
        int writeData(const char* data_name, int value);
        int writeData(const char* data_name, unsigned value) { return writeData(data_name, (int)value); }   
        int writeData(const char* data_name, long value) { return writeData(data_name, (int)value); }
        int writeData(const char* data_name, unsigned long value) { return writeData(data_name, (long)value); }  
        int writeData(const char* data_name, float value);
        int writeData(const char* data_name, double value);
        int writeData(const char* data_name, int64_t value);
        int writeData(const char* data_name, uint64_t value);
        int writeData(const std::string& data_name, const std::string& value)
        {
                return writeData(data_name.c_str(), value.c_str());
        }
        int writeAttribute(const std::string& data_name, const std::string& attr_name, const std::string& value)
        {
                return writeAttribute(data_name.c_str(), attr_name.c_str(), value.c_str());
        }

        int writeAttribute(const char* data_name, const char* attr_name, int value);
        int writeAttribute(const char* data_name, const char* attr_name, float value);
        int writeAttribute(const char* data_name, const char* attr_name, double value);
        int writeData(const char* data_name, const int64_t* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const uint64_t* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const int* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const unsigned int* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const float* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const double* value, const int* dims_array, int ndims);
        int writeData(const char* data_name, const int64_t* value, int len);
        int writeData(const char* data_name, const uint64_t* value, int len);
        int writeData(const char* data_name, const int* value, int len);
        int writeData(const char* data_name, const unsigned int* value, int len);
        int writeData(const char* data_name, const float* value, int len);
        int writeData(const char* data_name, const double* value, int len);
        int writeData(const char* data_name, const int* value, int dim1, int dim2);
        int writeData(const char* data_name, const unsigned long* value, int dim1, int dim2) { return writeData(data_name, (const int*)value, dim1, dim2); }
        int writeData(const char* data_name, const float* value, int dim1, int dim2);
        int writeData(const char* data_name, const double* value, int dim1, int dim2);
        int writeData(const char* data_name, const char* value);
        int writeData(const char* data_name, const char* value, int len);
        int writeData(const char* data_name, const char* value, int dim1, int dim2);
        int makeData(const char* data_name, int nxtype, const int* dims_array, int ndims);
        int makeDataChunked(const char* data_name, int nxtype, const int* dims_array, const int* chunk_array, int ndims);
        int writeSlabList(const char* data_name, const unsigned long* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const std::vector<int>& slab_list);
        int addSlabList(const char* data_name, const unsigned long* value, const int* dims_array, int ndims, int dest_start[], const int* slab_start, const int* slab_size, const std::vector<int>& slab_list);
        int makeDataSlab(const char* data_name, const unsigned long* value, const int* dims_array, int ndims);
        int writeSlab(const char* data_name, const int* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size);
        int writeSlab(const char* data_name, const unsigned long* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size) { return writeSlab(data_name, (const int*)value, dims_array, ndims, slab_start, slab_size); }
        int addSlab(const char* data_name, const int* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const char* data_name, const unsigned long* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const char* data_name, const float* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const int* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const unsigned long* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const float* value, const int* dims_array, int ndims, const int* slab_start, const int* slab_size, const int* dest_start);
        int addSlab(const int* value, const int64_t* dims_array, int ndims, const int64_t* slab_start, const int64_t* slab_size, const int64_t* dest_start);
        int addSlab(const float* value, const int64_t* dims_array, int ndims, const int64_t* slab_start, const int64_t* slab_size, const int64_t* dest_start);
        int writeAttribute(const char* data_name, const char* attr_name, const int* value, int len);
        int writeAttribute(const char* data_name, const char* attr_name, const float* value, int len);
        int writeAttribute(const char* data_name, const char* attr_name, const double* value, int len);
        int writeAttribute(const char* data_name, const char* attr_name, const char* value, int len);
        int writeAttribute(const char* data_name, const char* attr_name, const char* value);
        int addLog(const char* nxname, const char* filename, 
                                          const char* log_name, const char* log_units, time_t ref_time);
        template<typename T>
        int addLog(const char* nxname, const std::vector<T>& values, const char* value_units,
                                          const std::vector<float>& time, const char* time_units, time_t ref_time);

//      int writeMuonFile(const char* filename, const ISISCRPT_STRUCT* crpt);
        int makeNewGroup(const char* name, const char* nxclass, bool open_group = true);
        int makeNewGroup(const std::string& name, const std::string& nxclass, bool open_group = true) { return makeNewGroup(name.c_str(), nxclass.c_str(), open_group); }

        int closeGroup();
        const char* ISOtime(time_t time);
        time_t unixTime(const char* isotime);
        int enableOptions(Options options) { return (m_options |= options); }
        void setSpectraChunkSize(int nsp) { m_spectra_chunk = nsp; }
        void enableCompression(int comp_level = NX_COMP_LZW) { m_compression_type = comp_level; } 
        void disableCompression() { m_compression_type = NX_COMP_NONE; } 
        bool testOptions(Options options) { return ((m_options & options) != 0); }

        int readData(const char* data_name, std::string& value);
        int readData(const char* data_name, int& value);
        int readData(const char* data_name, float& value);
        int listEntries(std::list<std::string>& entries, bool groups_only = false);
        int openGroup(const char* group_name, const char* group_class); 
        NXhandle fileid() { return m_fileid; }
};

class ISISRAW;
struct ISISCRPT_STRUCT;

class NeXusWriter : public ISIS::Base
{
public:
        NeXusWriter() : Base("NeXusWriter") , m_run_number_digits(8) { }
        void setRunNumberDigits(int digits)  { m_run_number_digits = digits; }
        int writeMuonFile(const char* filename, const ISISCRPT_STRUCT* crpt, const isisU32_t* raw_data, isisU32_t raw_data_size, const seblock_map_t& blocks, const Poco::Path& inst_settings_dir, const std::string& inst_xml_file, const std::string& inst_parameter_map_file, DAEstatus& dstatus);
        int writeISISNeXus(const char* filename, bool logs_only, const ISISCRPT_STRUCT* crpt, const isisU32_t* raw_data, isisU32_t raw_data_size, const ISISRAW* iraw, const seblock_map_t& blocks, const std::string& inst_xml_file, const std::string& inst_parameter_map_file, DAEstatus& dstatus, bool update = false);
        int writeISISNeXus(const char* filename, bool logs_only, const ISISCRPT_STRUCT* crpt, const isisU32_t* raw_data, isisU32_t raw_data_size, const ISISRAW* iraw, const seblock_map_t& blocks, const std::string& events_nxfile, const std::string& inst_xml_file, const std::string& inst_parameter_map_file, DAEstatus& dstatus);
        int addMissingMuonLogs(const char* filename, const char* logs_path, const char* new_comment, const char* new_sample_name, DAEstatus& dstatus);
private:
        static void readExternalFile(const std::string& file_name, std::string& file_contents);
        int m_run_number_digits;
        NeXusWriter(const NeXusWriter&) { }
};

template <typename T>
class NXlogWriter : public ISIS::Base
{
private:
        time_t m_offset;
        std::string m_value_units;
        std::vector<float> m_time;
        std::vector<T> m_value;
public:
        NXlogWriter(const std::string& value_units, time_t offset) : m_offset(offset), m_value_units(value_units) { setLoggerName("NXlogWriter"); }
        void addValue(float time, T value) { m_time.push_back(time); m_value.push_back(value); }
        void write(IXNeXusFile* file, const std::string& name) { file->addLog(name.c_str(), m_value, m_value_units.c_str(), m_time, "second", m_offset); }
        void setOffset(time_t offset) { m_offset = offset; }
};

#endif /* NEXUSWRITER_H */