DegreeOfFreedom.h

//
//  Copyright (C) 2017, Alexander Stukowski and Paul Erhart
//
//  This file is part of atomicrex.
//
//  Atomicrex is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 3 of the License, or
//  (at your option) any later version.
//
//  Atomicrex is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#pragma once

#include "../Atomicrex.h"
#include "../minimizers/Minimizer.h"
#include "../util/xml/XMLUtilities.h"

namespace atomicrex {

class FitObject;
class AtomicStructure;
class Potential;

class DegreeOfFreedom
{
public:

    DegreeOfFreedom(const FPString& id = FPString(), const FPString& tag = FPString()) : _id(id), _tag(tag), _fitEnabled(false),
        _relax(false), _object(nullptr), _resetBeforeRelax(true) {}

    virtual ~DegreeOfFreedom() {}

    const FPString& id() const { return _id; }

    void setId(const FPString& id) { _id = id; }

    const FPString& tag() const { return _tag; }

    void setTag(const FPString& tag) { _tag = tag; }

    bool fitEnabled() const { return _fitEnabled; }

    void setFitEnabled(bool enable) { _fitEnabled = enable; }

    bool relax() const { return _relax; }

    void setRelax(bool enable) { _relax = enable; }

    FitObject* object() const { return _object; }

    virtual int numScalars() = 0;

    virtual void exportValue(double*& dst) = 0;

    virtual void importValue(const double*& src) = 0;

    virtual bool hasBoundConstraints() const { return false; }

    virtual bool satisfiesBoundConstraints() const { return true; }

    virtual void getBoundConstraints(std::vector<Minimizer::BoundConstraints>::iterator& types, std::vector<double>::iterator& lowerBounds, std::vector<double>::iterator& upperBounds) {
        std::fill(types, types + numScalars(), Minimizer::NO_BOUNDS);
        types += numScalars();
        lowerBounds += numScalars();
        upperBounds += numScalars();
    }

    virtual void print(MsgLogger& stream) {}

    bool resetBeforeRelax() const { return _resetBeforeRelax; }

    void setResetBeforeRelax(bool enableReset) { _resetBeforeRelax = enableReset; }

    virtual void reset() {}

public:

    virtual void parseFit(XML::Element fitElement);

    virtual void parseRelax(XML::Element relaxElement);

    virtual XML::OElement generateXMLValueDefinition() const;

    virtual XML::OElement generateXMLFitDefinition() const;

private:

    FPString _id;

    FPString _tag;

    bool _fitEnabled;

    bool _relax;

    bool _resetBeforeRelax;

    FitObject* _object;

    friend class FitObject;
};

class ScalarDOF : public DegreeOfFreedom
{
public:

    ScalarDOF(const FPString& id = FPString(), double defaultValue = 0,
            double minValue = -std::numeric_limits<double>::infinity(),
            double maxValue = std::numeric_limits<double>::infinity()) : DegreeOfFreedom(id),
        _value(defaultValue),
        _initialValue(defaultValue),
        _minValue(minValue),
        _maxValue(maxValue),
        _masterDOF(nullptr) {}

    operator double() const { return _value; }

    double getValue() { return _value; }

    ScalarDOF& operator=(double value);

    void setValue(double value) { _value = value; };

    double* getValuePointer() { return &_value; }

    void setInitialValue(double value) { _initialValue = value; *this = value; }

    double initialValue() const { return _initialValue; }

    virtual void reset() override { DegreeOfFreedom::reset(); *this = _initialValue;    }

    virtual int numScalars() override { return 1; }

    virtual void exportValue(double*& dst) override;

    virtual void importValue(const double*& src) override;

    virtual void print(MsgLogger& stream) override;

    double lowerBound() const { return _minValue; }

    bool hasLowerBound() const { return _minValue != -std::numeric_limits<double>::infinity(); }

    void setLowerBound(double lowerBound) { _minValue = lowerBound; }

    double upperBound() const { return _maxValue; }

    bool hasUpperBound() const { return _maxValue != std::numeric_limits<double>::infinity(); }

    void setUpperBound(double upperBound) { _maxValue = upperBound; }

    virtual bool hasBoundConstraints() const override { return hasLowerBound() || hasUpperBound(); }

    virtual bool satisfiesBoundConstraints() const override {
      if(hasLowerBound() && _value < lowerBound()) return false;
      if(hasUpperBound() && _value > upperBound()) return false;
      return true;
    };

    virtual void getBoundConstraints(std::vector<Minimizer::BoundConstraints>::iterator& types, std::vector<double>::iterator& lowerBounds, std::vector<double>::iterator& upperBounds) override {
        if(hasLowerBound()) {
            if(hasUpperBound())
                *types++ = Minimizer::BOTH_BOUNDS;
            else
                *types++ = Minimizer::LOWER_BOUNDS;
        }
        else if(hasUpperBound())
            *types++ = Minimizer::UPPER_BOUNDS;
        else
            *types++ = Minimizer::NO_BOUNDS;
        *lowerBounds++ = _minValue;
        *upperBounds++ = _maxValue;
    }

    bool setEqualTo(ScalarDOF* masterDOF);

public:

    virtual void parseFit(XML::Element fitElement) override;

    virtual void parseRelax(XML::Element relaxElement) override;

    void parseSetEqualToAttribute(XML::Element element);

    virtual XML::OElement generateXMLValueDefinition() const override;

    virtual XML::OElement generateXMLFitDefinition() const override;

private:

    double _value;

    double _initialValue;

    double _minValue;

    double _maxValue;

    ScalarDOF* _masterDOF;

    std::vector<std::function<void(ScalarDOF&)>> _changeListeners;
};

} // End of namespace