EnergyResolvedProperty.h

Go to the documentation of this file.

/* Copyright 2018 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_PROPERTY_ENERGY_RESOLVED_PROPERTY
#define COM_DAFER45_TBTK_PROPERTY_ENERGY_RESOLVED_PROPERTY
 
#include "TBTK/Property/AbstractProperty.h"
#include "TBTK/TBTKMacros.h"
 
#include <cmath>
#include <complex>
#include <vector>
 
namespace TBTK{
namespace Property{
 
template<typename DataType>
class EnergyResolvedProperty : public AbstractProperty<DataType>{
public:
    enum class EnergyType{Real, FermionicMatsubara, BosonicMatsubara};
 
    EnergyResolvedProperty();
 
    EnergyResolvedProperty(
        double lowerBound,
        double upperBound,
        unsigned int resolution
    );
 
    EnergyResolvedProperty(
        double lowerBound,
        double upperBound,
        unsigned int resolution,
        const DataType *data
    );
 
    EnergyResolvedProperty(
        const std::vector<int> &ranges,
        double lowerBound,
        double upperBound,
        unsigned int resolution
    );
 
    EnergyResolvedProperty(
        const std::vector<int> &ranges,
        double lowerBound,
        double upperBound,
        unsigned int resolution,
        const DataType *data
    );
 
    EnergyResolvedProperty(
        const IndexTree &indexTree,
        double lowerBound,
        double upperBound,
        unsigned int resolution
    );
 
    EnergyResolvedProperty(
        const IndexTree &indexTree,
        double lowerBound,
        double upperBound,
        unsigned int resolution,
        const DataType *data
    );
 
    EnergyResolvedProperty(
        EnergyType energyType,
        const IndexTree &indexTree,
        int lowerMatsubaraEnergyIndex,
        int upperMatsubaraEnergtIndex,
        double fundamentalMatsubaraEnergy
    );
 
    EnergyResolvedProperty(
        EnergyType energyType,
        const IndexTree &indexTree,
        int lowerMatsubaraEnergyIndex,
        int upperMatsubaraEnergtIndex,
        double fundamentalMatsubaraEnergy,
        const DataType *data
    );
 
    EnergyResolvedProperty(
        const std::string &serialization,
        Serializable::Mode mode
    );
 
    /*** Get energy type.
     *
     *  @return The EnergyType. */
    EnergyType getEnergyType() const;
 
    double getLowerBound() const;
 
    double getUpperBound() const;
 
    unsigned int getResolution() const;
 
    double getDeltaE() const;
 
    double getEnergy(unsigned int n) const;
 
    int getLowerMatsubaraEnergyIndex() const;
 
    int getUpperMatsubaraEnergyIndex() const;
 
    unsigned int getNumMatsubaraEnergies() const;
 
    double getFundamentalMatsubaraEnergy() const;
 
    double getLowerMatsubaraEnergy() const;
 
    double getUpperMatsubaraEnergy() const;
 
    std::complex<double> getMatsubaraEnergy(unsigned int n) const;
 
    unsigned int getNumEnergies() const;
 
    bool energyWindowsAreEqual(
        const EnergyResolvedProperty &energyResolvedProperty,
        double precision = 1e-1
    ) const;
 
    virtual std::string serialize(Serializable::Mode mode) const;
protected:
    EnergyResolvedProperty& operator+=(const EnergyResolvedProperty &rhs);
 
    EnergyResolvedProperty& operator-=(const EnergyResolvedProperty &rhs);
 
    EnergyResolvedProperty& operator*=(const DataType &rhs);
 
    EnergyResolvedProperty& operator/=(const DataType &rhs);
private:
    EnergyType energyType;
 
    class RealEnergy{
    public:
        double lowerBound;
 
        double upperBound;
 
        unsigned int resolution;
    };
 
    class MatsubaraEnergy{
    public:
        int lowerMatsubaraEnergyIndex;
 
        int numMatsubaraEnergies;
 
        double fundamentalMatsubaraEnergy;
    };
 
    union EnergyDescriptor{
        RealEnergy realEnergy;
        MatsubaraEnergy matsubaraEnergy;
    };
 
    EnergyDescriptor descriptor;
};
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(){
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    double lowerBound,
    double upperBound,
    unsigned int resolution
) :
    AbstractProperty<DataType>(resolution)
{
    TBTKAssert(
        lowerBound <= upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be less or equal to the 'upperBound=" << upperBound
        << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    double lowerBound,
    double upperBound,
    unsigned int resolution,
    const DataType *data
) :
    AbstractProperty<DataType>(resolution, data)
{
    TBTKAssert(
        lowerBound <= upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be less or equal to the 'upperBound=" << upperBound
        << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    const std::vector<int> &ranges,
    double lowerBound,
    double upperBound,
    unsigned int resolution
) :
    AbstractProperty<DataType>(ranges, resolution)
{
    TBTKAssert(
        lowerBound <= upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be less or equal to the 'upperBound=" << upperBound
        << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    const std::vector<int> &ranges,
    double lowerBound,
    double upperBound,
    unsigned int resolution,
    const DataType *data
) :
    AbstractProperty<DataType>(ranges, resolution, data)
{
    TBTKAssert(
        lowerBound <= upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be less or equal to the 'upperBound=" << upperBound
        << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    const IndexTree &indexTree,
    double lowerBound,
    double upperBound,
    unsigned int resolution
) :
    AbstractProperty<DataType>(indexTree, resolution)
{
    TBTKAssert(
        lowerBound <= upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be less or equal to the 'upperBound=" << upperBound
        << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    const IndexTree &indexTree,
    double lowerBound,
    double upperBound,
    unsigned int resolution,
    const DataType *data
) :
    AbstractProperty<DataType>(indexTree, resolution, data)
{
    TBTKAssert(
        lowerBound < upperBound,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
        " must be smaller than the 'upperBound=" << upperBound << "'.",
        ""
    );
    TBTKAssert(
        resolution > 0,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "The 'resolution' must be larger than 0.",
        ""
    );
 
    energyType = EnergyType::Real;
    descriptor.realEnergy.lowerBound = lowerBound;
    descriptor.realEnergy.upperBound = upperBound;
    descriptor.realEnergy.resolution = resolution;
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    EnergyType energyType,
    const IndexTree &indexTree,
    int lowerMatsubaraEnergyIndex,
    int upperMatsubaraEnergyIndex,
    double fundamentalMatsubaraEnergy
) :
    AbstractProperty<DataType>(
        indexTree,
        (upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2 + 1
    )
{
    TBTKAssert(
        lowerMatsubaraEnergyIndex <= upperMatsubaraEnergyIndex,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid Matsubara energy bounds. The"
        " 'lowerMatsubaraEnergyIndex=" << lowerMatsubaraEnergyIndex
        << "' must be less or equal to the 'upperMatsubaraEnergyIndex="
        << upperMatsubaraEnergyIndex << "'.",
        ""
    );
    TBTKAssert(
        fundamentalMatsubaraEnergy > 0,
        "EnergyResolvedProperty::energyResolvedProperty()",
        "The 'fundamentalMatsubaraEnergy' must be larger than 0.",
        ""
    );
 
    switch(energyType){
    case EnergyType::FermionicMatsubara:
        TBTKAssert(
            abs(lowerMatsubaraEnergyIndex%2) == 1,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'lowerMatsubaraEnergyIndex="
            << lowerMatsubaraEnergyIndex << "' must be odd for"
            << " EnergyType::FermionicMatsubara.",
            ""
        );
        TBTKAssert(
            abs(upperMatsubaraEnergyIndex%2) == 1,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'upperMatsubaraEnergyIndex="
            << upperMatsubaraEnergyIndex << "' must be odd for"
            << " EnergyType::FermionicMatsubara.",
            ""
        );
 
        this->energyType = energyType;
        descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            = lowerMatsubaraEnergyIndex;
        descriptor.matsubaraEnergy.numMatsubaraEnergies = (
            upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
            + 1;
        descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            = fundamentalMatsubaraEnergy;
 
        break;
    case EnergyType::BosonicMatsubara:
        TBTKAssert(
            lowerMatsubaraEnergyIndex%2 == 0,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'lowerMatsubaraEnergyIndex="
            << lowerMatsubaraEnergyIndex << "' must be even for"
            << " EnergyType::BosonicMatsubara.",
            ""
        );
        TBTKAssert(
            upperMatsubaraEnergyIndex%2 == 0,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'upperMatsubaraEnergyIndex="
            << upperMatsubaraEnergyIndex << "' must be even for"
            << " EnergyType::BosonicMatsubara.",
            ""
        );
 
        this->energyType = energyType;
        descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            = lowerMatsubaraEnergyIndex;
        descriptor.matsubaraEnergy.numMatsubaraEnergies = (
            upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
            + 1;
        descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            = fundamentalMatsubaraEnergy;
 
        break;
    default:
        TBTKExit(
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'energyType' must be"
            " EnergyType::FermionicMatsubara or"
            " EnergyType::BosonicMatsubara.",
            ""
        );
    }
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    EnergyType energyType,
    const IndexTree &indexTree,
    int lowerMatsubaraEnergyIndex,
    int upperMatsubaraEnergyIndex,
    double fundamentalMatsubaraEnergy,
    const DataType *data
) :
    AbstractProperty<DataType>(
        indexTree,
        (upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2 + 1,
        data
    )
{
    TBTKAssert(
        lowerMatsubaraEnergyIndex <= upperMatsubaraEnergyIndex,
        "EnergyResolvedProperty::EnergyResolvedProperty()",
        "Invalid Matsubara energy bounds. The"
        " 'lowerMatsubaraEnergyIndex=" << lowerMatsubaraEnergyIndex
        << "' must be less or equal to the 'upperMatsubaraEnergyIndex="
        << upperMatsubaraEnergyIndex << "'.",
        ""
    );
    TBTKAssert(
        fundamentalMatsubaraEnergy > 0,
        "EnergyResolvedProperty::energyResolvedProperty()",
        "The 'fundamentalMatsubaraEnergy' must be larger than 0.",
        ""
    );
 
    switch(energyType){
    case EnergyType::FermionicMatsubara:
        TBTKAssert(
            abs(lowerMatsubaraEnergyIndex%2) == 1,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'lowerMatsubaraEnergyIndex="
            << lowerMatsubaraEnergyIndex << "' must be odd for"
            << " EnergyType::FermionicMatsubara.",
            ""
        );
        TBTKAssert(
            abs(upperMatsubaraEnergyIndex%2) == 1,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'uppererMatsubaraEnergyIndex="
            << upperMatsubaraEnergyIndex << "' must be odd for"
            << " EnergyType::FermionicMatsubara.",
            ""
        );
 
        this->energyType = energyType;
        descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            = lowerMatsubaraEnergyIndex;
        descriptor.matsubaraEnergy.numMatsubaraEnergies = (
            upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
            + 1;
        descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            = fundamentalMatsubaraEnergy;
 
        break;
    case EnergyType::BosonicMatsubara:
        TBTKAssert(
            lowerMatsubaraEnergyIndex%2 == 0,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'lowerMatsubaraEnergyIndex="
            << lowerMatsubaraEnergyIndex << "' must be even for"
            << " EnergyType::BosonicMatsubara.",
            ""
        );
        TBTKAssert(
            upperMatsubaraEnergyIndex%2 == 0,
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'uppererMatsubaraEnergyIndex="
            << upperMatsubaraEnergyIndex << "' must be even for"
            << " EnergyType::BosonicMatsubara.",
            ""
        );
 
        this->energyType = energyType;
        descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            = lowerMatsubaraEnergyIndex;
        descriptor.matsubaraEnergy.numMatsubaraEnergies = (
            upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
            + 1;
        descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            = fundamentalMatsubaraEnergy;
 
        break;
    default:
        TBTKExit(
            "EnergyResolvedProperty::EnergyResolvedProperty()",
            "The 'energyType' must be"
            " EnergyType::FermionicMatsubara or"
            " EnergyType::BosonicMatsubara.",
            ""
        );
    }
}
 
template<typename DataType>
EnergyResolvedProperty<DataType>::EnergyResolvedProperty(
    const std::string &serialization,
    Serializable::Mode mode
) :
    AbstractProperty<DataType>(
        Serializable::extract(
            serialization,
            mode,
            "abstractProperty"
        ),
        mode
    )
{
    TBTKAssert(
        Serializable::validate(serialization, "EnergyResolvedProperty", mode),
        "Property::EnergyResolvedProperty::EnergyResolvedProperty()",
        "Unable to parse string as EnergyResolvedProperty '"
        << serialization << "'.",
        ""
    );
 
    switch(mode){
    case Serializable::Mode::JSON:
        try{
            nlohmann::json j = nlohmann::json::parse(serialization);
            std::string et = j.at("energyType").get<std::string>();
            if(et.compare("Real") == 0){
                energyType = EnergyType::Real;
                descriptor.realEnergy.lowerBound
                    = j.at("lowerBound").get<double>();
                descriptor.realEnergy.upperBound
                    = j.at("upperBound").get<double>();
                descriptor.realEnergy.resolution
                    = j.at("resolution").get<double>();
            }
            else if(et.compare("FermionicMatsubara") == 0){
                energyType = EnergyType::FermionicMatsubara;
                descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
                    = j.at("lowerMatsubaraEnergyIndex");
                descriptor.matsubaraEnergy.numMatsubaraEnergies
                    = j.at("numMatsubaraEnergies");
                descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
                    = j.at("fundamentalMatsubaraEnergy");
            }
            else if(et.compare("BosonicMatsubara") == 0){
                energyType = EnergyType::BosonicMatsubara;
                descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
                    = j.at("lowerMatsubaraEnergyIndex");
                descriptor.matsubaraEnergy.numMatsubaraEnergies
                    = j.at("numMatsubaraEnergies");
                descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
                    = j.at("fundamentalMatsubaraEnergy");
            }
        }
        catch(nlohmann::json::exception &e){
            TBTKExit(
                "Proerty::EnergyResolvedProperty::EnergyResolvedProperty()",
                "Unable to parse string as"
                << " EnergyResolvedProperty '" << serialization
                << "'.",
                ""
            );
        }
 
        break;
    default:
        TBTKExit(
            "Property::EnergyResolvedProperty::EnergyResolvedProperty()",
            "Only Serializable::Mode::JSON is supported yet.",
            ""
        );
    }
}
 
template<typename DataType>
inline typename EnergyResolvedProperty<DataType>::EnergyType
EnergyResolvedProperty<DataType>::getEnergyType() const{
    return energyType;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getLowerBound() const{
    TBTKAssert(
        energyType == EnergyType::Real,
        "EnergyResolvedProperty::getLowerBound()",
        "The Property is not of the type EnergyType::Real.",
        ""
    );
 
    return descriptor.realEnergy.lowerBound;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getUpperBound() const{
    TBTKAssert(
        energyType == EnergyType::Real,
        "EnergyResolvedProperty::getUpperBound()",
        "The Property is not of the type EnergyType::Real.",
        ""
    );
 
    return descriptor.realEnergy.upperBound;
}
 
template<typename DataType>
inline unsigned int EnergyResolvedProperty<DataType>::getResolution() const{
    TBTKAssert(
        energyType == EnergyType::Real,
        "EnergyResolvedProperty::getResolution()",
        "The Property is not of the type EnergyType::Real.",
        ""
    );
 
    return descriptor.realEnergy.resolution;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getDeltaE() const{
    TBTKAssert(
        energyType == EnergyType::Real,
        "EnergyResolvedProperty::getDeltaE()",
        "The Property is not of the type EnergyType::Real.",
        ""
    );
 
    double dE;
    if(descriptor.realEnergy.resolution == 1)
        dE = 0;
    else
        dE = (
            descriptor.realEnergy.upperBound
            - descriptor.realEnergy.lowerBound
        )/(descriptor.realEnergy.resolution - 1);
 
    return dE;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getEnergy(
    unsigned int n
) const{
    TBTKAssert(
        energyType == EnergyType::Real,
        "EnergyResolvedProperty::getEnergy()",
        "The Property is not of the type EnergyType::Real.",
        ""
    );
 
    return descriptor.realEnergy.lowerBound + ((int)n)*getDeltaE();
}
 
template<typename DataType>
inline int EnergyResolvedProperty<DataType>::getLowerMatsubaraEnergyIndex(
) const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getLowerMatsubaraEnergyIndex()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
}
 
template<typename DataType>
inline int EnergyResolvedProperty<DataType>::getUpperMatsubaraEnergyIndex(
) const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getUpperMatsubaraEnergyIndex()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
     + 2*(descriptor.matsubaraEnergy.numMatsubaraEnergies - 1);
}
 
template<typename DataType>
inline unsigned int EnergyResolvedProperty<DataType>::getNumMatsubaraEnergies() const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getNumMatsubaraEnergies()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return descriptor.matsubaraEnergy.numMatsubaraEnergies;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<
    DataType
>::getFundamentalMatsubaraEnergy() const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getFundamentalMatsubaraEnergy()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getLowerMatsubaraEnergy(
) const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getLowerMatsubaraEnergy()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
        *descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
}
 
template<typename DataType>
inline double EnergyResolvedProperty<DataType>::getUpperMatsubaraEnergy(
) const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getUpperMatsubaraEnergyIndex()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return (
            descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            + 2*(descriptor.matsubaraEnergy.numMatsubaraEnergies-1)
        )*descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
}
 
template<typename DataType>
inline std::complex<double> EnergyResolvedProperty<
    DataType
>::getMatsubaraEnergy(
    unsigned int n
) const{
    TBTKAssert(
        energyType == EnergyType::FermionicMatsubara
        || energyType == EnergyType::BosonicMatsubara,
        "EnergyResolvedProperty::getMatsubaraEnergy()",
        "The Property is not of the type"
        << " EnergyType::FermionicMatsubara or"
        << " EnergyType::BosonicMatsubara.",
        ""
    );
 
    return std::complex<double>(
        0,
        (descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex + 2*(int)n)
        *descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
    );
}
 
template<typename DataType>
inline unsigned int EnergyResolvedProperty<DataType>::getNumEnergies() const{
    switch(energyType){
    case EnergyType::Real:
        return getResolution();
    case EnergyType::FermionicMatsubara:
    case EnergyType::BosonicMatsubara:
        return getNumMatsubaraEnergies();
    default:
        TBTKExit(
            "Property::EnergyResolvedProperty::getNumEnergies()",
            "Unknown energy type.",
            "This should never happen, contact the developer."
        );
    }
}
 
template<typename DataType>
inline bool EnergyResolvedProperty<DataType>::energyWindowsAreEqual(
    const EnergyResolvedProperty &energyResolvedProperty,
    double precision
) const{
    if(energyType != energyResolvedProperty.energyType)
        return false;
 
    if(getNumEnergies() != energyResolvedProperty.getNumEnergies())
        return false;
 
    switch(energyType){
    case EnergyType::Real:
    {
        double lowerBound0 = getLowerBound();
        double upperBound0 = getUpperBound();
        double lowerBound1 = energyResolvedProperty.getLowerBound();
        double upperBound1 = energyResolvedProperty.getUpperBound();
        double dE = getDeltaE();
 
        if(std::abs(lowerBound0 - lowerBound1) > precision*dE)
            return false;
        if(std::abs(upperBound0 - upperBound1) > precision*dE)
            return false;
 
        return true;
    }
    case EnergyType::FermionicMatsubara:
    case EnergyType::BosonicMatsubara:
    {
        double lowerMatsubaraEnergy0 = getLowerMatsubaraEnergy();
        double upperMatsubaraEnergy0 = getUpperMatsubaraEnergy();
        double lowerMatsubaraEnergy1
            = energyResolvedProperty.getLowerMatsubaraEnergy();
        double upperMatsubaraEnergy1
            = energyResolvedProperty.getUpperMatsubaraEnergy();
        double dE;
        if(getNumEnergies() > 1)
            dE = imag(getMatsubaraEnergy(1) - getMatsubaraEnergy(0));
        else
            dE = 0;
 
        if(
            std::abs(lowerMatsubaraEnergy0 - lowerMatsubaraEnergy1)
                > precision*dE
        ){
            return false;
        }
        if(
            std::abs(upperMatsubaraEnergy0 - upperMatsubaraEnergy1)
            > precision*dE
        ){
            return false;
        }
 
        return true;
    }
    default:
        TBTKExit(
            "Property::EnergyResolvedProperty::energyWindowsAreEqual()",
            "Unknown energy type.",
            "This should never happen, contact the developer."
        );
    }
}
 
template<typename DataType>
inline std::string EnergyResolvedProperty<DataType>::serialize(
    Serializable::Mode mode
) const{
    switch(mode){
    case Serializable::Mode::JSON:
    {
        nlohmann::json j;
        j["id"] = "EnergyResolvedProperty";
        switch(energyType){
        case EnergyType::Real:
            j["energyType"] = "Real";
            j["lowerBound"] = descriptor.realEnergy.lowerBound;
            j["upperBound"] = descriptor.realEnergy.upperBound;
            j["resolution"] = descriptor.realEnergy.resolution;
 
            break;
        case EnergyType::FermionicMatsubara:
            j["energyType"] = "FermionicMatsubara";
            j["lowerMatsubaraEnergyIndex"]
                = descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
            j["numMatsubaraEnergies"]
                = descriptor.matsubaraEnergy.numMatsubaraEnergies;
            j["fundamentalMatsubaraEnergy"]
                = descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
 
            break;
        case EnergyType::BosonicMatsubara:
            j["energyType"] = "BosonicMatsubara";
            j["lowerMatsubaraEnergyIndex"]
                = descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
            j["numMatsubaraEnergies"]
                = descriptor.matsubaraEnergy.numMatsubaraEnergies;
            j["fundamentalMatsubaraEnergy"]
                = descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
 
            break;
        default:
            TBTKExit(
                "Property::EnergyResolvedProperty::serialize()",
                "Unknown EnergyType.",
                "This should never happen, contact the developer."
            );
        }
        j["abstractProperty"] = nlohmann::json::parse(
            AbstractProperty<DataType>::serialize(mode)
        );
 
        return j.dump();
    }
    default:
        TBTKExit(
            "Property::EnergyResolvedProperty::serialize()",
            "Only Serializable::Mode::JSON is supported yet.",
            ""
        );
    }
}
 
template<typename DataType>
inline EnergyResolvedProperty<DataType>&
EnergyResolvedProperty<DataType>::operator+=(
    const EnergyResolvedProperty<DataType> &rhs
){
    TBTKAssert(
        energyType == rhs.energyType,
        "Property::EnergyResolvedProperty::operator+=()",
        "Incompatible energy types.",
        ""
    );
 
    switch(energyType){
    case EnergyType::Real:
        TBTKAssert(
            descriptor.realEnergy.lowerBound
                == rhs.descriptor.realEnergy.lowerBound,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible energy bounds. The left hand side has"
            << " lower bound '" << descriptor.realEnergy.lowerBound
            << "', while the right hand side has lower bound '"
            << rhs.descriptor.realEnergy.lowerBound << "'.",
            ""
        );
        TBTKAssert(
            descriptor.realEnergy.upperBound
                == rhs.descriptor.realEnergy.upperBound,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible energy bounds. The left hand side has"
            << " upper bound '" << descriptor.realEnergy.upperBound
            << "', while the right hand side has upper bound '"
            << rhs.descriptor.realEnergy.upperBound << "'.",
            ""
        );
        TBTKAssert(
            descriptor.realEnergy.resolution
                == rhs.descriptor.realEnergy.resolution,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible energy resolution. The left hand side"
            << " has resolution '"
            << descriptor.realEnergy.resolution << "', while the"
            << " right hand side has resolution '"
            << rhs.descriptor.realEnergy.resolution << "'.",
            ""
        );
    case EnergyType::FermionicMatsubara:
    case EnergyType::BosonicMatsubara:
        TBTKAssert(
            descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
                == rhs.descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has lower Matsubara energy index '"
            << descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            << "', while the right hand side has lower Matsubara"
            << " energy index '"
            << rhs.descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex << "'.",
            ""
        );
        TBTKAssert(
            descriptor.matsubaraEnergy.numMatsubaraEnergies
                == rhs.descriptor.matsubaraEnergy.numMatsubaraEnergies,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has '"
            << descriptor.matsubaraEnergy.numMatsubaraEnergies
            << "' number of Matsubara energies, while the right"
            << " hand side has '"
            << rhs.descriptor.matsubaraEnergy.numMatsubaraEnergies
            << "' number of Matsubara energies.",
            ""
        );
        TBTKAssert(
            descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
                == rhs.descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy,
            "Property::EnergyResolvedProperty::operator+=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has fundamental Matsubara energy '"
            << descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            << "', while the right hand side has fundamental Matsubara"
            << " energy '"
            << rhs.descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            << "'.",
            ""
        );
    }
 
    AbstractProperty<DataType>::operator+=(rhs);
 
    return *this;
}
 
template<typename DataType>
inline EnergyResolvedProperty<DataType>&
EnergyResolvedProperty<DataType>::operator-=(
    const EnergyResolvedProperty<DataType> &rhs
){
    TBTKAssert(
        energyType == rhs.energyType,
        "Property::EnergyResolvedProperty::operator-=()",
        "Incompatible energy types.",
        ""
    );
 
    switch(energyType){
    case EnergyType::Real:
        TBTKAssert(
            descriptor.realEnergy.lowerBound
                == rhs.descriptor.realEnergy.lowerBound,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible energy bounds. The left hand side has"
            << " lower bound '" << descriptor.realEnergy.lowerBound
            << "', while the right hand side has lower bound '"
            << rhs.descriptor.realEnergy.lowerBound << "'.",
            ""
        );
        TBTKAssert(
            descriptor.realEnergy.upperBound
                == rhs.descriptor.realEnergy.upperBound,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible energy bounds. The left hand side has"
            << " upper bound '" << descriptor.realEnergy.upperBound
            << "', while the right hand side has upper bound '"
            << rhs.descriptor.realEnergy.upperBound << "'.",
            ""
        );
        TBTKAssert(
            descriptor.realEnergy.resolution
                == rhs.descriptor.realEnergy.resolution,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible energy resolution. The left hand side"
            << " has resolution '"
            << descriptor.realEnergy.resolution << "', while the"
            << " right hand side has resolution '"
            << rhs.descriptor.realEnergy.resolution << "'.",
            ""
        );
    case EnergyType::FermionicMatsubara:
    case EnergyType::BosonicMatsubara:
        TBTKAssert(
            descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
                == rhs.descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has lower Matsubara energy index '"
            << descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
            << "', while the right hand side has lower Matsubara"
            << " energy index '"
            << rhs.descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex << "'.",
            ""
        );
        TBTKAssert(
            descriptor.matsubaraEnergy.numMatsubaraEnergies
                == rhs.descriptor.matsubaraEnergy.numMatsubaraEnergies,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has '"
            << descriptor.matsubaraEnergy.numMatsubaraEnergies
            << "' number of Matsubara energies, while the right"
            << " hand side has '"
            << rhs.descriptor.matsubaraEnergy.numMatsubaraEnergies
            << "' number of Matsubara energies.",
            ""
        );
        TBTKAssert(
            descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
                == rhs.descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy,
            "Property::EnergyResolvedProperty::operator-=()",
            "Incompatible Matsubara energies. The left hand side"
            << " has fundamental Matsubara energy '"
            << descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            << "', while the right hand side has fundamental Matsubara"
            << " energy '"
            << rhs.descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
            << "'.",
            ""
        );
    }
 
    AbstractProperty<DataType>::operator-=(rhs);
 
    return *this;
}
 
template<typename DataType>
inline EnergyResolvedProperty<DataType>&
EnergyResolvedProperty<DataType>::operator*=(
    const DataType &rhs
){
    AbstractProperty<DataType>::operator*=(rhs);
 
    return *this;
}
 
template<typename DataType>
inline EnergyResolvedProperty<DataType>&
EnergyResolvedProperty<DataType>::operator/=(
    const DataType &rhs
){
    AbstractProperty<DataType>::operator/=(rhs);
 
    return *this;
}
 
};  //End namespace Property
};  //End namespace TBTK
 
#endif