energy.h

//
// energy.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_molecule_energy_h
#define _chemistry_molecule_energy_h
 
#include <iostream>
 
#include <math/optimize/function.h>
#include <math/optimize/conv.h>
#include <chemistry/molecule/molecule.h>
#include <chemistry/molecule/coor.h>
#include <chemistry/molecule/deriv.h>
#ifdef MPQC_NEW_FEATURES
#include <util/misc/xml.h>
#endif
 
namespace sc {
 
 
class MolecularEnergy: public Function
#ifdef MPQC_NEW_FEATURES
, virtual public DescribedXMLWritable
#endif
{
  private:
    RefSCDimension moldim_; // the number of cartesian variables
    Ref<MolecularCoor> mc_;
    Ref<Molecule> mol_;
    Ref<MolecularHessian> hess_;
    Ref<MolecularHessian> guesshess_;
    Ref<MolecularGradient> grad_;
 
    RefSCVector cartesian_gradient_;
    RefSymmSCMatrix cartesian_hessian_;
 
    RefSCVector efield_;  //< electric field vector
 
    bool ckpt_;
    std::string ckpt_file_;
    int ckpt_freq_;
 
  protected:
    Ref<PointGroup> initial_pg_;
 
    void failure(const char *);
 
    virtual void set_energy(double);
 
    virtual void set_gradient(RefSCVector&);
    virtual void set_hessian(RefSymmSCMatrix&);
 
    void x_to_molecule();
    void molecule_to_x();
 
    int print_molecule_when_changed_;
 
    virtual bool nonzero_efield_supported() const;
 
    virtual bool analytic_gradient_implemented() const;
    virtual bool analytic_hessian_implemented() const;
 
 
  public:
    MolecularEnergy(const MolecularEnergy&);
    MolecularEnergy(const Ref<KeyVal>&);
    MolecularEnergy(StateIn&);
    ~MolecularEnergy();
 
    void save_data_state(StateOut&);
 
 
#ifdef MPQC_NEW_FEATURES
    virtual boost::property_tree::ptree& write_xml(boost::property_tree::ptree& parent, const XMLWriter& writer);
#endif
 
    void set_checkpoint();
    void set_checkpoint_file(const char*);
    void set_checkpoint_freq(int freq);
    bool if_to_checkpoint() const;
    const char* checkpoint_file() const;
    int checkpoint_freq() const;
 
    MolecularEnergy & operator=(const MolecularEnergy&);
 
    virtual double energy();
 
    virtual Ref<Molecule> molecule() const;
    virtual RefSCDimension moldim() const;
 
    void guess_hessian(RefSymmSCMatrix&);
    RefSymmSCMatrix inverse_hessian(RefSymmSCMatrix&);
 
    int gradient_implemented() const;
    int hessian_implemented() const;
 
    void set_desired_gradient_accuracy(double acc);
    void set_desired_hessian_accuracy(double acc);
 
    void set_molhess(const Ref<MolecularHessian>& molhess);
    const Ref<MolecularHessian>& molhess() const;
    RefSymmSCMatrix hessian();
    void set_molgrad(const Ref<MolecularGradient>& molgrad);
    const Ref<MolecularGradient>& molgrad() const;
    RefSCVector gradient();
 
    void set_x(const RefSCVector&);
 
    RefSCVector get_cartesian_x();
    RefSCVector get_cartesian_gradient();
    RefSymmSCMatrix get_cartesian_hessian();
 
    Ref<MolecularCoor> molecularcoor() { return mc_; }
 
    virtual void symmetry_changed();
 
    Ref<NonlinearTransform> change_coordinates();
 
    virtual void purge();
 
    const RefSCVector& electric_field() const { return efield_; }
 
    void print_natom_3(const RefSCVector &,
                       const char *t=0, std::ostream&o=ExEnv::out0()) const;
    void print_natom_3(double **, const char *t=0, std::ostream&o=ExEnv::out0()) const;
    void print_natom_3(double *, const char *t=0, std::ostream&o=ExEnv::out0()) const;
 
    virtual void print(std::ostream& = ExEnv::out0()) const;
};
 
class SumMolecularEnergy: public MolecularEnergy {
  protected:
    int value_implemented() const;
    bool analytic_gradient_implemented() const;
    bool analytic_hessian_implemented() const;
    int n_;
    Ref<MolecularEnergy> *mole_;
    double *coef_;
    void compute();
  public:
    SumMolecularEnergy(const Ref<KeyVal> &);
    SumMolecularEnergy(StateIn&);
    ~SumMolecularEnergy();
 
    void save_data_state(StateOut&);
 
    void set_x(const RefSCVector&);
 
    void purge();
};
 
 
/* The MolEnergyConvergence class derives from the Convergence class.  The
MolEnergyConvergence class allows the user to request that cartesian
coordinates be used in evaluating the convergence criteria.  This is
useful, since the internal coordinates can be somewhat arbitary.  If the
optimization is constrained, then the fixed internal coordinates will be
projected out of the cartesian gradients.  The input is similar to that for
Convergence class with the exception that giving none of the convergence
criteria keywords is the same as providing the following input to the
KeyVal constructor:
 
<pre>
  conv<MolEnergyConvergence>: (
    max_disp = 1.0e-4
    max_grad = 1.0e-4
    graddisp = 1.0e-4
  )
</pre>
 
For MolEnergyConverence to work, the Function object given to the Optimizer
object must derive from MolecularEnergy.
*/
class MolEnergyConvergence: public Convergence {
  protected:
    Ref<MolecularEnergy> mole_;
    int cartesian_;
 
    void set_defaults();
  public:
    // Standard constructors and destructor.
    MolEnergyConvergence();
    MolEnergyConvergence(StateIn&);
    MolEnergyConvergence(const Ref<KeyVal>&);
    virtual ~MolEnergyConvergence();
 
    void save_data_state(StateOut&);
 
    // Set the current gradient and position information.  These
    //will possibly grab the cartesian infomation if we have a
    //MolecularEnergy.
    void get_grad(const Ref<Function> &);
    void get_x(const Ref<Function> &);
    void set_nextx(const RefSCVector &);
 
    // Return nonzero if the optimization has converged.
    int converged();
 
    void print(std::ostream& = ExEnv::out0()) const;
};
 
// end of addtogroup ChemistryMolecule
 
}
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: