DataFormatUtils.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Device/IO/DataFormatUtils.cpp
//! @brief     Implements class DataFormatUtils.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "Device/IO/DataFormatUtils.h"
#include "Base/Axis/ConstKBinAxis.h"
#include "Base/Axis/CustomBinAxis.h"
#include "Base/Axis/FixedBinAxis.h"
#include "Base/Axis/PointwiseAxis.h"
#include "Base/Util/FileSystemUtils.h"
#include "Base/Util/StringUtils.h"
#include "Device/Data/Datafield.h"
#include <functional>
#include <iostream>
#include <iterator>
 
namespace {
 
using createAxisFun = std::function<IAxis*(std::istringstream iss)>;
 
const std::string GzipExtension = ".gz";
const std::string BzipExtension = ".bz2";
const std::string IntExtension = ".int";
const std::string NicosExtension = ".001";
const std::string TiffExtension = ".tif";
const std::string TiffExtension2 = ".tiff";
 
std::istringstream getAxisStringRepresentation(std::istream& input_stream)
{
    std::string line;
    std::getline(input_stream, line);
    const std::vector<std::string> to_replace = {",", "\"", "(", ")", "[", "]"};
    BaseUtils::String::replaceItemsFromString(line, to_replace, " ");
    return std::istringstream(line);
}
 
std::string uncompressedFilename(const std::string& name)
{
    if (DataUtils::Format::isGZipped(name))
        return name.substr(0, name.size() - GzipExtension.size());
    if (DataUtils::Format::isBZipped(name))
        return name.substr(0, name.size() - BzipExtension.size());
    return name;
}
 
 
//! Creates one of FixedBinAxis from string representation
//! FixedBinAxis("axis0", 10, -1, 1)
//! ConstKBinAxis("axis0", 10, -1, 1)
//! CustomBinAxis("axis0", 10, -1, 1)
template <class Axis>
IAxis* createFixedBinLikeAxis(std::istringstream iss)
{
    std::string name;
    size_t nbins(0);
    if (!(iss >> name >> nbins))
        throw std::runtime_error("createFixedBinLikeAxis() -> Error. Can't parse the string.");
 
    std::vector<double> boundaries;
    DataUtils::Format::readLineOfDoubles(boundaries, iss);
    if (boundaries.size() != 2)
        throw std::runtime_error("Error in createFixedBinLikeAxis: Can't parse the string while "
                                 "reading boundaries.");
 
    return new Axis(name, nbins, boundaries[0], boundaries[1]);
}
 
//! Creates VariableBinAxis from string representation
//! VariableBinAxis("axis0", 4, [-1, -0.5, 0.5, 1, 2])
IAxis* createVariableBinAxis(std::istringstream iss)
{
    std::string name;
    size_t nbins(0);
    if (!(iss >> name >> nbins))
        throw std::runtime_error("Error in createVariableBinAxis: Can't parse the string.");
 
    std::vector<double> boundaries;
    DataUtils::Format::readLineOfDoubles(boundaries, iss);
    if (boundaries.size() != nbins + 1)
        throw std::runtime_error(
            "Error in createVariableBinAxis: wrong number of boundaries read.");
 
    return new VariableBinAxis(name, boundaries);
}
 
//! Creates createPointwiseAxis from string representation
//! PointwiseAxis("axis0", [-0.5, 0.5, 1, 2])
IAxis* createPointwiseAxis(std::istringstream iss)
{
    std::string name;
    if (!(iss >> name))
        throw std::runtime_error("Error in createPointwiseAxis:Can't parse the string.");
 
    std::vector<double> coordinates;
    DataUtils::Format::readLineOfDoubles(coordinates, iss);
 
    return new PointwiseAxis(name, coordinates);
}
 
const std::vector<std::pair<std::string, createAxisFun>> type_map = {
    {"ConstKBinAxis", createFixedBinLikeAxis<ConstKBinAxis>},
    {"CustomBinAxis", createFixedBinLikeAxis<CustomBinAxis>},
    {"FixedBinAxis", createFixedBinLikeAxis<FixedBinAxis>},
    {"PointwiseAxis", createPointwiseAxis},
    {"VariableBinAxis", createVariableBinAxis}};
 
} // namespace
 
 
bool DataUtils::Format::isCompressed(const std::string& name)
{
    return isGZipped(name) || isBZipped(name);
}
 
//! Does name contain *.gz extension?
 
bool DataUtils::Format::isGZipped(const std::string& name)
{
    return BaseUtils::Filesystem::hasExtension(name, GzipExtension);
}
 
bool DataUtils::Format::isBZipped(const std::string& name)
{
    return BaseUtils::Filesystem::hasExtension(name, BzipExtension);
}
 
bool DataUtils::Format::isIntFile(const std::string& file_name)
{
    return BaseUtils::Filesystem::hasExtension(uncompressedFilename(file_name), IntExtension);
}
 
bool DataUtils::Format::isNicosFile(const std::string& file_name)
{
    return BaseUtils::Filesystem::hasExtension(uncompressedFilename(file_name), NicosExtension);
}
 
bool DataUtils::Format::isTiffFile(const std::string& file_name)
{
    return BaseUtils::Filesystem::hasExtension(uncompressedFilename(file_name), TiffExtension)
           || BaseUtils::Filesystem::hasExtension(uncompressedFilename(file_name), TiffExtension2);
}
 
//! Creates axis of certain type from input stream
IAxis* DataUtils::Format::createAxis(std::istream& input_stream)
{
    auto iss = getAxisStringRepresentation(input_stream);
    std::string type;
    if (!(iss >> type))
        throw std::runtime_error(
            "Error in DataUtils::Format::createAxis:: couldn't read axis type from input");
 
    for (auto iter = type_map.cbegin(); iter != type_map.end(); ++iter)
        if (iter->first == type)
            return iter->second(std::move(iss));
    throw std::runtime_error("Error in DataUtils::Format::createAxis:"
                             "Unknown axis type '"
                             + type + "'");
}
 
//! Fills output data raw buffer from input stream
void DataUtils::Format::fillDatafield(Datafield* data, std::istream& input_stream)
{
    std::string line;
    size_t iout = 0;
    while (std::getline(input_stream, line)) {
        if (line.empty() || line[0] == '#')
            break;
        std::istringstream iss(line);
        std::vector<double> buffer;
        readLineOfDoubles(buffer, iss);
        for (auto value : buffer)
            (*data)[iout++] = value;
    }
    if (iout != data->size())
        throw std::runtime_error("Error while parsing data, did not reach expected end");
}
 
//! Parse double values from string to vector of double
 
// #migration +++ this works only if separator is space or tab; it does not work e.g. with comma or
// semicolon
std::vector<double> DataUtils::Format::parse_doubles(const std::string& str)
{
    std::vector<double> result;
    std::istringstream iss(str);
    DataUtils::Format::readLineOfDoubles(result, iss);
    if (result.empty()) {
        std::string out = str;
        const size_t max_string_length(10);
        if (out.size() > max_string_length)
            out.resize(max_string_length, ' ');
        out += " ...";
        throw std::runtime_error("DataUtils::Format::parse_doubles -> Error! Can't parse double "
                                 "values from a string '"
                                 + out + "'");
    }
    return result;
}
 
// #migration +++ this works only if separator is space or tab; it does not work e.g. with comma or
// semicolon
void DataUtils::Format::readLineOfDoubles(std::vector<double>& buffer, std::istringstream& iss)
{
    iss.imbue(std::locale::classic());
    std::copy(std::istream_iterator<double>(iss), std::istream_iterator<double>(),
              back_inserter(buffer));
}