tensor_operator.hpp

 
#ifndef EXATN_NUMERICS_TENSOR_OPERATOR_HPP_
#define EXATN_NUMERICS_TENSOR_OPERATOR_HPP_
 
#include "tensor_basic.hpp"
#include "tensor_network.hpp"
 
#include <string>
#include <vector>
#include <complex>
#include <memory>
 
namespace exatn{
 
namespace numerics{
 
class TensorOperator{
public:
 
 //Tensor operator component:
 struct OperatorComponent{
  //Tensor network (or a single tensor stored as a tensor network of size 1):
  std::shared_ptr<TensorNetwork> network;
  //Ket legs of the tensor network: Global tensor mode id <-- Output tensor leg:
  std::vector<std::pair<unsigned int, unsigned int>> ket_legs;
  //Bra legs of the tensor network: Global tensor mode id <-- Output tensor leg:
  std::vector<std::pair<unsigned int, unsigned int>> bra_legs;
  //Expansion coefficient of the operator component:
  std::complex<double> coefficient;
 };
 
 using Iterator = typename std::vector<OperatorComponent>::iterator;
 using ConstIterator = typename std::vector<OperatorComponent>::const_iterator;
 
 TensorOperator(const std::string & name): name_(name) {}
 
 TensorOperator(const TensorOperator &) = default;
 TensorOperator & operator=(const TensorOperator &) = default;
 TensorOperator(TensorOperator &&) noexcept = default;
 TensorOperator & operator=(TensorOperator &&) noexcept = default;
 virtual ~TensorOperator() = 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 const std::string & getName() const{
  return name_;
 }
 
 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 OperatorComponent & 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 (or single tensor as a tensor network)
                      const std::vector<std::pair<unsigned int, unsigned int>> & ket_pairing, //in: ket pairing: Global tensor mode id <-- Output tensor leg
                      const std::vector<std::pair<unsigned int, unsigned int>> & bra_pairing, //in: bra pairing: Global tensor mode id <-- Output tensor leg
                      const std::complex<double> coefficient);                                //in: expansion coefficient
 
 void conjugate();
 
 void printIt() const;
 
protected:
 
 std::string name_;                          //tensor operator name
 std::vector<OperatorComponent> components_; //ordered components of the tensor operator
};
 
} //namespace numerics
 
} //namespace exatn
 
#endif //EXATN_NUMERICS_TENSOR_OPERATOR_HPP_