Bond.hpp

Go to the documentation of this file.

#ifndef _H_Bond_
#define _H_Bond_
 
#include "Type.hpp"
#include "Symmetry.hpp"
#include "cytnx_error.hpp"
#include <initializer_list>
#include <vector>
#include <fstream>
#include "intrusive_ptr_base.hpp"
#include "utils/vec_clone.hpp"
namespace cytnx{
    enum bondType: int{
        BD_KET = -1,
        BD_BRA = 1,
        BD_REG =0
    };
    class Bond_impl: public intrusive_ptr_base<Bond_impl>{
        private:
 
        public:
            friend class Bond;
            cytnx_uint64 _dim;
            bondType _type;
            std::vector< std::vector<cytnx_int64> > _qnums; //(dim, # of sym)
            std::vector<Symmetry> _syms;
 
            Bond_impl(): _type(bondType::BD_REG) {};   
 
            void Init(const cytnx_uint64 &dim, const bondType &bd_type=bondType::BD_REG, const std::vector<std::vector<cytnx_int64> > &in_qnums = {}, const std::vector<Symmetry> &in_syms={});
 
 
            bondType                                type() const{return this->_type;};
            const std::vector<std::vector<cytnx_int64> >& qnums() const{return this->_qnums;}
            std::vector<std::vector<cytnx_int64> >& qnums(){return this->_qnums;}
            const cytnx_uint64&                             dim() const{return this->_dim;}
            cytnx_uint32                           Nsym() const{return this->_syms.size();}
            const std::vector<Symmetry>&                   syms() const{return this->_syms;}
            std::vector<Symmetry>& syms(){return this->_syms;}
 
            //this is clone return.
            std::vector<std::vector<cytnx_int64> > qnums_clone() const{return this->_qnums;}
            std::vector<Symmetry> syms_clone() const{return vec_clone(this->_syms);}
 
 
            void set_type(const bondType &new_bondType){
                if((this->_type != BD_REG) && (new_bondType == BD_REG)){
                    cytnx_error_msg(this->_qnums.size(),"[ERROR] cannot change type to BD_REG for a symmetry bond.%s","\n");
                }
                this->_type = new_bondType;
            }
 
            void clear_type(){
                if(this->_type != BD_REG){
                    cytnx_error_msg(this->_qnums.size(),"[ERROR] cannot clear type for a symmetry bond.%s","\n");
                }
                this->_type = bondType::BD_REG;
            }
 
            
            boost::intrusive_ptr<Bond_impl> clone(){
                boost::intrusive_ptr<Bond_impl> out(new Bond_impl());
                out->_dim = this->dim();
                out->_type = this->type();
                out->_qnums = this->qnums_clone();
                out->_syms  = this->syms_clone();// return a clone of vec!
                return out;
            }
 
            void combineBond_(const boost::intrusive_ptr<Bond_impl> &bd_in);
 
    
            boost::intrusive_ptr<Bond_impl> combineBond(const boost::intrusive_ptr<Bond_impl> &bd_in){
                boost::intrusive_ptr<Bond_impl> out = this->clone();
                out->combineBond_(bd_in);
                return out;
            }
 
            // return a sorted qnums by removing all duplicates, sorted from large to small.
            std::vector<std::vector<cytnx_int64> > getUniqueQnums(std::vector<cytnx_uint64> &counts, const bool &return_counts);
 
            // return the degeneracy of the specify qnum set.
            cytnx_uint64 getDegeneracy(const std::vector<cytnx_int64> &qnum, const bool &return_indices,std::vector<cytnx_uint64> &indices);
 
            // return the effective qnums when Bra-Ket mismatch. 
            std::vector<std::vector<cytnx_int64> > calc_reverse_qnums();
 
 
    };//Bond_impl
 
    class Bond{
        public:
            boost::intrusive_ptr<Bond_impl> _impl;
            Bond(): _impl(new Bond_impl()){};
            Bond(const Bond&rhs){this->_impl = rhs._impl;}
            Bond& operator=(const Bond &rhs){this->_impl = rhs._impl; return *this;}
 
            Bond(const cytnx_uint64 &dim, const bondType &bd_type=bondType::BD_REG, const std::vector<std::vector<cytnx_int64> > &in_qnums={}, const std::vector<Symmetry> &in_syms={}): _impl(new Bond_impl()){
                this->_impl->Init(dim,bd_type,in_qnums,in_syms);
            }
            
            void Init(const cytnx_uint64 &dim, const bondType &bd_type=bondType::BD_REG, const std::vector<std::vector<cytnx_int64> > &in_qnums={}, const std::vector<Symmetry> &in_syms={}){
                this->_impl->Init(dim,bd_type,in_qnums,in_syms);
            }
            
            bondType                                type() const{return this->_impl->type();};
            
 
            const std::vector<std::vector<cytnx_int64> >& qnums() const{return this->_impl->qnums();};
            std::vector<std::vector<cytnx_int64> >& qnums(){return this->_impl->qnums();};
            
            std::vector<std::vector<cytnx_int64> > qnums_clone() const{return this->_impl->qnums_clone();};
    
            cytnx_uint64                             dim() const{return this->_impl->dim();};
 
            cytnx_uint32                            Nsym() const{return this->_impl->syms().size();};
 
 
 
            const std::vector<Symmetry>&                   syms() const{return this->_impl->syms();};
            std::vector<Symmetry>&                         syms(){return this->_impl->syms();};
 
            std::vector<Symmetry>                         syms_clone() const{return this->_impl->syms_clone();};
 
 
 
 
            Bond& set_type(const bondType &new_bondType){
                this->_impl->set_type(new_bondType);
                return *this;
            }
 
            Bond retype(const bondType &new_bondType){
                auto out = this->clone();
                out.set_type(new_bondType);
                return out;
            }
 
            Bond redirect() const{
                auto out = this->clone();
                out.set_type(bondType(int(out.type())*-1));
                return out;
            }
 
            
 
            void clear_type(){
                this->_impl->clear_type();
            }
 
            Bond clone() const{
                Bond out;
                out._impl = this->_impl->clone();
                return out;
            }
 
 
            void combineBond_(const Bond &bd_in){
                this->_impl->combineBond_(bd_in._impl);
            }           
 
            Bond combineBond(const Bond &bd_in) const{
                Bond out;
                out._impl = this->_impl->combineBond(bd_in._impl);
                return out;
            }
 
            Bond combineBonds(const std::vector<Bond> &bds){
                Bond out = this->clone();
                for(cytnx_uint64 i=0;i<bds.size();i++){
                    out.combineBond_(bds[i]);
                }
                return out;
            }
 
            void combineBonds_(const std::vector<Bond> &bds){
                for(cytnx_uint64 i=0;i<bds.size();i++){
                    this->combineBond_(bds[i]);
                }
            }
 
            std::vector<std::vector<cytnx_int64> > getUniqueQnums(std::vector<cytnx_uint64> &counts){
                return this->_impl->getUniqueQnums(counts,true);
            }
            std::vector<std::vector<cytnx_int64> > getUniqueQnums(){
                std::vector<cytnx_uint64> tmp;
                return this->_impl->getUniqueQnums(tmp,false);
            }
            
            cytnx_uint64 getDegeneracy(const std::vector<cytnx_int64>& qnum) const{
                std::vector<cytnx_uint64> tmp;
                return this->_impl->getDegeneracy(qnum,false,tmp);            
            } 
            cytnx_uint64 getDegeneracy(const std::vector<cytnx_int64>& qnum, std::vector<cytnx_uint64> &indices) const{
                indices.clear();
                return this->_impl->getDegeneracy(qnum,true,indices);
            }
 
            std::vector<std::vector<cytnx_int64> > calc_reverse_qnums(){
                return this->_impl->calc_reverse_qnums();
            }
 
 
            void Save(const std::string &fname) const;
            void Save(const char* fname) const;
            static cytnx::Bond Load(const std::string &fname);
            static cytnx::Bond Load(const char* fname);
 
 
            void _Save(std::fstream &f) const;
            void _Load(std::fstream &f);
 
            bool operator==(const Bond &rhs) const;
            bool operator!=(const Bond &rhs) const;
      
            Bond operator*(const Bond &rhs) const{
                return this->combineBond(rhs);
            }
        
            Bond& operator*=(const Bond &rhs){
                this->combineBond_(rhs);
                return *this;
            }
 
 
 
    };
 
    std::ostream& operator<<(std::ostream &os,const Bond &bin);
}
 
 
#endif