---

wfn.h

//
// wfn.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//

#ifndef _chemistry_qc_wfn_wfn_h
#define _chemistry_qc_wfn_wfn_h

#ifdef __GNUC__
#pragma interface
#endif

#include <iostream>

#include <util/misc/compute.h>
#include <math/scmat/matrix.h>
#include <math/scmat/vector3.h>
#include <chemistry/molecule/energy.h>
#include <chemistry/qc/basis/basis.h>
#include <chemistry/qc/basis/integral.h>

class Wavefunction: public MolecularEnergy {
  public:

    enum OrthogMethod { Symmetric=1, Canonical=2, GramSchmidt=3 };

  private:
    RefSCDimension aodim_;
    RefSCDimension sodim_;
    Ref<SCMatrixKit> basiskit_;
    
    ResultRefSymmSCMatrix overlap_;
    ResultRefSymmSCMatrix hcore_;
    ResultRefSCMatrix natural_orbitals_;
    ResultRefDiagSCMatrix natural_density_;

    double * bs_values;
    double * bsg_values;

    Ref<GaussianBasisSet> gbs_;
    Ref<Integral> integral_;

    // The tolerance for linearly independent basis functions.
    // The intepretation depends on the orthogonalization method.
    double lindep_tol_;
    // The orthogonalization method
    OrthogMethod orthog_method_;
    // The dimension in the orthogonalized SO basis
    RefSCDimension osodim_;
    // The orthogonalization matrices
    RefSCMatrix orthog_trans_;
    RefSCMatrix orthog_trans_inverse_;
    // The maximum and minimum residuals from the orthogonalization
    // procedure.  The interpretation depends on the method used.
    // For symmetry and canonical, these are the min and max overlap
    // eigenvalues.  These are the residuals for the basis functions
    // that actually end up being used.
    double min_orthog_res_;
    double max_orthog_res_;

    int print_nao_;
    int print_npa_;

    void compute_overlap_eig(RefSCMatrix& overlap_eigvec,
                             RefDiagSCMatrix& overlap_isqrt_eigval,
                             RefDiagSCMatrix& overlap_sqrt_eigval);
    void compute_symmetric_orthog();
    void compute_canonical_orthog();
    void compute_gs_orthog();
    void compute_orthog_trans();

  protected:

    int debug_;

    double min_orthog_res() const { return min_orthog_res_; }
    double max_orthog_res() const { return max_orthog_res_; }

    void copy_orthog_info(const Ref<Wavefunction> &);
    
  public:
    Wavefunction(StateIn&);
    Wavefunction(const Ref<KeyVal>&);
    virtual ~Wavefunction();

    void save_data_state(StateOut&);

    double density(const SCVector3&);
    double density_gradient(const SCVector3&,double*);
    double natural_orbital(const SCVector3& r, int iorb);
    double natural_orbital_density(const SCVector3& r,
                                   int orb, double* orbval = 0);
    double orbital(const SCVector3& r, int iorb, const RefSCMatrix& orbs);

    double orbital_density(const SCVector3& r,
                           int iorb,
                           const RefSCMatrix& orbs,
                           double* orbval = 0);

    double charge();
    virtual int nelectron() = 0;

    virtual RefSymmSCMatrix density() = 0;
    virtual RefSymmSCMatrix ao_density();
    virtual RefSCMatrix natural_orbitals();
    virtual RefDiagSCMatrix natural_density();

    virtual int spin_polarized() = 0;

    virtual RefSymmSCMatrix alpha_density();
    virtual RefSymmSCMatrix beta_density();
    virtual RefSymmSCMatrix alpha_ao_density();
    virtual RefSymmSCMatrix beta_ao_density();

    virtual RefSCMatrix nao(double *atom_charges=0);

    virtual RefSymmSCMatrix overlap();
    virtual RefSymmSCMatrix core_hamiltonian();

    RefSCDimension ao_dimension();
    RefSCDimension so_dimension();
    RefSCDimension oso_dimension();
    Ref<SCMatrixKit> basis_matrixkit();
    Ref<GaussianBasisSet> basis() const;
    Ref<Integral> integral();

    // override symmetry_changed from MolecularEnergy
    void symmetry_changed();

    RefSCMatrix so_to_orthog_so();

    RefSCMatrix so_to_orthog_so_inverse();

    OrthogMethod orthog_method() { return orthog_method_; }

    void obsolete();

    void print(std::ostream& = ExEnv::out()) const;
};


#endif

// Local Variables:
// mode: c++
// c-file-style: "ETS"
// End:

---