Index: src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -89,4 +89,8 @@
 QtObservedAtom::AtomPositionChannels(1, AtomObservable::PositionChanged);
 const Observable::channels_t
+QtObservedAtom::AtomVelocityChannels(1, AtomObservable::VelocityChanged);
+const Observable::channels_t
+QtObservedAtom::AtomForceChannels(1, AtomObservable::ForceChanged);
+const Observable::channels_t
 QtObservedAtom::AtomSelectedChannels(1, AtomObservable::SelectionChanged);
 
@@ -124,4 +128,6 @@
   boost::any_cast<ObservedValue_wCallback<std::string, ObservedValue_Index_t> *>(ObservedValues[AtomName])->noteCallBackIsGone();
   boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomPosition])->noteCallBackIsGone();
+  boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomVelocity])->noteCallBackIsGone();
+  boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomForce])->noteCallBackIsGone();
   boost::any_cast<ObservedValue_wCallback<bool, ObservedValue_Index_t> *>(ObservedValues[AtomSelected])->noteCallBackIsGone();
 
@@ -215,4 +221,22 @@
 inline
 #endif
+Vector QtObservedAtom::updateVelocity(
+    const atom &_atom)
+{
+  return _atom.getAtomicVelocity();
+}
+
+#ifdef HAVE_INLINE
+inline
+#endif
+Vector QtObservedAtom::updateForce(
+    const atom &_atom)
+{
+  return _atom.getAtomicForce();
+}
+
+#ifdef HAVE_INLINE
+inline
+#endif
 bool QtObservedAtom::updateSelected(
     const atom &_atom)
@@ -269,8 +293,14 @@
     boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
         ObservedValues[AtomPosition])->forceUpdate();
+    boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
+        ObservedValues[AtomVelocity])->forceUpdate();
+    boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
+        ObservedValues[AtomForce])->forceUpdate();
     boost::any_cast<ObservedValue_wCallback<QtObservedMolecule*, ObservedValue_Index_t> *>(
         ObservedValues[MoleculeRef])->forceUpdate();
     // then tell Qt part about updates
     emit positionChanged();
+    emit velocityChanged();
+    emit forceChanged();
     emit moleculeChanged();
   } else {
@@ -296,4 +326,10 @@
       case AtomObservable::PositionChanged:
         emit positionChanged();
+        break;
+      case AtomObservable::VelocityChanged:
+        emit velocityChanged();
+        break;
+      case AtomObservable::ForceChanged:
+        emit forceChanged();
         break;
       case AtomObservable::SelectionChanged:
@@ -362,4 +398,8 @@
   const boost::function<Vector ()> AtomPositionUpdater(
       boost::bind(&QtObservedAtom::updatePosition, boost::cref(*_atomref)));
+  const boost::function<Vector ()> AtomVelocityUpdater(
+      boost::bind(&QtObservedAtom::updateVelocity, boost::cref(*_atomref)));
+  const boost::function<Vector ()> AtomForceUpdater(
+      boost::bind(&QtObservedAtom::updateForce, boost::cref(*_atomref)));
   const boost::function<bool ()> AtomSelectedUpdater(
       boost::bind(&QtObservedAtom::updateSelected, boost::cref(*_atomref)));
@@ -401,4 +441,18 @@
       AtomPositionUpdater(),
       AtomPositionChannels,
+      _subjectKilled);
+  _ObservedValues[AtomVelocity] = new ObservedValue_wCallback<Vector, ObservedValue_Index_t>(
+      _atomref,
+      AtomVelocityUpdater,
+      "AtomVelocity_"+toString(_id),
+      AtomVelocityUpdater(),
+      AtomVelocityChannels,
+      _subjectKilled);
+  _ObservedValues[AtomForce] = new ObservedValue_wCallback<Vector, ObservedValue_Index_t>(
+      _atomref,
+      AtomForceUpdater,
+      "AtomForce_"+toString(_id),
+      AtomForceUpdater(),
+      AtomForceChannels,
       _subjectKilled);
   _ObservedValues[AtomSelected] = new ObservedValue_wCallback<bool, ObservedValue_Index_t>(
@@ -426,4 +480,6 @@
   delete boost::any_cast<ObservedValue_wCallback<std::string, ObservedValue_Index_t> *>(_ObservedValues[AtomName]);
   delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomPosition]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomVelocity]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomForce]);
   delete boost::any_cast<ObservedValue_wCallback<bool, ObservedValue_Index_t> *>(_ObservedValues[AtomSelected]);
   delete boost::any_cast<ObservedValue_wCallback<QtObservedMolecule*, ObservedValue_Index_t> *>(_ObservedValues[MoleculeRef]);
@@ -463,4 +519,14 @@
 }
 
+const Vector& QtObservedAtom::getAtomVelocity() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomVelocity])->get();
+}
+
+const Vector& QtObservedAtom::getAtomForce() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomForce])->get();
+}
+
 const bool QtObservedAtom::getAtomSelected() const
 {
Index: src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -136,4 +136,16 @@
   const Vector& getAtomPosition() const;
 
+  /** Getter to atom velocity contained in \a ObservedValues.
+   *
+   * \return atom's velocity
+   */
+  const Vector& getAtomVelocity() const;
+
+  /** Getter to atom force contained in \a ObservedValues.
+   *
+   * \return atom's force
+   */
+  const Vector& getAtomForce() const;
+
   /** Getter to the observed state of the associated molecule.
    *
@@ -155,4 +167,6 @@
   void nameChanged();
   void positionChanged();
+  void velocityChanged();
+  void forceChanged();
   void atomRemoved();
   void selectedChanged();
@@ -174,4 +188,6 @@
   static std::string updateName(const atom &_atom);
   static Vector updatePosition(const atom &_atom);
+  static Vector updateVelocity(const atom &_atom);
+  static Vector updateForce(const atom &_atom);
   static bool updateSelected(const atom &_atom);
 
@@ -188,4 +204,8 @@
     //!> contains the current atom position
     AtomPosition,
+    //!> contains the current atom velocity
+    AtomVelocity,
+    //!> contains the current atom force
+    AtomForce,
     //!> contains the current atom's selection status
     AtomSelected,
@@ -253,4 +273,8 @@
   //!> list of channels when position needs to update
   static const Observable::channels_t AtomPositionChannels;
+  //!> list of channels when velocity needs to update
+  static const Observable::channels_t AtomVelocityChannels;
+  //!> list of channels when force needs to update
+  static const Observable::channels_t AtomForceChannels;
   //!> list of channels when selection needs to update
   static const Observable::channels_t AtomSelectedChannels;
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -61,8 +61,11 @@
 QGLMaterial *GLMoleculeObject::m_selectionMaterial = NULL;
 QGLMaterial *GLMoleculeObject::m_selectionBoxMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_velocityMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_forceMaterial = NULL;
 
 QGLSceneNode *GLMoleculeObject::meshEmpty[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshSphere[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshCylinder[GLMoleculeObject::DETAILTYPES_MAX];
+QGLSceneNode *GLMoleculeObject::meshArrow[GLMoleculeObject::DETAILTYPES_MAX];
 
 double GLMoleculeObject::detailMinDistance[GLMoleculeObject::DETAILTYPES_MAX] = {0, 15, 30, 42};
@@ -309,4 +312,14 @@
     m_selectionBoxMaterial->setEmittedLight( QColor(155, 50, 50) );
   }
+  if (!m_velocityMaterial){
+    m_velocityMaterial = new QGLMaterial(NULL);
+    QColor colorvelocity(50,50,255,255);
+    m_velocityMaterial->setColor(colorvelocity);
+  }
+  if (!m_forceMaterial){
+    m_forceMaterial = new QGLMaterial(NULL);
+    QColor colorforce(50,255,50,255);
+    m_forceMaterial->setColor(colorforce);
+  }
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -108,4 +108,5 @@
    static QGLSceneNode *meshSphere[DETAILTYPES_MAX];
    static QGLSceneNode *meshCylinder[DETAILTYPES_MAX];
+   static QGLSceneNode *meshArrow[DETAILTYPES_MAX];
 
 protected:
@@ -130,4 +131,6 @@
    static QGLMaterial *m_selectionMaterial;
    static QGLMaterial *m_selectionBoxMaterial;
+   static QGLMaterial *m_velocityMaterial;
+   static QGLMaterial *m_forceMaterial;
    QGLAbstractEffect *m_effect;
    int m_objectId;
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -50,4 +50,5 @@
 #include "Element/element.hpp"
 #include "Element/periodentafel.hpp"
+#include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/Vector.hpp"
 #include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp"
@@ -57,7 +58,10 @@
 GLMoleculeObject_atom::GLMoleculeObject_atom(
     QGLSceneNode *mesh[],
+    QGLSceneNode *mesharrow[],
     QObject *parent,
     QtObservedAtom::ptr &_ObservedAtom) :
   GLMoleculeObject(mesh, parent),
+  GLMoleculeObjectVelocity(mesharrow, this),
+  GLMoleculeObjectForce(mesharrow, this),
   ObservedAtom(_ObservedAtom)
 {
@@ -69,5 +73,10 @@
   setObjectId(_id);
   resetPosition();
+  resetVelocity();
+  resetForce();
   resetElement();
+
+  GLMoleculeObjectVelocity.setMaterial(GLMoleculeObject::m_velocityMaterial);
+  GLMoleculeObjectForce.setMaterial(GLMoleculeObject::m_forceMaterial);
 
   m_selected = ObservedAtom->getAtomSelected();
@@ -77,4 +86,6 @@
   connect( ObservedAtom.get(), SIGNAL(elementChanged()), this, SLOT(resetElement()));
   connect( ObservedAtom.get(), SIGNAL(positionChanged()), this, SLOT(resetPosition()));
+  connect( ObservedAtom.get(), SIGNAL(velocityChanged()), this, SLOT(resetVelocity()));
+  connect( ObservedAtom.get(), SIGNAL(forceChanged()), this, SLOT(resetForce()));
   connect( ObservedAtom.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
 }
@@ -95,4 +106,15 @@
 }
 
+static void setArrow(
+    const Vector &_position,
+    const Vector &_arrow,
+    const double _offset,
+    GLMoleculeObject &_obj)
+{
+  // set position (cylinder offset is in its barymetric center)
+  Vector OneFourth(_position + (_offset/_arrow.Norm()+.75) * _arrow);
+  _obj.setPosition(QVector3D(OneFourth[0], OneFourth[1], OneFourth[2]));
+}
+
 void GLMoleculeObject_atom::resetPosition()
 {
@@ -100,4 +122,57 @@
   LOG(4, "INFO: GLMoleculeObject_atom::resetPosition() - new position is "+toString(Position)+".");
   setPosition(QVector3D(Position[0], Position[1], Position[2]));
+  setArrow(Position, 10.*ObservedAtom->getAtomVelocity(), scaleX(), GLMoleculeObjectVelocity);
+  setArrow(Position, 10.*ObservedAtom->getAtomForce(), scaleX(), GLMoleculeObjectForce);
+}
+
+static void alignArrow(
+    const Vector &_arrow,
+    GLMoleculeObject &_obj)
+{
+  if (_arrow.IsZero()) {
+    _obj.setScaleZ(0.);
+    return;
+  }
+  // calculate position
+  Vector Z(unitVec[2]); // cylinder are initially aligned along the Z axis
+  Vector b;
+  Vector OtherAxis;
+  double alpha;
+  // construct rotation axis
+  b = -1.*_arrow;
+  b.VectorProduct(Z);
+  Line axis(zeroVec, b);
+  // calculate rotation angle
+  alpha = _arrow.Angle(Z);
+  // construct other axis to check right-hand rule
+  OtherAxis = b;
+  OtherAxis.VectorProduct(Z);
+  // assure right-hand rule for the rotation
+  if (_arrow.ScalarProduct(OtherAxis) < MYEPSILON)
+    alpha = M_PI-alpha;
+  // check
+  Vector a_rotated = axis.rotateVector(_arrow, alpha);
+  LOG(5, "DEBUG: Aligning arrow " << _arrow << " to " << a_rotated
+      << " around " << b << " by " << alpha/M_PI*180. << ".");
+
+  _obj.setScaleZ(10.*_arrow.Norm());
+  _obj.setRotationVector(QVector3D(b[0], b[1], b[2]));
+  _obj.setRotationAngle(alpha/M_PI*180.);
+}
+
+void GLMoleculeObject_atom::resetVelocity()
+{
+  const Vector Velocity = ObservedAtom->getAtomVelocity();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetVelocity() - new velocity is "+toString(Velocity)+".");
+  alignArrow(Velocity, GLMoleculeObjectVelocity);
+//  GLMoleculeObjectForce.setScaleZ(Velocity.Norm());
+}
+
+void GLMoleculeObject_atom::resetForce()
+{
+  const Vector Force = ObservedAtom->getAtomForce();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetForce() - new force is "+toString(Force)+".");
+  alignArrow(Force, GLMoleculeObjectForce);
+//  GLMoleculeObjectForce.setScaleZ(Force.Norm());
 }
 
@@ -144,4 +219,6 @@
   // call old hook to do the actual paining
   GLMoleculeObject::draw(painter, cameraPlane);
+  GLMoleculeObjectVelocity.draw(painter, cameraPlane);
+  GLMoleculeObjectForce.draw(painter, cameraPlane);
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -34,4 +34,5 @@
   GLMoleculeObject_atom(
       QGLSceneNode *mesh[],
+      QGLSceneNode *mesharrow[],
       QObject *parent,
       QtObservedAtom::ptr &_ObservedAtom
@@ -46,4 +47,6 @@
   void resetElement();
   void resetPosition();
+  void resetVelocity();
+  void resetForce();
   void resetSelected();
 
@@ -58,4 +61,9 @@
 
 private:
+  //!> internal GLMoleculeObject to represent the atom's velocity as an arrow
+  GLMoleculeObject GLMoleculeObjectVelocity;
+  //!> internal GLMoleculeObject to represent the atom's force as an arrow
+  GLMoleculeObject GLMoleculeObjectForce;
+
   //!> current list of bonds to compare new onw against for changes
   QtObservedAtom::ListOfBonds_t ListOfBonds;
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -154,4 +154,5 @@
   int sphereDetails[] = {5, 3, 2, 0};
   int cylinderDetails[] = {16, 8, 6, 3};
+  int arrowDetails[] = {8, 5, 3, 0};
   for (int i=0;i<GLMoleculeObject::DETAILTYPES_MAX;i++){
     QGLBuilder emptyBuilder;
@@ -165,4 +166,21 @@
     GLMoleculeObject::meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
     GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    {
+      QGLBuilder builderCyl;
+      builderCyl << QGLCylinder(.15,.15,1.6,arrowDetails[i]);
+      QGLSceneNode *cyl = builderCyl.finalizedSceneNode();
+      QGLBuilder builderCone;
+      builderCone << QGLCylinder(0,.4,0.4,arrowDetails[i]);
+      QGLSceneNode *cone = builderCone.finalizedSceneNode();
+      {
+        QMatrix4x4 mat;
+        mat.translate(0.0f, 0.0f, 1.0f);
+        cone->setLocalTransform(mat);
+      }
+      GLMoleculeObject::meshArrow[i] = new QGLSceneNode(this);
+      GLMoleculeObject::meshArrow[i]->addNode(cyl);
+      GLMoleculeObject::meshArrow[i]->addNode(cone);
+    }
+    GLMoleculeObject::meshArrow[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
   connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
@@ -279,4 +297,5 @@
     atomObject = new GLMoleculeObject_atom(
             GLMoleculeObject::meshSphere,
+            GLMoleculeObject::meshArrow,
             parent,
             _atom);
Index: src/UIElements/Views/Qt4/QtInfoBox.cpp
===================================================================
--- src/UIElements/Views/Qt4/QtInfoBox.cpp	(revision 8450dae3b6ce23db9afb756a259d2605c8f22409)
+++ src/UIElements/Views/Qt4/QtInfoBox.cpp	(revision 897a018da758c7cae890e36cd28b044f33ad9e7e)
@@ -65,5 +65,5 @@
 
   setMinimumWidth(200);
-  setMinimumHeight(220);
+  setMinimumHeight(350);
 
   connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeout()));
@@ -220,4 +220,10 @@
   addInfo(this, "Position y", QString(toString(atomRef->getAtomPosition()[1]).c_str()));
   addInfo(this, "Position z", QString(toString(atomRef->getAtomPosition()[2]).c_str()));
+  addInfo(this, "Velocity x", QString(toString(atomRef->getAtomVelocity()[0]).c_str()));
+  addInfo(this, "Velocity y", QString(toString(atomRef->getAtomVelocity()[1]).c_str()));
+  addInfo(this, "Velocity z", QString(toString(atomRef->getAtomVelocity()[2]).c_str()));
+  addInfo(this, "Force x", QString(toString(atomRef->getAtomForce()[0]).c_str()));
+  addInfo(this, "Force y", QString(toString(atomRef->getAtomForce()[1]).c_str()));
+  addInfo(this, "Force z", QString(toString(atomRef->getAtomForce()[2]).c_str()));
 }
 
