SimulationOptionsItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Support/Data/SimulationOptionsItem.cpp
//! @brief     Defines class SimulationOptionsItem
//!
//! @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 "GUI/Support/Data/SimulationOptionsItem.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/DeserializationException.h"
#include <QXmlStreamWriter>
#include <thread>
 
namespace {
 
namespace Tags {
 
const QString RunImmediately("RunImmediately");
const QString NumberOfThreads("NumberOfThreads");
const QString Analytical("Analytical");
const QString NumberOfMonteCarloPoints("NumberOfMonteCarloPoints");
const QString UseAverageMaterials("UseAverageMaterials");
const QString IncludeSpecularPeak("IncludeSpecularPeak");
 
} // namespace Tags
 
} // namespace
 
 
SimulationOptionsItem::SimulationOptionsItem()
{
    m_runImmediately = true;
    m_numberOfThreads = std::thread::hardware_concurrency();
    m_computationMethodAnalytical = true;
    m_numberOfMonteCarloPoints = 100;
    m_useAverageMaterials = false;
    m_includeSpecularPeak = false;
}
 
unsigned SimulationOptionsItem::numberOfThreads() const
{
    return m_numberOfThreads;
}
 
void SimulationOptionsItem::setNumberOfThreads(unsigned number)
{
    m_numberOfThreads = number;
}
 
bool SimulationOptionsItem::runImmediately() const
{
    return m_runImmediately;
}
 
bool SimulationOptionsItem::runInBackground() const
{
    return !runImmediately();
}
 
void SimulationOptionsItem::setRunImmediately(bool runImmediately)
{
    m_runImmediately = runImmediately;
}
 
void SimulationOptionsItem::setUseMonteCarloIntegration(unsigned numberOfPoints)
{
    m_computationMethodAnalytical = false;
    m_numberOfMonteCarloPoints = numberOfPoints;
}
 
void SimulationOptionsItem::setUseAnalytical()
{
    m_computationMethodAnalytical = true;
}
 
bool SimulationOptionsItem::useMonteCarloIntegration() const
{
    return !useAnalytical();
}
 
bool SimulationOptionsItem::useAnalytical() const
{
    return m_computationMethodAnalytical;
}
 
unsigned SimulationOptionsItem::numberOfMonteCarloPoints() const
{
    return m_numberOfMonteCarloPoints;
}
 
void SimulationOptionsItem::setUseAverageMaterials(bool useAverageMaterials)
{
    m_useAverageMaterials = useAverageMaterials;
}
 
bool SimulationOptionsItem::useAverageMaterials() const
{
    return m_useAverageMaterials;
}
 
void SimulationOptionsItem::setIncludeSpecularPeak(bool includeSpecularPeak)
{
    m_includeSpecularPeak = includeSpecularPeak;
}
 
bool SimulationOptionsItem::includeSpecularPeak() const
{
    return m_includeSpecularPeak;
}
 
void SimulationOptionsItem::writeContentTo(QXmlStreamWriter* writer) const
{
    GUI::Session::XML::writeAttribute(writer, GUI::Session::XML::Version, int(1));
    GUI::Session::XML::writeAttribute(writer, Tags::RunImmediately, m_runImmediately);
    GUI::Session::XML::writeAttribute(writer, Tags::NumberOfThreads, m_numberOfThreads);
    GUI::Session::XML::writeAttribute(writer, Tags::Analytical, m_computationMethodAnalytical);
    GUI::Session::XML::writeAttribute(writer, Tags::NumberOfMonteCarloPoints,
                                      m_numberOfMonteCarloPoints);
    GUI::Session::XML::writeAttribute(writer, Tags::UseAverageMaterials, m_useAverageMaterials);
    GUI::Session::XML::writeAttribute(writer, Tags::IncludeSpecularPeak, m_includeSpecularPeak);
}
 
void SimulationOptionsItem::readContentFrom(QXmlStreamReader* reader)
{
    const int version = reader->attributes().value(GUI::Session::XML::Version).toInt();
 
    if (version < 1)
        throw DeserializationException::tooOld();
 
    if (version > 1)
        throw DeserializationException::tooNew();
 
    m_runImmediately = GUI::Session::XML::readBoolAttribute(reader, Tags::RunImmediately);
    m_numberOfThreads = GUI::Session::XML::readUIntAttribute(reader, Tags::NumberOfThreads);
    m_computationMethodAnalytical = GUI::Session::XML::readBoolAttribute(reader, Tags::Analytical);
    m_numberOfMonteCarloPoints =
        GUI::Session::XML::readUIntAttribute(reader, Tags::NumberOfMonteCarloPoints);
    m_useAverageMaterials = GUI::Session::XML::readBoolAttribute(reader, Tags::UseAverageMaterials);
    m_includeSpecularPeak = GUI::Session::XML::readBoolAttribute(reader, Tags::IncludeSpecularPeak);
}