AmplitudeSet.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_AMPLITUDE_SET
#define COM_DAFER45_TBTK_AMPLITUDE_SET

#include "HoppingAmplitude.h"
#include "TreeNode.h"
#include "Streams.h"
#include "TBTKMacros.h"

#include <vector>
#include <complex>

namespace TBTK{

class AmplitudeSet{
public:
    TreeNode tree;

    AmplitudeSet();

    ~AmplitudeSet();

    void addHA(HoppingAmplitude ha);

    void addHAAndHC(HoppingAmplitude ha);

    const std::vector<HoppingAmplitude>* getHAs(Index index) const;

    int getBasisIndex(const Index &index) const;

    int getBasisSize() const;

    bool isProperSubspace(const Index &subspace);

    void construct();

    bool getIsConstructed() const;

    void sort();

    void constructCOO();

    void destructCOO();

    void reconstructCOO();

    int getNumMatrixElements() const;

    const int* getCOORowIndices() const;

    const int* getCOOColIndices() const;

    const std::complex<double>* getCOOValues() const;

    class Iterator{
    public:
        ~Iterator();

        void reset();

        void searchNextHA();

        const HoppingAmplitude* getHA() const;
    private:
        friend class AmplitudeSet;

        Iterator(const TreeNode *tree);

        TreeNode::Iterator* it;
    };

    AmplitudeSet::Iterator getIterator() const;

    AmplitudeSet::Iterator getIterator(const Index &subspace) const;

    void print();

    void tabulate(
        std::complex<double> **amplitudes,
        int **indices,
        int *numHoppingAmplitudes,
        int *maxIndexSize
    ) const;
private:
    bool isConstructed;

    bool isSorted;

    int numMatrixElements;

    int *cooRowIndices;

    int *cooColIndices;

    std::complex<double> *cooValues;
};

inline void AmplitudeSet::addHA(HoppingAmplitude ha){
    tree.add(ha);
}

inline void AmplitudeSet::addHAAndHC(HoppingAmplitude ha){
    tree.add(ha);
    tree.add(ha.getHermitianConjugate());
}

inline const std::vector<HoppingAmplitude>* AmplitudeSet::getHAs(Index index) const{
    return tree.getHAs(index);
}

inline int AmplitudeSet::getBasisIndex(const Index &index) const{
    return tree.getBasisIndex(index);
}

inline int AmplitudeSet::getBasisSize() const{
    return tree.basisSize;
}

inline bool AmplitudeSet::isProperSubspace(const Index &subspace){
    return tree.isProperSubspace(subspace);
}

inline void AmplitudeSet::construct(){
    TBTKAssert(
        !isConstructed,
        "AmplitudeSet::construct()",
        "AmplitudeSet is already constructed.",
        ""
    );

    tree.generateBasisIndices();
    isConstructed = true;
}

inline bool AmplitudeSet::getIsConstructed() const{
    return isConstructed;
}

inline void AmplitudeSet::sort(){
    TBTKAssert(
        isConstructed,
        "AmplitudeSet::sort()",
        "AmplitudeSet has to be constructed first.",
        ""
    );

    if(!isSorted){
        tree.sort(&tree);
        isSorted = true;
    }
}

inline const int* AmplitudeSet::getCOORowIndices() const{
    return cooRowIndices;
}

inline const int* AmplitudeSet::getCOOColIndices() const{
    return cooColIndices;
}

inline const std::complex<double>* AmplitudeSet::getCOOValues() const{
    return cooValues;
}

};  //End of namespace TBTK

#endif