HoppingAmplitude.h

Go to the documentation of this file.

/* Copyright 2016 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_HOPPING_AMPLITUDE
#define COM_DAFER45_TBTK_HOPPING_AMPLITUDE

#include "TBTK/Index.h"
#include "TBTK/Serializable.h"

#include <complex>
#include <initializer_list>
#include <tuple>
#include <vector>

namespace TBTK{

enum HermitianConjugate {HC};

class HoppingAmplitude{
public:
    class AmplitudeCallback{
    public:
        virtual std::complex<double> getHoppingAmplitude(
            const Index &to,
            const Index &from
        ) const = 0;
    };

    //TBTKFeature Core.HoppingAmplitude.Construction.1 2019-09-23
    HoppingAmplitude();

    //TBTKFeature Core.HoppingAmplitude.Construction.2 2019-09-23
    HoppingAmplitude(
        std::complex<double> amplitude,
        Index toIndex,
        Index fromIndex
    );

    //TBTKFeature Core.HoppingAmplitude.Construction.3 2019-09-23
    HoppingAmplitude(
        const AmplitudeCallback &callback,
        Index toIndex,
        Index fromIndex
    );

    //TBTKFeature Core.HoppingAmplitude.Copy.1 2019-09-23
    //TBTKFeature Core.HoppingAmplitude.Copy.2 2019-09-23
    HoppingAmplitude(const HoppingAmplitude &ha);

    //TBTKFeature Core.HoppingAmplitude.Serialization.1 2019-09-23
    HoppingAmplitude(
        const std::string &serialization,
        Serializable::Mode mode
    );

    //TBTKFeature Core.HoppingAmplitude.getHermitianConjugate.1 2019-09-23
    //TBTKFeature Core.HoppingAmplitude.getHermitianConjugate.2 2019-09-23
    HoppingAmplitude getHermitianConjugate() const;

    void print() const;

    //TBTKFeature Core.HoppingAmplitude.getAmplitude.1 2019-09-23
    //TBTKFeature Core.HoppingAmplitude.getAmplitude.2 2019-09-23
    std::complex<double> getAmplitude() const;

    //TBTKFeature Core.HoppingAmplitude.operatorAddition.1.C++ 2019-09-23
    std::tuple<HoppingAmplitude, HoppingAmplitude> operator+(
        const HermitianConjugate hc
    );

    //TBTKFeature Core.HoppingAmplitude.getToIndex.1 2019-09-23
    const Index& getToIndex() const;

    //TBTKFeature Core.HoppingAmplitude.getFromIndex.1 2019-09-23
    const Index& getFromIndex() const;

    //TBTKFeature Core.HoppingAmplitude.getIsCallbackDependent.1 2019-09-23
    //TBTKFeature Core.HoppingAmplitude.getIsCallbackDependent.2 2019-09-23
    bool getIsCallbackDependent() const;

    //TBTKFeature Core.HoppingAmplitude.getAmplitudeCallback.1 2019-09-23
    //TBTKFeature Core.HoppingAmplitude.getAmplitudeCallback.2 2019-09-23
    const AmplitudeCallback& getAmplitudeCallback() const;

    std::string toString() const;

    friend std::ostream& operator<<(
        std::ostream &stream,
        const HoppingAmplitude &hoppingAmplitude
    );

    //TBTKFeature Core.HoppingAmplitude.Serialization.1 2019-09-23
    std::string serialize(Serializable::Mode mode) const;

    unsigned int getSizeInBytes() const;
private:
    std::complex<double> amplitude;

    const AmplitudeCallback *amplitudeCallback;

    Index fromIndex;

    Index toIndex;

};

inline std::complex<double> HoppingAmplitude::getAmplitude() const{
    if(amplitudeCallback){
        return amplitudeCallback->getHoppingAmplitude(
            toIndex,
            fromIndex
        );
    }
    else{
        return amplitude;
    }
}

inline std::tuple<HoppingAmplitude, HoppingAmplitude> HoppingAmplitude::operator+(
    HermitianConjugate hc
){
    return std::make_tuple(*this, this->getHermitianConjugate());
}

inline const Index& HoppingAmplitude::getToIndex() const{
    return toIndex;
}

inline const Index& HoppingAmplitude::getFromIndex() const{
    return fromIndex;
}

inline bool HoppingAmplitude::getIsCallbackDependent() const{
    if(amplitudeCallback == nullptr)
        return false;
    else
        return true;
}

inline const HoppingAmplitude::AmplitudeCallback&
HoppingAmplitude::getAmplitudeCallback() const{
    if(amplitudeCallback != nullptr){
        return *amplitudeCallback;
    }
    else{
        TBTKExit(
            "HoppingAmpliude::getAmplitudeCallback()",
            "Tried to access AmplitudeCallback from a"
            << " HoppingAmplitude without an AmplitudeCallback.",
            ""
        );
    }
}

inline std::string HoppingAmplitude::toString() const{
    std::stringstream stream;
    stream << "HoppingAmplitude:\n";
    if(amplitudeCallback == nullptr){
        stream << "\tIs callback dependent: False\n";
        stream << "\tAmplitude: " << amplitude << "\n";
    }
    else{
        stream << "\tIs callback dependent: True\n";
        stream << "\tAmplitude: "
            << amplitudeCallback->getHoppingAmplitude(
                toIndex,
                fromIndex
            ) << "\n";
    }
    stream << "\tTo-Index: " << toIndex << "\n";
    stream << "\tFrom-Index: " << fromIndex;

    return stream.str();
}

inline std::ostream& operator<<(
    std::ostream &stream,
    const HoppingAmplitude &hoppingAmplitude
){
    stream << hoppingAmplitude.toString();

    return stream;
}

inline unsigned int HoppingAmplitude::getSizeInBytes() const{
    return sizeof(HoppingAmplitude)
        - sizeof(fromIndex)
        - sizeof(toIndex)
        + fromIndex.getSizeInBytes()
        + toIndex.getSizeInBytes();
}

};  //End of namespace TBTK

#endif