source: src/atom_atominfo.cpp@ 056e70

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010 University of Bonn. All rights reserved.
 * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
 */

/*
 * atom_atominfo.cpp
 *
 *  Created on: Oct 19, 2009
 *      Author: heber
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include "CodePatterns/Log.hpp"
#include "CodePatterns/Verbose.hpp"
#include "config.hpp"
#include "element.hpp"
#include "parser.hpp"
#include "periodentafel.hpp"
#include "World.hpp"
#include "atom_atominfo.hpp"

/** Constructor of class AtomInfo.
 */
AtomInfo::AtomInfo() :
  AtomicElement(NULL),
  FixedIon(false)
{
  AtomicPosition.reserve(1);
  AtomicPosition.push_back(zeroVec);
  AtomicVelocity.reserve(1);
  AtomicVelocity.push_back(zeroVec);
  AtomicForce.reserve(1);
  AtomicForce.push_back(zeroVec);
};

/** Copy constructor of class AtomInfo.
 */
AtomInfo::AtomInfo(const AtomInfo &_atom) :
    AtomicPosition(_atom.AtomicPosition),
    AtomicElement(_atom.AtomicElement),
    FixedIon(false)
{
  AtomicVelocity.reserve(1);
  AtomicVelocity.push_back(zeroVec);
  AtomicForce.reserve(1);
  AtomicForce.push_back(zeroVec);
};

AtomInfo::AtomInfo(const VectorInterface &_v) :
    AtomicElement(NULL),
    FixedIon(false)
{
  AtomicPosition[0] = _v.getPosition();
  AtomicVelocity.reserve(1);
  AtomicVelocity.push_back(zeroVec);
  AtomicForce.reserve(1);
  AtomicForce.push_back(zeroVec);
};

/** Destructor of class AtomInfo.
 */
AtomInfo::~AtomInfo()
{
};

const element *AtomInfo::getType() const
{
  return AtomicElement;
}

const double& AtomInfo::operator[](size_t i) const
{
  ASSERT(AtomicPosition.size() > 0,
      "AtomInfo::operator[]() - Access out of range.");
  return AtomicPosition[0][i];
}

const double& AtomInfo::at(size_t i) const
{
  ASSERT(AtomicPosition.size() > 0,
      "AtomInfo::at() - Access out of range.");
  return AtomicPosition[0].at(i);
}

const double& AtomInfo::atStep(size_t i, int _step) const
{
  ASSERT(AtomicPosition.size() > _step,
      "AtomInfo::atStep() - Access out of range.");
  return AtomicPosition[_step].at(i);
}

void AtomInfo::set(size_t i, const double value)
{
  ASSERT(AtomicPosition.size() > 0,
      "AtomInfo::set() - Access out of range.");
  AtomicPosition[0].at(i) = value;
}

const Vector& AtomInfo::getPosition() const
{
  ASSERT(AtomicPosition.size() > 0,
      "AtomInfo::getPosition() - Access out of range.");
  return AtomicPosition[0];
}

const Vector& AtomInfo::getPositionAtStep(const int _step) const
{
  ASSERT(_step < AtomicPosition.size(),
      "AtomInfo::getPositionAtStep() - Access out of range.");
  return AtomicPosition[_step];
}

void AtomInfo::setType(const element* _type) {
  AtomicElement = _type;
}

void AtomInfo::setType(const int Z) {
  const element *elem = World::getInstance().getPeriode()->FindElement(Z);
  setType(elem);
}

//Vector& AtomInfo::getAtomicVelocity()
//{
//  return AtomicVelocity[0];
//}

//Vector& AtomInfo::getAtomicVelocity(const int _step)
//{
//  ASSERT(_step < AtomicVelocity.size(),
//      "AtomInfo::getAtomicVelocity() - Access out of range.");
//  return AtomicVelocity[_step];
//}

const Vector& AtomInfo::getAtomicVelocity() const
{
  ASSERT(AtomicVelocity.size() > 0,
      "AtomInfo::getAtomicVelocity() - Access out of range.");
  return AtomicVelocity[0];
}

const Vector& AtomInfo::getAtomicVelocityAtStep(const int _step) const
{
  ASSERT(_step < AtomicVelocity.size(),
      "AtomInfo::getAtomicVelocity() - Access out of range.");
  return AtomicVelocity[_step];
}

void AtomInfo::setAtomicVelocity(const Vector &_newvelocity)
{
  ASSERT(0 < AtomicVelocity.size(),
      "AtomInfo::setAtomicVelocity() - Access out of range.");
  AtomicVelocity[0] = _newvelocity;
}

void AtomInfo::setAtomicVelocityAtStep(const int _step, const Vector &_newvelocity)
{
  ASSERT(_step <= AtomicVelocity.size(),
      "AtomInfo::setAtomicVelocityAtStep() - Access out of range.");
  if(_step < (int)AtomicVelocity.size()) {
    AtomicVelocity[_step] = _newvelocity;
  } else if (_step == (int)AtomicVelocity.size()) {
    AtomicVelocity.push_back(_newvelocity);
  }
}

const Vector& AtomInfo::getAtomicForce() const
{
  ASSERT(0 < AtomicForce.size(),
      "AtomInfo::getAtomicForce() - Access out of range.");
  return AtomicForce[0];
}

const Vector& AtomInfo::getAtomicForceAtStep(const int _step) const
{
  ASSERT(_step < AtomicForce.size(),
      "AtomInfo::getAtomicForce() - Access out of range.");
  return AtomicForce[_step];
}

void AtomInfo::setAtomicForce(const Vector &_newforce)
{
  ASSERT(0 < AtomicForce.size(),
      "AtomInfo::setAtomicForce() - Access out of range.");
  AtomicForce[0] = _newforce;
}

void AtomInfo::setAtomicForceAtStep(const int _step, const Vector &_newforce)
{
  const int size = AtomicForce.size();
  ASSERT(_step <= size,
      "AtomInfo::setAtomicForce() - Access out of range.");
  if(_step < size) {
    AtomicForce[_step] = _newforce;
  } else if (_step == size) {
    AtomicForce.push_back(_newforce);
  }
}

bool AtomInfo::getFixedIon() const
{
  return FixedIon;
}

void AtomInfo::setFixedIon(const bool _fixedion)
{
  FixedIon = _fixedion;
}

void AtomInfo::setPosition(const Vector& _vector)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::setPosition() - Access out of range.");
  AtomicPosition[0] = _vector;
  //cout << "AtomInfo::setPosition: " << getType()->symbol << " at " << getPosition() << endl;
}

void AtomInfo::setPositionAtStep(int _step, const Vector& _vector)
{
  ASSERT(_step <= AtomicPosition.size(),
      "AtomInfo::setPosition() - Access out of range.");
  if(_step < (int)AtomicPosition.size()) {
    AtomicPosition[_step] = _vector;
  } else if (_step == (int)AtomicPosition.size()) {
    AtomicPosition.push_back(_vector);
  }
  //cout << "AtomInfo::setPosition: " << getType()->symbol << " at " << getPosition() << endl;
}

const VectorInterface& AtomInfo::operator+=(const Vector& b)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::operator+=() - Access out of range.");
  AtomicPosition[0] += b;
  return *this;
}

const VectorInterface& AtomInfo::operator-=(const Vector& b)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::operator-=() - Access out of range.");
  AtomicPosition[0] -= b;
  return *this;
}

Vector const AtomInfo::operator+(const Vector& b) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::operator+() - Access out of range.");
  Vector a(AtomicPosition[0]);
  a += b;
  return a;
}

Vector const AtomInfo::operator-(const Vector& b) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::operator-() - Access out of range.");
  Vector a(AtomicPosition[0]);
  a -= b;
  return a;
}

double AtomInfo::distance(const Vector &point) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::distance() - Access out of range.");
  return AtomicPosition[0].distance(point);
}

double AtomInfo::DistanceSquared(const Vector &y) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::DistanceSquared() - Access out of range.");
  return AtomicPosition[0].DistanceSquared(y);
}

double AtomInfo::distance(const VectorInterface &_atom) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::distance() - Access out of range.");
  return _atom.distance(AtomicPosition[0]);
}

double AtomInfo::DistanceSquared(const VectorInterface &_atom) const
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::DistanceSquared() - Access out of range.");
  return _atom.DistanceSquared(AtomicPosition[0]);
}

VectorInterface &AtomInfo::operator=(const Vector& _vector)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::operator=() - Access out of range.");
  AtomicPosition[0] = _vector;
  return *this;
}

void AtomInfo::ScaleAll(const double *factor)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::ScaleAll() - Access out of range.");
  AtomicPosition[0].ScaleAll(factor);
}

void AtomInfo::ScaleAll(const Vector &factor)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::ScaleAll() - Access out of range.");
  AtomicPosition[0].ScaleAll(factor);
}

void AtomInfo::Scale(const double factor)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::Scale() - Access out of range.");
  AtomicPosition[0].Scale(factor);
}

void AtomInfo::Zero()
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::Zero() - Access out of range.");
  AtomicPosition[0].Zero();
}

void AtomInfo::One(const double one)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::One() - Access out of range.");
  AtomicPosition[0].One(one);
}

void AtomInfo::LinearCombinationOfVectors(const Vector &x1, const Vector &x2, const Vector &x3, const double * const factors)
{
  ASSERT(0 < AtomicPosition.size(),
      "AtomInfo::LinearCombinationOfVectors() - Access out of range.");
  AtomicPosition[0].LinearCombinationOfVectors(x1,x2,x3,factors);
}

/**
 *  returns the kinetic energy of this atom at a given time step
 */
double AtomInfo::getKineticEnergy(unsigned int _step) const{
  ASSERT(_step < AtomicPosition.size(),
      "AtomInfo::getKineticEnergy() - Access out of range.");
  return getMass() * AtomicVelocity[_step].NormSquared();
}

Vector AtomInfo::getMomentum(unsigned int _step) const{
  ASSERT(_step < AtomicPosition.size(),
      "AtomInfo::getMomentum() - Access out of range.");
  return getMass()*AtomicVelocity[_step];
}

/** Extends the trajectory STL vector to the new size.
 * Does nothing if \a MaxSteps is smaller than current size.
 * \param MaxSteps
 */
void AtomInfo::ResizeTrajectory(size_t MaxSteps)
{
  if (AtomicPosition.size() <= (unsigned int)(MaxSteps)) {
    DoLog(0) && (Log() << Verbose(0) << "Increasing size for trajectory array from " << AtomicPosition.size() << " to " << (MaxSteps+1) << "." << endl);
    AtomicPosition.resize(MaxSteps+1, zeroVec);
    AtomicVelocity.resize(MaxSteps+1, zeroVec);
    AtomicForce.resize(MaxSteps+1, zeroVec);
  }
};

size_t AtomInfo::getTrajectorySize() const
{
  return AtomicPosition.size();
}

double AtomInfo::getMass() const{
  return AtomicElement->getMass();
}

/** Copies a given trajectory step \a src onto another \a dest
 * \param dest index of destination step
 * \param src index of source step
 */
void AtomInfo::CopyStepOnStep(int dest, int src)
{
  if (dest == src)  // self assignment check
    return;

  ASSERT(dest < AtomicPosition.size(),
      "AtomInfo::CopyStepOnStep() - destination outside of current trajectory array.");
  ASSERT(src < AtomicPosition.size(),
      "AtomInfo::CopyStepOnStep() - source outside of current trajectory array.");
  for (int n=NDIM;n--;) {
    AtomicPosition.at(dest)[n] = AtomicPosition.at(src)[n];
    AtomicVelocity.at(dest)[n] = AtomicVelocity.at(src)[n];
    AtomicForce.at(dest)[n] = AtomicForce.at(src)[n];
  }
};

/** Performs a velocity verlet update of the trajectory.
 * Parameters are according to those in configuration class.
 * \param NextStep index of sequential step to set
 * \param *configuration pointer to configuration with parameters
 * \param *Force matrix with forces
 */
void AtomInfo::VelocityVerletUpdate(int nr, int NextStep, config *configuration, ForceMatrix *Force, const size_t offset)
{
  // update force
  // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
  Vector tempVector;
  for (int d=0; d<NDIM; d++)
    tempVector[d] = -Force->Matrix[0][nr][d+offset]*(configuration->GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
  setAtomicForceAtStep(NextStep, tempVector);

  // update position
  tempVector = getPositionAtStep(NextStep-1);
  tempVector += configuration->Deltat*(getAtomicVelocityAtStep(NextStep-1));     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2
  tempVector += 0.5*configuration->Deltat*configuration->Deltat*(getAtomicForceAtStep(NextStep))*(1./getMass());     // F = m * a and s =
  setPositionAtStep(NextStep, tempVector);

  // Update U
  tempVector = getAtomicVelocityAtStep(NextStep-1);
  tempVector += configuration->Deltat * (getAtomicForceAtStep(NextStep)+getAtomicForceAtStep(NextStep-1))*(1./getMass()); // v = F/m * t
  setAtomicVelocityAtStep(NextStep, tempVector);

  // some info for debugging
  DoLog(2) && (Log() << Verbose(2)
      << "Integrated position&velocity of step " << (NextStep) << ": ("
      << getPositionAtStep(NextStep) << ")\t("
      << getAtomicVelocityAtStep(NextStep) << ")" << std::endl);
};

const AtomInfo& operator*=(AtomInfo& a, const double m)
{
  a.Scale(m);
  return a;
}

AtomInfo const operator*(const AtomInfo& a, const double m)
{
  AtomInfo copy(a);
  copy *= m;
  return copy;
}

AtomInfo const operator*(const double m, const AtomInfo& a)
{
  AtomInfo copy(a);
  copy *= m;
  return copy;
}

std::ostream & AtomInfo::operator << (std::ostream &ost) const
{
  return (ost << getPosition());
}

std::ostream & operator << (std::ostream &ost, const AtomInfo &a)
{
  ost << a;
  return ost;
}