Model.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_MODEL
#define COM_DAFER45_TBTK_MODEL

#include "TBTK/AbstractHoppingAmplitudeFilter.h"
#include "TBTK/AbstractIndexFilter.h"
#include "TBTK/Communicator.h"
#include "TBTK/Geometry.h"
#include "TBTK/HoppingAmplitudeList.h"
#include "TBTK/HoppingAmplitudeSet.h"
#include "TBTK/IndexBasedHoppingAmplitudeFilter.h"
#include "TBTK/SingleParticleContext.h"
#include "TBTK/ManyParticleContext.h"
#include "TBTK/Serializable.h"
#include "TBTK/Statistics.h"
#include "TBTK/Streamable.h"

#include <complex>
#include <fstream>
#include <string>
#include <tuple>

namespace TBTK{

class FileReader;

class Model : public Serializable, public Communicator, public Streamable{
public:
    Model();

    Model(const std::vector<unsigned int> &capacity);

    Model(const Model &model);

    Model(Model &&model);

    Model(const std::string &serialization, Mode mode);

    virtual ~Model();

    Model& operator=(const Model &rhs);

    Model& operator=(Model &&rhs);

    void add(HoppingAmplitude ha);

    void addModel(const Model &model, const Index &subsytemIndex);

    int getBasisIndex(const Index &index) const;

    int getBasisSize() const;

    void generateHoppingAmplitudeSet(
        const HoppingAmplitude::AmplitudeCallback
            &hoppingAmplitudeCallback
    );

    void generateOverlapAmplitudeSet(
        const OverlapAmplitude::AmplitudeCallback
            &overlapAmplitudeCallback
    );

    void construct();

    bool getIsConstructed();

    void setTemperature(double temperature);

    double getTemperature() const;

    void setChemicalPotential(double chemicalPotential);

    double getChemicalPotential() const;

    void setStatistics(Statistics statistics);

    Statistics getStatistics() const;

    const BasisStateSet& getBasisStateSet() const;

    const HoppingAmplitudeSet& getHoppingAmplitudeSet() const;

    const SourceAmplitudeSet& getSourceAmplitudeSet() const;

    const OverlapAmplitudeSet& getOverlapAmplitudeSet() const;

    Geometry& getGeometry();

    const Geometry& getGeometry() const;

    void createManyParticleContext();

    ManyParticleContext* getManyParticleContext();

    void setFilter(
        const AbstractHoppingAmplitudeFilter &hoppingAmplitudeFilter
    );

    void setFilter(
        const AbstractIndexFilter &indexFilter
    );

    Model& operator<<(const AbstractState &basisState);

    Model& operator<<(const HoppingAmplitude& hoppingAmplitude);

    Model& operator<<(
        const std::tuple<HoppingAmplitude, HoppingAmplitude> &hoppingAmplitudes
    );

    Model& operator<<(const HoppingAmplitudeList& hoppingAmplitudeList);

    Model& operator<<(const SourceAmplitude& sourceAmplitude);

    Model& operator<<(const OverlapAmplitude& overlapAmplitudeSet);

    virtual std::string toString() const;

    std::string serialize(Mode mode) const;
private:
    double temperature;

    double chemicalPotential;

    SingleParticleContext singleParticleContext;

    ManyParticleContext *manyParticleContext;

    AbstractIndexFilter *indexFilter;

    AbstractHoppingAmplitudeFilter *hoppingAmplitudeFilter;

    friend class FileReader;
};

inline void Model::add(HoppingAmplitude ha){
    singleParticleContext.getHoppingAmplitudeSet().add(ha);
}

inline int Model::getBasisSize() const{
    return singleParticleContext.getHoppingAmplitudeSet().getBasisSize();
}

inline void Model::generateHoppingAmplitudeSet(
    const HoppingAmplitude::AmplitudeCallback &hoppingAmplitudeCallback
){
    singleParticleContext.generateHoppingAmplitudeSet(
        hoppingAmplitudeCallback
    );
}

inline void Model::generateOverlapAmplitudeSet(
    const OverlapAmplitude::AmplitudeCallback &overlapAmplitudeCallback
){
    singleParticleContext.generateOverlapAmplitudeSet(
        overlapAmplitudeCallback
    );
}

inline int Model::getBasisIndex(const Index &index) const{
    return singleParticleContext.getHoppingAmplitudeSet().getBasisIndex(index);
}

inline bool Model::getIsConstructed(){
    return singleParticleContext.getHoppingAmplitudeSet().getIsConstructed();
}

inline void Model::setTemperature(double temperature){
    this->temperature = temperature;
}

inline double Model::getTemperature() const{
    return temperature;
}

inline void Model::setChemicalPotential(double chemicalPotential){
    this->chemicalPotential = chemicalPotential;
}

inline double Model::getChemicalPotential() const{
    return chemicalPotential;
}

inline void Model::setStatistics(Statistics statistics){
    singleParticleContext.setStatistics(statistics);
}

inline Statistics Model::getStatistics() const{
    return singleParticleContext.getStatistics();
}

inline const BasisStateSet& Model::getBasisStateSet() const{
    return singleParticleContext.getBasisStateSet();
}

inline const HoppingAmplitudeSet& Model::getHoppingAmplitudeSet() const{
    return singleParticleContext.getHoppingAmplitudeSet();
}

inline const SourceAmplitudeSet& Model::getSourceAmplitudeSet() const{
    return singleParticleContext.getSourceAmplitudeSet();
}

inline const OverlapAmplitudeSet& Model::getOverlapAmplitudeSet() const{
    return singleParticleContext.getOverlapAmplitudeSet();
}

inline Geometry& Model::getGeometry(){
    return singleParticleContext.getGeometry();
}

inline const Geometry& Model::getGeometry() const{
    return singleParticleContext.getGeometry();
}

inline void Model::createManyParticleContext(){
    manyParticleContext = new ManyParticleContext(&singleParticleContext);
}

inline ManyParticleContext* Model::getManyParticleContext(){
    return manyParticleContext;
}

inline void Model::setFilter(
    const AbstractHoppingAmplitudeFilter &hoppingAmplitudeFilter
){
    if(this->hoppingAmplitudeFilter != nullptr)
        delete this->hoppingAmplitudeFilter;

    this->hoppingAmplitudeFilter = hoppingAmplitudeFilter.clone();
}

inline void Model::setFilter(
    const AbstractIndexFilter &indexFilter
){
    if(this->indexFilter != nullptr)
        delete this->indexFilter;
    this->indexFilter = indexFilter.clone();

    if(this->hoppingAmplitudeFilter != nullptr)
        delete this->hoppingAmplitudeFilter;

    this->hoppingAmplitudeFilter = new IndexBasedHoppingAmplitudeFilter(
        indexFilter
    );
}

inline Model& Model::operator<<(const AbstractState &basisState){
    singleParticleContext.getBasisStateSet().add(basisState);

    return *this;
}

inline Model& Model::operator<<(const HoppingAmplitude &hoppingAmplitude){
    if(
        hoppingAmplitudeFilter == nullptr
        || hoppingAmplitudeFilter->isIncluded(hoppingAmplitude)
    ){
        add(hoppingAmplitude);
    }

    return *this;
}

inline Model& Model::operator<<(const std::tuple<HoppingAmplitude, HoppingAmplitude> &hoppingAmplitudes){
    if(
        hoppingAmplitudeFilter == nullptr
    ){
        add(std::get<0>(hoppingAmplitudes));
        add(std::get<1>(hoppingAmplitudes));
    }
    else{
        if(
            hoppingAmplitudeFilter->isIncluded(
                std::get<0>(hoppingAmplitudes)
            )
        ){
            add(std::get<0>(hoppingAmplitudes));
        }
        if(
            hoppingAmplitudeFilter->isIncluded(
                std::get<1>(hoppingAmplitudes)
            )
        ){
            add(std::get<1>(hoppingAmplitudes));
        }
    }

    return *this;
}

inline Model& Model::operator<<(const HoppingAmplitudeList &hoppingAmplitudeList){
    for(unsigned int n = 0; n < hoppingAmplitudeList.getSize(); n++)
        add(hoppingAmplitudeList[n]);

    return *this;
}

inline Model& Model::operator<<(const SourceAmplitude &sourceAmplitude){
    if(
        indexFilter == nullptr
        || indexFilter->isIncluded(sourceAmplitude.getIndex())
    ){
        singleParticleContext.getSourceAmplitudeSet().add(
            sourceAmplitude
        );
    }

    return *this;
}

inline Model& Model::operator<<(const OverlapAmplitude &overlapAmplitude){
    if(
        indexFilter == nullptr
        || (
            indexFilter->isIncluded(overlapAmplitude.getBraIndex())
            && indexFilter->isIncluded(
                overlapAmplitude.getKetIndex()
            )
        )
    ){
        singleParticleContext.getOverlapAmplitudeSet().add(
            overlapAmplitude
        );
    }

    return *this;
}

};  //End of namespace TBTK

#endif