Eigenvector_Printer.h

#ifndef QNANO_NEW_EIGENVECTOR_PRINTER_DEFINED_H
#define QNANO_NEW_EIGENVECTOR_PRINTER_DEFINED_H

#include "orbitals/Organize_Blocks_By_Orbital_List.h"
#include "tools/Parameter_Map.h"


class Eigenvector_Printer{
protected:
  bool delete_orb_blocks_on_destruction;
  bool spinless;
public: 

  int round_figure;
  std::string EV_filename_pattern;
  std::string eigenvalue_filename;
  int nr_print;
  bool override_printEV;
  std::string EV_header;
  std::vector<std::string> EV_header_individual;
  bool print_sparse;
  double print_sparse_cutoff;
  bool print_error_cout;
  bool silent;

  bool print_Kramers_sz;
  double kramers_tolerance;
  //Eigenvector_Printer_Kramers_Data kramers; <- might remove class eventually?

 
  Organize_Blocks *orb_blocks;
  bool orbs_are_spinless()const{return spinless;}

  //function that defines how the state indices are printed
  std::string (*sparse_print_index)(size_t line_counter, void* spi_ctx);
  void* spi_ctx;
  static std::string sparse_print_index_default(size_t line_counter, void* spi_ctx);


  virtual void setup(Parameter_Map &param_map);

  const std::string & get_EV_header(int i) const;

  //prints (and defines printing format) of a block of states to a string
  void print_block(std::string &str, std::complex<double> *ptr, int blocksize, int baseindex)const;


  //implementation specific: nr of converged eigenpairs and i-th eigenvalue
  virtual int get_n_converged() const=0;
  virtual double get_eigenvalue(int i) const=0;
  virtual int get_actual_nr_print()const;
  
  //(abstract) functions for printing 
  virtual void print() const;
  virtual void print_eigenvalues()const;
  virtual void print_eigenvector(int n_print)const=0;
  //print when print_Kramers_sz is set; default: just print state i and i+1
  virtual void print_eigenvector_Kramers(int i)const;
  virtual bool has_Kramers_partner(int i)const;
  //calculate alpha and beta for Kramers rotation
  virtual void calculate_alpha_beta_Kramers_sz( \
    std::complex<double> &alpha, std::complex<double> &beta, int i) const;
  //obtain phase factor of orbital with maximal density
  virtual std::complex<double> calculate_max_phase_factor( \
    std::complex<double> alpha, std::complex<double> beta, int i) const;




  Eigenvector_Printer(Organize_Blocks *org, bool spinless_=true)
    : delete_orb_blocks_on_destruction(false), 
      spinless(spinless_), orb_blocks(org) {
  }
  Eigenvector_Printer(size_t DIM, bool spinless_=true)
    : delete_orb_blocks_on_destruction(true), spinless(spinless_), 
      orb_blocks(new Organize_Blocks_Equal(1,DIM)){
  }
  virtual ~Eigenvector_Printer(){
    if(delete_orb_blocks_on_destruction){
      delete orb_blocks;
    }
  }
};

#endif