BoundaryCondition.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_BOUNDARY_CONDITION
#define COM_DAFER45_TBTK_BOUNDARY_CONDITION

#include "TBTK/HoppingAmplitude.h"
#include "TBTK/HoppingAmplitudeList.h"
#include "TBTK/Serializable.h"
#include "TBTK/SourceAmplitude.h"

#include <vector>

namespace TBTK{

class BoundaryCondition : public Serializable{
public:
    BoundaryCondition();

    BoundaryCondition(
        const std::string &serializeation,
        Serializable::Mode mode
    );

    void add(const HoppingAmplitude &hoppingAmplitude);

    const HoppingAmplitudeList& getHoppingAmplitudeList() const;

    void set(const SourceAmplitude &sourceAmplitude);

    const SourceAmplitude& getSourceAmplitude() const;

    void setEliminationIndex(const Index &eliminationIndex);

    const Index& getEliminationIndex() const;

    std::string serialize(Serializable::Mode mode) const;

    unsigned int getSizeInBytes() const;
private:
    HoppingAmplitudeList hoppingAmplitudeList;

    SourceAmplitude sourceAmplitude;

    Index eliminationIndex;
};

inline BoundaryCondition::BoundaryCondition(){
}

inline void BoundaryCondition::add(const HoppingAmplitude &hoppingAmplitude){
    if(hoppingAmplitudeList.getSize() > 0){
        TBTKAssert(
            hoppingAmplitude.getToIndex().equals(
                hoppingAmplitudeList[0].getToIndex()
            ),
            "BoundaryCondition::add()",
            "Incompatible to-Indices. All HoppingAmplitudes in a"
            << " BoundaryCondition must have the same to-Index."
            << " The added HoppingAmplitude has to-Index '"
            << hoppingAmplitude.getToIndex().toString() << "'"
            << " while a HoppingAmplitude with to-Index '"
            << hoppingAmplitudeList[0].getToIndex().toString()
            << "' already has been added.",
            ""
        );
    }
    else{
        if(!sourceAmplitude.getIndex().equals({})){
            TBTKAssert(
                hoppingAmplitude.getToIndex().equals(
                    sourceAmplitude.getIndex()
                ),
                "BoundaryCondition::add()",
                "Incompatible Indices. The HoppingAmplitude"
                << " must have the same to-Index as the Index"
                << " of the SourceAmplitude. The"
                << " HoppingAmplitude has to-Index '"
                << hoppingAmplitude.getToIndex().toString()
                << "' while the SourceAmplitude has Index '"
                << sourceAmplitude.getIndex().toString() << "'.",
                ""
        );
        }
    }

    hoppingAmplitudeList.add(hoppingAmplitude);
}

inline const HoppingAmplitudeList& BoundaryCondition::getHoppingAmplitudeList() const{
    return hoppingAmplitudeList;
}

inline void BoundaryCondition::set(const SourceAmplitude &sourceAmplitude){
    TBTKAssert(
        !sourceAmplitude.getIndex().equals({}),
        "BoundaryCondition::set()",
        "Invalid Index. The SourceAmplitudes Index cannot be the empty"
        << "Index.",
        ""
    );
    if(hoppingAmplitudeList.getSize() > 0){
        TBTKAssert(
            sourceAmplitude.getIndex().equals(
                hoppingAmplitudeList[0].getToIndex()
            ),
            "BoundaryCondition::set()",
            "Incompatible Indices. The SourceAmplitude must have"
            << " the same Index as the HoppingAmplitudes"
            << " to-Indices. The SourceAmplitude has Index '"
            << sourceAmplitude.getIndex().toString() << "' while a"
            << " HoppingAmplitude with to-Index '"
            << hoppingAmplitudeList[0].getToIndex().toString()
            << "' already has been added.",
            ""
        );
    }

    this->sourceAmplitude = sourceAmplitude;
}

inline const SourceAmplitude& BoundaryCondition::getSourceAmplitude() const{
    return sourceAmplitude;
}

inline void BoundaryCondition::setEliminationIndex(const Index &eliminationIndex){
    bool eliminationIndexFound = false;
    for(unsigned int n = 0; n < hoppingAmplitudeList.getSize(); n++){
        if(
            hoppingAmplitudeList[n].getFromIndex().equals(
                eliminationIndex
            )
        ){
            eliminationIndexFound = true;
            break;
        }
    }
    TBTKAssert(
        eliminationIndexFound,
        "BoundaryCondition::setEliminationIndex()",
        "Invalid elimination Index. The elimination Index must be"
        << " equal to the from-Index of at least one HoppingAmplitude"
        << " added to the BoundaryCondition but no such from-Index was"
        << " found.",
        "First add HoppingAmplitudes using BoundaryCondition::add()"
    );

    this->eliminationIndex = eliminationIndex;
}

inline const Index& BoundaryCondition::getEliminationIndex() const{
    return eliminationIndex;
}

inline unsigned int BoundaryCondition::getSizeInBytes() const{
    return sizeof(*this)
        + hoppingAmplitudeList.getSizeInBytes() - sizeof(hoppingAmplitudeList)
        + sourceAmplitude.getSizeInBytes() - sizeof(sourceAmplitude)
        + eliminationIndex.getSizeInBytes() - sizeof(eliminationIndex);
}

};  //End of namespace TBTK

#endif