FockState.h

/* 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_FOCK_STATE
#define COM_DAFER45_TBTK_FOCK_STATE
 
#include "TBTK/Streams.h"
 
namespace TBTK{
 
template<typename BIT_REGISTER>
class FockSpace;
 
template<typename BIT_REGISTER>
class LadderOperator;
 
template<typename BIT_REGISTER>
class FockState{
public:
    FockState(unsigned int exponentialDimension);
 
    FockState(const FockState &fockState);
 
    ~FockState();
 
    bool isNull() const;
 
    const BIT_REGISTER& getBitRegister() const;
 
    BIT_REGISTER& getBitRegister();
 
    int getPrefactor() const;
 
//  unsigned int getNumFermions() const;
 
    void print() const;
private:
    friend class FockSpace<BIT_REGISTER>;
 
    friend class LadderOperator<BIT_REGISTER>;
 
    BIT_REGISTER bitRegister;
 
    int prefactor;
};
 
template<typename BIT_REGISTER>
FockState<BIT_REGISTER>::FockState(unsigned int exponentialDimension
) :
    bitRegister(exponentialDimension+1)
{
    bitRegister.clear();
    prefactor = 1;
}
 
template<typename BIT_REGISTER>
FockState<BIT_REGISTER>::FockState(const FockState &fockState
) :
    bitRegister(fockState.bitRegister)
{
    prefactor = fockState.prefactor;
}
 
template<typename BIT_REGISTER>
FockState<BIT_REGISTER>::~FockState(){
}
 
template<typename BIT_REGISTER>
bool FockState<BIT_REGISTER>::isNull() const{
    return bitRegister.getMostSignificantBit();
}
 
template<typename BIT_REGISTER>
const BIT_REGISTER& FockState<BIT_REGISTER>::getBitRegister() const{
    return bitRegister;
}
 
template<typename BIT_REGISTER>
BIT_REGISTER& FockState<BIT_REGISTER>::getBitRegister(){
    return bitRegister;
}
 
template<typename BIT_REGISTER>
int FockState<BIT_REGISTER>::getPrefactor() const{
    return prefactor;
}
 
/*template<typename BIT_REGISTER>
unsigned int FockState<BIT_REGISTER>::getNumFermions() const{
    return bitRegister.getNumOneBits();
}*/
 
template<typename BIT_REGISTER>
void FockState<BIT_REGISTER>::print() const{
    Streams::out << prefactor << "|";
    for(int n = bitRegister.getNumBits()-1; n >= 0; n--){
        Streams::out << bitRegister.getBit(n);
        if(n%8 == 0 && n != 0)
            Streams::out << " ";
    }
    Streams::out << ">\n";
}
 
};  //End of namespace TBTK
 
#endif