FitProperty.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 "../job/FitObject.h"
#include "../util/xml/XMLUtilities.h"

namespace atomicrex {

class ScalarDOF;
class FitJob;   // defined in FitJob.h

class FitProperty : public FitObject
{
public:

    enum ResidualNorm {
        UserDefined,        
        Squared,        
        SquaredRelative,    
        AbsoluteDiff        
    };

public:

    FitProperty() { setFitEnabled(false); setOutputEnabled(false); }

    FitProperty(const FPString& id, const FPString& units, FitJob* job) : FitObject(id, job) { 
        setFitEnabled(false); 
        setOutputEnabled(false); 
        initialize(id, units, job);
    }

    void initialize(const FPString& id, const FPString& units, FitJob* job);

    virtual double residual(ResidualNorm norm) const = 0;

    bool shouldCompute(bool isFitting) const { return (isFitting && _fitEnabled) || (!isFitting && _outputEnabled); }

    virtual void print(MsgLogger& stream) override {}

    virtual void compute() {}

    void assignAbsoluteWeights(double absoluteWeight) override { _absoluteWeight = absoluteWeight; }

    double absoluteWeight() const { return _absoluteWeight; }

    double tolerance() const { return _tolerance; }

    void setTolerance(double tolerance) { _tolerance = tolerance; }

    ResidualNorm residualNorm() const { return _residualNorm; }

    const FPString& units() const { return _units; }

public:

    virtual void parse(XML::Element propertyElement) override;

protected:

    double _absoluteWeight = 1.0;

private:

    double _tolerance = 1.0;

protected:

    ResidualNorm _residualNorm = Squared;

    FPString _units;

    friend class FitObject;
};

class ScalarFitProperty : public FitProperty
{
public:

    ScalarFitProperty() : _computedValue(0), _targetValue(0) {}

    ScalarFitProperty(const FPString& id, const FPString& units, FitJob* job) : FitProperty(id, units, job), _computedValue(0), _targetValue(0) {}

    void initialize(const FPString& id, const FPString& units, FitJob* job) { FitProperty::initialize(id, units, job); }

    virtual double residual(ResidualNorm norm) const override;

    operator double() const { return _computedValue; }

    double computedValue() const { return _computedValue;}
    ScalarFitProperty& operator=(double value) { _computedValue = value; return *this; }

    virtual void print(MsgLogger& stream) override;

public:

    virtual void parse(XML::Element propertyElement) override;

    double targetValue() { return _targetValue; }

    void setTargetValue(double targetValue ) { _targetValue = targetValue;}


protected:

    double _computedValue;

    double _targetValue;
};


class CoupledFitProperty : public ScalarFitProperty
{
public:

    CoupledFitProperty(ScalarDOF& dof, const FPString& units, FitJob* job);

    ScalarDOF& dof() const { return _dof; }

    virtual void compute() override;

    virtual void print(MsgLogger& stream) override;

public:

    virtual void parse(XML::Element propertyElement) override;

private:

    ScalarDOF& _dof;
};

} // End of namespace