colvaratoms.h

Go to the documentation of this file.

#ifndef COLVARATOMS_H
#define COLVARATOMS_H

#include "colvarmodule.h"
#include "colvarparse.h"

class colvarmodule::atom {

protected:

  size_t        index;

public:

  int              id;

  cvm::real      mass;

  cvm::atom_pos   pos;

  cvm::rvector    vel;

  cvm::rvector    system_force;

  cvm::rvector   grad;

  inline atom() {}

  atom (int const &atom_number);

  atom (cvm::residue_id const &residue,
        std::string const     &atom_name,
        std::string const     &segment_id);

  atom (atom const &a);

  ~atom();

  inline void reset_data() {
    pos = atom_pos (0.0);
    vel = grad = system_force = rvector (0.0);
  }

  void read_position();

  void read_velocity();

  void read_system_force();

  void apply_force (cvm::rvector const &new_force);
};




class colvarmodule::atom_group
  : public std::vector<cvm::atom>,
    public colvarparse
{
public:
  // Note: all members here are kept public, to make possible to any
  // object accessing and manipulating them


  bool b_dummy;
  cvm::atom_pos dummy_atom_pos;


  bool b_center;

  bool b_rotate;
  cvm::rotation rot;

  std::vector<cvm::atom_pos> ref_pos;
  cvm::atom_pos              ref_pos_com;
  atom_group                *ref_pos_group;


  cvm::real total_mass;

  bool        noforce;


  atom_group (std::string const &conf,
              char const        *key,
              atom_group        *ref_pos_group = NULL);

  void parse (std::string const &conf,
              char const        *key,
              atom_group        *ref_pos_group = NULL);

  atom_group (std::vector<cvm::atom> const &atoms);

  void add_atom (cvm::atom const &a);

  atom_group();

  ~atom_group();

  void read_positions();

  void apply_translation (cvm::rvector const &t);

  void apply_rotation (cvm::rotation const &q);


  void read_velocities();

  void read_system_forces();

  inline void reset_atoms_data()
  {
    for (cvm::atom_iter ai = this->begin(); ai != this->end(); ai++)
      ai->reset_data();
  }

  std::vector<cvm::atom_pos> positions() const;

  std::vector<cvm::atom_pos> positions_shifted (cvm::rvector const &shift) const;

  cvm::atom_pos center_of_geometry (cvm::atom_pos const &ref_pos);
  cvm::atom_pos center_of_geometry() const;

  cvm::atom_pos center_of_mass (cvm::atom_pos const &ref_pos);
  cvm::atom_pos center_of_mass() const;

  std::vector<cvm::atom_pos> old_pos;


  std::vector<cvm::rvector> velocities() const;


  std::vector<cvm::rvector> system_forces() const;
  cvm::rvector system_force() const;


  void set_weighted_gradient (cvm::rvector const &grad);

  void apply_colvar_force (cvm::real const &force);

  void apply_force (cvm::rvector const &force);

  void apply_forces (std::vector<cvm::rvector> const &forces);
};




#endif


// Emacs
// Local Variables:
// mode: C++
// End:

---