HartreeFock.h

/* Copyright 2019 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef COM_DAFER45_TBTK_HARTREE_FOCK_DIAGONALIZATION
#define COM_DAFER45_TBTK_HARTREE_FOCK_DIAGONALIZATION

#include "TBTK/Atom.h"
#include "TBTK/Solver/Diagonalizer.h"

namespace TBTK{
namespace Solver{

class HartreeFock : public Diagonalizer{
public:
    class Callbacks :
        public HoppingAmplitude::AmplitudeCallback,
        public OverlapAmplitude::AmplitudeCallback
    {
    public:
        Callbacks();

        virtual std::complex<double> getHoppingAmplitude(
            const Index &to,
            const Index &from
        ) const;

        virtual std::complex<double> getOverlapAmplitude(
            const Index &bra,
            const Index &ket
        ) const;

        void setSolver(const HartreeFock &solver);
    private:
        const HartreeFock *solver;
    };

    HartreeFock();

    virtual ~HartreeFock();

    void setOccupationNumber(unsigned int occupationNumber);

    double getTotalEnergy() const;

    void addNuclearCenter(const Atom &atom, const Vector3d &position);

    void run();
private:
    class PositionedAtom : public Atom{
    public:
        PositionedAtom(const Atom &atom, const Vector3d &position);

        const Vector3d& getPosition() const;
    private:
        //Position
        Vector3d position;
    };

    std::vector<const AbstractState*> basisStates;

    Matrix<std::complex<double>> densityMatrix;

    std::vector<PositionedAtom> nuclearCenters;

    unsigned int occupationNumber;

    double totalEnergy;

    class SelfConsistencyCallback :
        public Diagonalizer::SelfConsistencyCallback
    {
    public:
        SelfConsistencyCallback(HartreeFock &solver);

        virtual bool selfConsistencyCallback(
            Diagonalizer &diagonalizer
        );
    private:
        HartreeFock &solver;
    } selfConsistencyCallback;

    const Matrix<std::complex<double>>& getDensityMatrix() const;

    const std::vector<PositionedAtom>& getNuclearCenters() const;

    void calculateTotalEnergy();
};

inline void HartreeFock::setOccupationNumber(unsigned int occupationNumber){
    this->occupationNumber = occupationNumber;
}

inline double HartreeFock::getTotalEnergy() const{
    return totalEnergy;
}

inline const Matrix<std::complex<double>>&
HartreeFock::getDensityMatrix() const{
    return densityMatrix;
}

inline void HartreeFock::addNuclearCenter(
    const Atom &atom,
    const Vector3d &position
){
    nuclearCenters.push_back(PositionedAtom(atom, position));
}

inline const std::vector<HartreeFock::PositionedAtom>&
HartreeFock::getNuclearCenters() const{
    return nuclearCenters;
}

inline void HartreeFock::Callbacks::setSolver(const HartreeFock &solver){
    this->solver = &solver;
}

inline HartreeFock::PositionedAtom::PositionedAtom(
    const Atom &atom,
    const Vector3d &position
) :
    Atom(atom),
    position(position)
{
}

inline const Vector3d& HartreeFock::PositionedAtom::getPosition() const{
    return position;
}

};  //End of namespace Solver
};  //End of namespace TBTK

#endif