Atoms.h

Go to the documentation of this file.

#ifndef ATOMS_H
#define ATOMS_H
 
#include <set>
#include <vector>
using std::set;
using std::vector;
#include "Vec.h" // Needed because we are destroying a vector<Vec> in
                 // Atoms::~Atoms().  (at least with the alpha compiler)
 
class SuperCell;
// class Vec;
class AsapPotential;
 
// Atomic positions are stored in a vector<Vec>:
//
// positions[0, ..., nAtoms - 1] :
//   real atoms
//
// positions[nAtoms, ..., nAtoms + nGhosts - 1] :
//   ghost atoms (from QC or Parallel)
//
// positions[nAtoms + nGhosts, ..., positions.size() - 1] :
//   image atoms (from periodic boundaries)


 
class Atoms {
public:
  Atoms(const Vec *p, int n, SuperCell *s);

  virtual ~Atoms() {};

  virtual SuperCell *GetSuperCell() const { return superCell; }

  virtual const Vec *GetUnitCell() const;

  virtual void SetUnitCell(const Vec newbasis[3], bool fix);

  virtual void SetCalculator(AsapPotential *potential);

  AsapPotential *GetPotential() const { return potential; }


  inline void MarkChanged() { ++counter; }

  inline int GetChangeCounter() const { return counter; }


  virtual void SetCartesianPositions(const Vec *p);


  virtual void GetCartesianPositions(Vec *p) const;


  virtual const Vec *GetCartesianPositions() const { return &positions[0]; }


  Vec *GetPositionsPtr() { return &positions[0]; }


  virtual void GetUnwrappedPositions(vector<Vec> &p) const;


  virtual void SetUnwrappedPositions(const Vec *p);

  virtual void NormalizeDifferences(Vec *diff) const;

  virtual void NormalizeDifference(Vec &diff) const;


  virtual void NormalizePositions();


  virtual void NormalizePosition(Vec &pos) const;


  virtual void NormalizePosition(Vec &pos, Vec &scaled_translation) const;

  virtual void ReNormalizePosition(Vec &pos, Vec &scaled_translation) const;

  virtual void SetAtomicNumbers(const int *z);

  virtual const int *GetAtomicNumbers() const { return &types[0]; }


  int *GetAtomicNumbersPtr() { return &types[0]; }

  virtual void GetListOfElements(set<int> &elements) const;

  void SetNumberOfImages(int i);

  int GetNumberOfImages() const { return nImages; }


  virtual int GetNumberOfAtoms() const { return nAtoms; }


  int GetNumberOfRealAtoms() const { return nAtoms; }

  virtual void SetNumberOfAtoms(int n);
 
protected:
  AsapPotential *potential;     
  SuperCell *superCell;         
  vector<Vec> positions;        
  vector<Vec> pos_translations; 
  vector<int> types;            
  int nAtoms;                   
  int nImages; 
  int counter; 
};
 
#endif // ATOMS_H