IOFactory.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Device/IO/IOFactory.cpp
//! @brief     Implements class DatafieldIOFactory.
//!
//! @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/IOFactory.h"
#include "Base/Util/Assert.h"
#include "Base/Util/FileSystemUtils.h"
#include "Device/Histo/DiffUtil.h"
#include "Device/Histo/SimulationResult.h"
#include "Device/IO/DataFormatUtils.h"
#include "Device/IO/ReadReflectometry.h"
#include "Device/IO/ReadWriteINT.h"
#include "Device/IO/ReadWriteNicos.h"
#include "Device/IO/ReadWriteNumpyTXT.h"
#include "Device/IO/ReadWriteTiff.h"
#include <exception>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4244 4275)
#include "Device/IO/boost_streams.h"
#pragma warning(pop)
#else
#include "Device/IO/boost_streams.h"
#endif
 
Datafield* IOFactory::readDatafield(const std::string& file_name, LoaderSelector selector)
{
    const auto readAs = [=](LoaderSelector testForSelector) {
        return (selector == testForSelector)
               || (selector == automatic
                   && fileTypeMatchesLoaderSelector(file_name, testForSelector));
    };
 
    Datafield* result = nullptr;
 
    if (readAs(bornagain))
        result = readDatafield(file_name,
                               [](std::istream& s) { return ReadWriteINT().readDatafield(s); });
 
    else if (readAs(nicos))
        result = readDatafield(file_name, [](std::istream& s) { return IO::readNicosData(s); });
 
#ifdef BA_TIFF_SUPPORT
    else if (readAs(tiff))
        result = readDatafield(file_name,
                               [](std::istream& s) { return ReadWriteTiff().readDatafield(s); });
#endif
 
    else
        // Try to read ASCII by default. Binary maps to ASCII.
        // If the file is not actually a matrix of numbers,
        // the error will be thrown during the reading.
        result = readDatafield(
            file_name, [](std::istream& s) { return ReadWriteNumpyTXT().readDatafield(s); });
 
    ASSERT(result);
    return result;
}
 
Datafield* IOFactory::readReflectometryData(const std::string& file_name)
{
    return readDatafield(file_name,
                         [](std::istream& s) { return ReadReflectometry().readDatafield(s); });
}
 
void IOFactory::writeDatafield(const Datafield& data, const std::string& file_name)
{
    if (DataUtils::Format::isIntFile(file_name))
        writeDatafield(file_name, [&](std::ostream& s) { ReadWriteINT().writeDatafield(data, s); });
#ifdef BA_TIFF_SUPPORT
    else if (DataUtils::Format::isTiffFile(file_name))
        writeDatafield(file_name,
                       [&](std::ostream& s) { ReadWriteTiff().writeDatafield(data, s); });
#endif
    else
        writeDatafield(file_name,
                       [&](std::ostream& s) { ReadWriteNumpyTXT().writeDatafield(data, s); });
}
 
void IOFactory::writeDatafield(const std::string& file_name,
                               std::function<void(std::ostream&)> writeData)
{
    using namespace DataUtils::Format;
 
    std::ofstream fout;
    std::ios_base::openmode openmode = std::ios::out;
    if (isTiffFile(file_name) || isCompressed(file_name))
        openmode = std::ios::out | std::ios_base::binary;
 
#ifdef _WIN32
    fout.open(BaseUtils::Filesystem::convert_utf8_to_utf16(file_name), openmode);
#else
    fout.open(file_name, openmode);
#endif
 
    if (!fout.is_open())
        throw std::runtime_error("Cannot open file for writing: " + file_name);
    if (!fout.good())
        throw std::runtime_error("File is not good, probably it is a directory: " + file_name);
    std::stringstream ss;
    writeData(ss);
 
    boost::iostreams::filtering_streambuf<boost::iostreams::input> input_filtered;
    if (DataUtils::Format::isGZipped(file_name))
        input_filtered.push(boost::iostreams::gzip_compressor());
    else if (DataUtils::Format::isBZipped(file_name))
        input_filtered.push(boost::iostreams::bzip2_compressor());
    input_filtered.push(ss);
 
    boost::iostreams::copy(input_filtered, fout);
 
    fout.close();
}
 
bool IOFactory::fileTypeMatchesLoaderSelector(const std::string& fileName, LoaderSelector selector)
{
    switch (selector) {
    case bornagain:
        return DataUtils::Format::isIntFile(fileName);
    case nicos:
        return DataUtils::Format::isNicosFile(fileName);
    case tiff:
        return DataUtils::Format::isTiffFile(fileName);
    case automatic:
        return false;
    }
 
    return false;
}
 
void IOFactory::writeSimulationResult(const SimulationResult& result, const std::string& file_name)
{
    auto data = result.datafield();
    writeDatafield(*data, file_name); // TODO delete ptr
}
 
Datafield* IOFactory::readDatafield(const std::string& file_name,
                                    std::function<Datafield*(std::istream&)> readData)
{
    if (!BaseUtils::Filesystem::IsFileExists(file_name))
        throw std::runtime_error("File does not exist: " + file_name);
 
    using namespace DataUtils::Format;
    std::ifstream input_stream;
    std::ios_base::openmode openmode = std::ios::in;
    if (isTiffFile(file_name) || isCompressed(file_name))
        openmode = std::ios::in | std::ios_base::binary;
 
#ifdef _WIN32
    input_stream.open(BaseUtils::Filesystem::convert_utf8_to_utf16(file_name), openmode);
#else
    input_stream.open(file_name, openmode);
#endif
 
    if (!input_stream.is_open())
        throw std::runtime_error("Cannot open file for reading: " + file_name);
    if (!input_stream.good())
        throw std::runtime_error("File is not good, probably it is a directory:" + file_name);
 
    boost::iostreams::filtering_streambuf<boost::iostreams::input> input_filtered;
    if (DataUtils::Format::isGZipped(file_name))
        input_filtered.push(boost::iostreams::gzip_decompressor());
    else if (DataUtils::Format::isBZipped(file_name))
        input_filtered.push(boost::iostreams::bzip2_decompressor());
    input_filtered.push(input_stream);
    // we use stringstream since it provides random access which is important for tiff files
    std::stringstream str;
    boost::iostreams::copy(input_filtered, str);
 
    return readData(str);
}
 
 
bool IOUtil::filesAgree(const std::string& datFileName, const std::string& refFileName, double tol)
{
    std::unique_ptr<Datafield> datDat;
    try {
        datDat.reset(IOFactory::readDatafield(datFileName));
    } catch (const std::runtime_error& ex) {
        std::cerr << "File comparison: Could not read data from file " << datFileName
                  << ". Runtime error: " << ex.what() << std::endl;
    } catch (const std::exception& ex) {
        std::cerr << "File comparison: Could not read data from file " << datFileName
                  << ". Exception: " << ex.what() << std::endl;
    } catch (...) {
        std::cerr << "File comparison: Could not read data from file " << datFileName
                  << ". Unknown exception." << std::endl;
        return false;
    }
    ASSERT(datDat);
 
    std::unique_ptr<Datafield> refDat;
    try {
        refDat.reset(IOFactory::readDatafield(refFileName));
    } catch (...) {
        std::cerr << "File comparison: Could not read reference data from file " << refFileName
                  << std::endl;
        return false;
    }
    ASSERT(refDat);
 
    return DiffUtil::checkRelativeDifference(datDat->flatVector(), refDat->flatVector(), tol);
}