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