---

QMTimestep.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: QMTimestep.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.41 $       $Date: 2019/01/17 21:21:01 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * The QMTimestep and Wavefunction classes.
 * The QMTimestep class stores and manages all quantm chemistry related
 * data that are timestep dependent. These include gradients, charges,
 * SCF energies. Most importantly we also consider wave function
 * trajectories which enables the user to visualize orbital dynamics.
 * (None of the other visualization tools I'm aware of can do that :-)
 * 
 * Moreover, each timestep can have multiple different wave functions.
 * This is useful for UHF calculations where we have two sets of orbitals
 * with opposite spins or for calculations with multiple excited states. 
 * The number of existing wave function may vary between frames.
 * So we could have, for instance, a coordinate trajectory with orbitals
 * defined only for the last frame. Another typical case would be to have
 * a canonical wavefunction for each frame but for the last frame there
 * exists an additional set of localized orbitals.
 * The number of orbitals present for a given wavefunction may also
 * differ from frame to frame. 
 *
 * In order to identify a wavefunction throughout the trajectory we
 * assign a unique wavefunction ID that is based on its 'signature'
 * (type, spin, excitation, multiplicity and an optional info string).
 * A list with the signatures of all different wavefunction occuring
 * over the course of the trajectory is kept in the QMData class.
 *
 ***************************************************************************/
#ifndef QMTIMESTEP_H
#define QMTIMESTEP_H

#include "QMData.h"

class Timestep;

class Wavefunction {
  friend class QMTimestep;
  int   idtag;              
  int   type;               
  int   spin;               
  int   excitation;         
  int   multiplicity;       
  int   num_orbitals;       
  int   num_coeffs;         
  char info[QMDATA_BUFSIZ]; 
  double energy;            
  float *wave_coeffs;       
  float *orb_energies;      
  float *occupancies;       
  int   *orb_ids;           
  int   *orb_id2index;      
  int   *orb_sort_map;      
 public:
  Wavefunction();
  Wavefunction(const Wavefunction& wf);
  Wavefunction(int numcoeffs,
               int numorbitals, 
               const float *coeffs,
               const float *energies,
               const float *occ,
               const int   *orbids,
               double _energy,
               int _idtag,
               int _type,
               int _spin,
               int _excitation,
               int _multiplicity,
               char *infostr);
  ~Wavefunction();

  Wavefunction& operator=(const Wavefunction& wf);

  // Move the data over from the given wavefunction wf
  // and set the pointers in wf to NULL.
  // This avoids copying the arrays.
  void movefrom(Wavefunction& wf);

  int get_num_orbitals() const   { return num_orbitals; }
  int get_num_coeffs()   const   { return num_coeffs; }

  const float* get_coeffs()      { return wave_coeffs; }

  const float* get_orbenergies() { return orb_energies; }

  const float* get_occupancies() { return occupancies; }

  const int*   get_orbids() { return orb_ids; }

  //  const float* get_coeffs(int orb);

  void set_coeffs(const float *wfn, int norbitals, int wavef_size);

  void set_orbenergies(const float *energies, int norbitals);

  void set_occupancies(const float *occupancies, int norbitals);

  void set_orbids(const int *orbids, int norbitals);

  //float get_coeff(int orb, int i);
  float get_orbitalenergy(int orb) const;

  double get_energy() { return energy; }

  int get_spin() { return spin; }

  int get_excitation() { return excitation; }

  int get_multiplicity() { return multiplicity; }

  const char* get_info() { return info; }

  int  get_type() const { return type; }

  void get_typestr(char *&typestr) const;

  int get_homo() const;

  int get_num_occupied_double() const;

  int get_num_occupied_single() const;


  void density_matrix(float *(&P)) const;
  void density_matrix(const QMData *qmdata, int atom, float *(&D)) const;
  void population_matrix(const float *S, float *(&P)) const;
  void population_matrix(const QMData *qmdata, int atom,
                         const float *S, float *(&P)) const;

  void sort_wave_coefficients(QMData *qmdata);

  void sort_orbitals(Wavefunction *previous_wavef);

 private:
  void sort_incr(QMData *qmdata, int atom, int ishell, int comp,
                 int first, int num);
};

class QMTimestep {
private:
  int   num_scfiter;        
  int   num_atoms;          
#if 0
  int   wavef_size;         

#endif
  int num_wavef;            
  Wavefunction *wavef;      

  int num_idtags;           
                            // XXX (should be same as num_wavef)

  int *wavef_id_map;        



  double *scfenergies;      
  float  *gradients;        

  int num_charge_sets;      
  double *charges;          
  int    *chargetypes;      


public:
  QMTimestep(int natoms);           
  QMTimestep(const QMTimestep& ts); 
  ~QMTimestep(void);                

  int add_wavefunction(QMData *qmdata,
                       int numcoeffs,
                       int numorbitals, 
                       const float *coeffs,
                       const float *energies,
                       float *occupancies,
                       const int   *orbids,
                       double energy,
                       int type,
                       int spin,
                       int excitation,
                       int multiplicity,
                       const char *info,
                       wavef_signa_t *(&signa_ts),
                       int &num_signa_ts);

  // Initialization functions
  void set_scfenergies(const double *energies, int numscfiter);
  void set_wavefunction(const float *wfn, int numorbitals, int num_gauss_basis_funcs);
  void set_orbitalenergies(const float *energies, int numorbitals);
  void set_gradients(const float *grad, int numatoms);

  // Initialize the sets of atom charges.
  void set_charges(const double *q, const int *qtype, 
                   int numatoms, int numqsets);

  void set_wavef_idtag(int iwave, int idtag);

  Wavefunction* get_wavefunction(int iwave);

  const float*  get_wavecoeffs(int iwave);
 
  const float*  get_orbitalenergy(int iwave);

  const float*  get_occupancies(int iwave);

  const int*    get_orbitalids(int iwave);

  const float*  get_gradients()     { return gradients;   }

  const double* get_scfenergies()   { return scfenergies; }

  const double* get_charge_set(int set);

  int get_charge_type(int iset);

  const char* get_charge_type_str(int iset);

  int get_num_scfiter() { return num_scfiter; }

  int get_num_charge_sets() { return num_charge_sets; }

  int get_num_wavef()   { return num_wavef;   }

  int get_num_coeffs(int iwave);

  int get_num_orbitals(int iwave);

  int get_wavef_index(int idtag);

  int get_waveid(int iwave);

  int get_spin(int iwave);

  int get_excitation(int iwave);

  int get_multiplicity(int iwave);

  double get_wave_energy(int iwave);

  // Get orbital index for HOMO
  int get_homo(int iwave);

  // Get orbital index for LUMO
  int get_lumo(int iwave);

  void get_orbital_occ_energy(int iwave, int orb, float &occ, float &energy);

  // Get string describing the wavefunction type
  void get_wavef_typestr(int iwave, char *&typestr) {
    wavef[iwave].get_typestr(typestr);
  }

  // Generate mapping that sorts the orbitals by similarity
  // throughout the trajectory (rather than by energy).
  // XXX Still unfinished.
  void sort_orbitals(QMTimestep *prev_qmts);

  int get_orbital_id_from_index(int iwave, int index);

  int get_orbital_index_from_id(int iwave, int id);

private:
  void sort_shell(QMData *qmdata, int atom, int ishell);
  void sort_incr(QMData *qmdata, int atom, int ishell, int comp, int first, int num);
};

void vmd_set_default_occ(float *(&occupancies), int scftyp, int numelec, int numorbitals, int multiplicity);


#endif

---