tensor_expansion.hpp

 
#ifndef EXATN_NUMERICS_TENSOR_EXPANSION_HPP_
#define EXATN_NUMERICS_TENSOR_EXPANSION_HPP_
 
#include "tensor_basic.hpp"
#include "tensor_network.hpp"
#include "tensor_operator.hpp"
 
#include <string>
#include <vector>
#include <complex>
#include <memory>
 
namespace exatn{
 
namespace numerics{
 
class TensorExpansion{
public:
 
 //Tensor network expansion component:
 struct ExpansionComponent{
  //Tensor network:
  std::shared_ptr<TensorNetwork> network;
  //Expansion coefficient:
  std::complex<double> coefficient;
 };
 
 using Iterator = typename std::vector<ExpansionComponent>::iterator;
 using ConstIterator = typename std::vector<ExpansionComponent>::const_iterator;
 
 TensorExpansion(): ket_(true) {}
 
 TensorExpansion(const TensorExpansion & expansion,       //in: tensor network expansion in some tensor space
                 const TensorOperator & tensor_operator); //in: tensor network operator
 
 TensorExpansion(const TensorExpansion & left_expansion,   //in: tensor network expansion in some tensor space
                 const TensorExpansion & right_expansion); //in: tensor network expansion from the same or dual space
 
 TensorExpansion(const TensorExpansion & left_expansion,  //in: tensor network expansion in some tensor space
                 const TensorExpansion & right_expansion, //in: tensor network expansion from the dual tensor space
                 const TensorOperator & tensor_operator); //in: tensor network operator
 
 TensorExpansion(const TensorExpansion &) = default;
 TensorExpansion & operator=(const TensorExpansion &) = default;
 TensorExpansion(TensorExpansion &&) noexcept = default;
 TensorExpansion & operator=(TensorExpansion &&) noexcept = default;
 virtual ~TensorExpansion() = default;
 
 inline Iterator begin() {return components_.begin();}
 inline Iterator end() {return components_.end();}
 inline ConstIterator cbegin() const {return components_.cbegin();}
 inline ConstIterator cend() const {return components_.cend();}
 
 inline bool isKet() const{
  return ket_;
 }
 
 inline bool isBra() const{
  return !ket_;
 }
 
 inline int getRank() const{
  if(!(components_.empty())) return components_[0].network->getRank();
  return -1;
 }
 
 inline std::size_t getNumComponents() const{
  return components_.size();
 }
 
 inline const ExpansionComponent & getComponent(std::size_t component_num){
  assert(component_num < components_.size());
  return components_[component_num];
 }
 
 bool appendComponent(std::shared_ptr<TensorNetwork> network,  //in: tensor network
                      const std::complex<double> coefficient); //in: expansion coefficient
 
 void conjugate();
 
 void printIt() const;
 
private:
 
 void constructDirectProductTensorExpansion(const TensorExpansion & left_expansion,
                                            const TensorExpansion & right_expansion);
 void constructInnerProductTensorExpansion(const TensorExpansion & left_expansion,
                                           const TensorExpansion & right_expansion);
 bool reorderProductLegs(TensorNetwork & network,
                         const std::vector<std::pair<unsigned int, unsigned int>> & new_legs);
 
protected:
 
 bool ket_; //ket or bra
 std::vector<ExpansionComponent> components_; //ordered components of the tensor network expansion
};
 
} //namespace numerics
 
} //namespace exatn
 
#endif //EXATN_NUMERICS_TENSOR_EXPANSION_HPP_