FitJob.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 "../properties/FitProperty.h"
#include "../properties/DerivedProperty.h"
#include "FitGroup.h"
#include "../util/xml/XMLUtilities.h"

namespace atomicrex {

class Potential;        // Defined in Potential.h
class AtomicStructure;  // Defined in AtomicStructure.h
class DegreeOfFreedom;  // Defined in DegreeOfFreedom.h
class Minimizer;        // Defined in Minimizer.h

class FitJob
{
public:

    enum TolerancePreset {
        Uniform,          
        Balanced,         
        AccurateEnergies  
    };

public:

    FitJob();

    ~FitJob();

    const FPString& name() const { return _name; }

    double getDefaultPropertyTolerance(FitProperty* property);

    int numAtomTypes() const { return _natomtypes; }

    bool addAtomType(const FPString& name, double mass = 0.0, int atomicNumber = 0) {
        if(name.empty() || find(_atomTypeNames.begin(), _atomTypeNames.end(), name) != _atomTypeNames.end())
            return false;
        _atomTypeNames.push_back(name);
        _atomTypeMasses.push_back(mass);
        _atomTypeAtomicNumbers.push_back(atomicNumber);
        _natomtypes = (int)_atomTypeNames.size();
        return true;
    }

    const FPString& atomTypeName(int i) const {
        BOOST_ASSERT(_natomtypes == _atomTypeNames.size());
        BOOST_ASSERT(i >= 0 && i < _atomTypeNames.size());
        return _atomTypeNames[i];
    }

    double atomTypeMass(int i) const {
        BOOST_ASSERT(_natomtypes == _atomTypeMasses.size());
        BOOST_ASSERT(i >= 0 && i < _atomTypeMasses.size());
        return _atomTypeMasses[i];
    }

    int atomTypeAtomicNumber(int i) const {
        BOOST_ASSERT(_natomtypes == _atomTypeAtomicNumbers.size());
        BOOST_ASSERT(i >= 0 && i < _atomTypeAtomicNumbers.size());
        return _atomTypeAtomicNumbers[i];
    }

    int atomTypeIndex(const FPString& s) const {
        auto iter = std::find(_atomTypeNames.begin(), _atomTypeNames.end(), s);
        BOOST_ASSERT(iter != _atomTypeNames.end());
        return iter - _atomTypeNames.begin();
    }

    double maximumCutoff() const { return _maximumCutoff; }

    const std::vector<Potential*>& potentials() const { return _potentials; }

    const std::vector<AtomicStructure*>& structures() const { return _structures; }

    const std::vector<AtomicStructure*>& referencedStructures() const { return _referencedStructures; }

    void addReferencedStructure(AtomicStructure* structure);

    const std::vector<AtomicStructure*>& unreferencedStructures() const { return _unreferencedStructures; }

    void addUnreferencedStructure(AtomicStructure* structure) { _unreferencedStructures.push_back(structure); }

    const std::vector<DerivedProperty*>& derivedProperties() { return _derivedProperties; }

    const std::vector<FitProperty*>& fitProperties() { return _propertyList; }

    FitGroup& rootGroup() { return _rootGroup; }

    ScalarFitProperty* getScalarFitProperty(const FPString& id);

    AtomicStructure* getAtomicStructure(const FPString& id);

    DerivedProperty* getDerivedProperty(const FPString& id);

    const Matrix3* lookupDeformation(const FPString& deformationId) const {
        auto d = _deformations.find(deformationId);
        if(d != _deformations.end()) return &d->second;
        else return nullptr;
    }

    bool fittingEnabled() const { return (bool)_fitMinimizer; }

    std::shared_ptr<Minimizer> fitMinimizer() { return _fitMinimizer; }

    void performFitting();

    void printPotentialDOFList(bool printFullDOFList);

    void printFittingProperties();

    bool potentialValidationEnabled() const { return _potentialValidationEnabled; }

    void validatePotentials();

    int numActiveDOF() const { return _numActiveDOF; }

    void packDOF(double* destination);

    void packDOF(std::vector<double>& destination) {
        BOOST_ASSERT(destination.size() == numActiveDOF());
        packDOF(destination.data());
    }

    void unpackDOF(const double* source);

    void unpackDOF(const std::vector<double>& source) {
        BOOST_ASSERT(source.size() == numActiveDOF());
        unpackDOF(source.data());
    }

public:

    void parse(const FPString& file);

    int parseAtomTypeAttribute(XML::Element element, const char* attributeName);

    int parseAtomTypeElement(XML::Element element, const char* elementName);

    std::vector<int> parseAtomTypesAttribute(XML::Element element, const char* attributeName);

    ScalarFitProperty* parseScalarFitPropertyAttribute(XML::Element element, const char* attributeName);

    double calculateResidual(FitProperty::ResidualNorm norm = FitProperty::UserDefined);

    void prepareFitting();


private:


    void assignAbsoluteWeights();

    void addStructure(AtomicStructure* structure);

    void addDerivedProperty(DerivedProperty* derivedProperty);



private:

    void parseAtomTypesElement(XML::Element typesElement);

    void parsePotentialsElement(XML::Element potentialsElement);

    void parseFittingElement(XML::Element fittingElement);

    void parseDeformationsElement(XML::Element deformationsElement);

private:

    FPString _name;

    int _natomtypes = 0;

    std::vector<FPString> _atomTypeNames;

    std::vector<double> _atomTypeMasses;

    std::vector<int> _atomTypeAtomicNumbers;

    double _maximumCutoff = 0.0;

    std::vector<Potential*> _potentials;

    FitGroup _rootGroup;

    std::vector<AtomicStructure*> _structures;

    std::vector<AtomicStructure*> _referencedStructures;

    std::vector<AtomicStructure*> _unreferencedStructures;

    std::vector<DerivedProperty*> _derivedProperties;

    std::vector<DegreeOfFreedom*> _completePotentialDOFList;

    std::vector<DegreeOfFreedom*> _activePotentialDOFList;

    size_t _numActiveDOF = 0;

    std::vector<double> _currentState;

    int _intervalForPrinting;

    std::vector<FitProperty*> _propertyList;

    std::shared_ptr<Minimizer> _fitMinimizer;

    std::map<FPString, Matrix3> _deformations;

    bool _potentialValidationEnabled = false;

    TolerancePreset _tolerancePreset = Balanced;

    friend class FitGroup;
    friend class AtomicStructure;
    friend class DerivedProperty;
};

} // End of namespace

#include "../structures/AtomicStructure.h"
#include "../potentials/Potential.h"