gradient.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: gradient.h,v 1.20.20.1 2007/05/18 12:02:44 oliver Exp $ 
//
// Author:
//   Oliver Kohlbacher
//

// A conjugate gradient minimizer for geometry optimisation

#ifndef BALL_MOLMEC_COMMON_GRADIENT_H 
#define BALL_MOLMEC_COMMON_GRADIENT_H 

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

#include <vector>

namespace BALL 
{ 
  class AtomVector;

  class BALL_EXPORT Gradient
    : private std::vector<Vector3>
  {
    public:

    BALL_CREATE_DEEP(Gradient)

    

    typedef std::vector<Vector3>::iterator Iterator;

    typedef std::vector<Vector3>::const_iterator ConstIterator;

    typedef std::vector<Vector3>::reverse_iterator ReverseIterator;

    typedef std::vector<Vector3>::const_reverse_iterator ConstReverseIterator;




    Gradient();

    Gradient(const AtomVector& atoms);

    Gradient(const Gradient& gradient, bool deep = true);

    virtual ~Gradient();


    Gradient& operator = (const Gradient& rhs);

    Gradient& operator = (const AtomVector& rhs);

    void set(const Gradient& gradient);

    void set(const AtomVector& atoms);

    void negate();

    void normalize();

    double operator * (const Gradient& gradient) const;


    /*  Return the number of components of the gradient.
    */
    using std::vector<Vector3>::size;

    /* Return the component for an atom.
    */
    //?????: GCC3 using std::vector<Vector3>::operator [];
    const Vector3& operator [] (int i) const { return std::vector<Vector3>::operator [] (i); }
    Vector3& operator [] (int i) { return std::vector<Vector3>::operator [] (i); }

    void invalidate();

    bool isValid() const;


      
    //?????: GCC3 using std::vector<Vector3>::begin;
    Iterator begin() { return vector<Vector3>::begin(); }
    ConstIterator begin() const { return vector<Vector3>::begin(); }

    //?????: GCC3 using std::vector<Vector3>::end;
    Iterator end() { return vector<Vector3>::end(); }
    ConstIterator end() const { return vector<Vector3>::end(); }

    //?????: GCC3 using std::vector<Vector3>::begin;
    ReverseIterator rbegin() { return vector<Vector3>::rbegin(); }
    ConstReverseIterator rbegin() const { return vector<Vector3>::rbegin(); }

    //?????: GCC3 using std::vector<Vector3>::end;
    ReverseIterator rend() { return vector<Vector3>::rend(); }
    ConstReverseIterator rend() const { return vector<Vector3>::rend(); }


    double norm;

    double inv_norm;

    double rms;


    protected:
      
    /*_ The validity flag.
    */
    bool valid_;
    
    };
  } // end of namespace BALL

#endif // BALL_MOLMEC_COMMON_GRADIENT_H