vector_bte.h

#ifndef VECTOR_BTE_H
#define VECTOR_BTE_H
 
#include "Matrix.h"
#include "PMatrix.h"
#include "active_bandstructure.h"
#include "context.h"
#include "eigen.h"
 
class VectorBTE {
public:
  VectorBTE(StatisticsSweep &statisticsSweep_,
            BaseBandStructure &bandStructure_, const int &dimensionality_ = 3);
 
  VectorBTE(const VectorBTE &that);
 
  VectorBTE &operator=(const VectorBTE &that);
 
  double &operator()(const int &iCalc, const int &iDim, const int &iState);
 
  const double &operator()(const int &iCalc, const int &iDim,
                           const int &iState) const;
 
  Eigen::MatrixXd dot(const VectorBTE &that);
 
  VectorBTE operator*(VectorBTE &that);
 
  VectorBTE operator*(const double &scalar);
 
  VectorBTE operator*(const Eigen::MatrixXd &vector);
 
  VectorBTE operator*(ParallelMatrix<double> &matrix);
 
  VectorBTE operator+(VectorBTE &that);
 
  VectorBTE operator-(VectorBTE &that);
 
  VectorBTE operator-();
 
  VectorBTE operator/(VectorBTE &that);
 
  VectorBTE sqrt();
  
  VectorBTE reciprocal() const;
 
  void canonical2Population();
 
  void population2Canonical();
 
  void outputToJSON(const std::string &outFileName, BaseBandStructure& outerBandStructure);
  
  Eigen::MatrixXd data;
 
  int glob2Loc(const ChemPotIndex &imu, const TempIndex &it,
               const CartIndex &iDim) const;
  std::tuple<ChemPotIndex, TempIndex, CartIndex> loc2Glob(const int &i) const;
 
  std::vector<int> excludeIndices;
  int dimensionality;
 
  void setConst(const double &constant);
 
  int getNumStates();
 
 protected:
  // we store auxiliary objects and parameters
  StatisticsSweep &statisticsSweep;
  int numCalculations;
  int numStates;
  int numChemPots;
  int numTemps;
 
  // we store auxiliary objects and parameters
  BaseBandStructure &bandStructure;
 
  friend class ScatteringMatrix; // this is also to remember that
  // if we change the index order of this class, we should check the
  // ScatteringMatrix implementations: they are high efficiency methods
  // so they need low-level access to the raw buffer
 
  VectorBTE baseOperator(VectorBTE &that, const int &operatorType);
  const int operatorSums = 0;
  const int operatorDivs = 1;
  const int operatorProd = 2;
  const int operatorDiff = 3;
};
 
#endif