Line data    Source code

       1              : // Copyright (C) 2015 Technische Universitaet Muenchen
       2              : // This file is part of the Mamico project. For conditions of distribution
       3              : // and use, please see the copyright notice in Mamico's main folder, or at
       4              : // www5.in.tum.de/mamico
       5              : #ifndef _MOLECULARDYNAMICS_COUPLING_CELLMAPPINGS_COMPUTEMEANPOTENTIALENERGYMAPPING_H_
       6              : #define _MOLECULARDYNAMICS_COUPLING_CELLMAPPINGS_COMPUTEMEANPOTENTIALENERGYMAPPING_H_
       7              : 
       8              : #include "coupling/BoundaryForceController.h"
       9              : #include "coupling/interface/MDSolverInterface.h"
      10              : #include "coupling/interface/Molecule.h"
      11              : #include <iostream>
      12              : 
      13              : namespace coupling {
      14              : namespace cellmappings {
      15              : template <class LinkedCell, unsigned int dim> class ComputeMeanPotentialEnergyMapping;
      16              : }
      17              : } // namespace coupling
      18              : 
      19              : /**
      20              :  *      @brief This class computes the mean potential energy over this
      21              :  *coupling cell.
      22              :  *      @tparam LinkedCell cell type
      23              :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      24              :  *  @author Philipp Neumann
      25              :  */
      26              : template <class LinkedCell, unsigned int dim> class coupling::cellmappings::ComputeMeanPotentialEnergyMapping {
      27              : public:
      28              :   /** Constructor
      29              :    *    @param mdSolverInterface
      30              :    *    @param boundaryForceController
      31              :    */
      32            0 :   ComputeMeanPotentialEnergyMapping(coupling::interface::MDSolverInterface<LinkedCell, dim>* const mdSolverInterface,
      33              :                                     const coupling::BoundaryForceController<LinkedCell, dim>& boundaryForceController)
      34            0 :       : _mdSolverInterface(mdSolverInterface), _meanPotentialEnergy(0.0), _particleCounter(0), _boundaryForceController(boundaryForceController) {}
      35              : 
      36              :   /** Destructor */
      37            0 :   ~ComputeMeanPotentialEnergyMapping() {}
      38              : 
      39              :   /** sets the mean potential energy and the particle counter to zero, before
      40              :    * the iteration process begins.
      41              :    */
      42            0 :   void beginCellIteration() {
      43            0 :     _meanPotentialEnergy = 0.0;
      44            0 :     _particleCounter = 0;
      45              :   }
      46              : 
      47              :   /** computes the mean potential energy in a linked cell, by dividing the
      48              :    * summation of the mean potential energy of all particles inside the cell
      49              :    * over the number of particles.
      50              :    */
      51            0 :   void endCellIteration() {
      52            0 :     if (_particleCounter != 0) {
      53            0 :       _meanPotentialEnergy = _meanPotentialEnergy / _particleCounter;
      54              :     }
      55              :   }
      56              : 
      57              :   /** counts the molecules inside a linked cell and sums up the of the mean
      58              :    *potential energy of all particles inside the cell.
      59              :    *    @param cell
      60              :    */
      61            0 :   void handleCell(LinkedCell& cell) {
      62            0 :     coupling::interface::MoleculeIterator<LinkedCell, dim>* it = _mdSolverInterface->getMoleculeIterator(cell);
      63            0 :     it->begin();
      64            0 :     while (it->continueIteration()) {
      65            0 :       const coupling::interface::Molecule<dim>& wrapper(it->getConst());
      66            0 :       _meanPotentialEnergy += wrapper.getPotentialEnergy();
      67            0 :       _meanPotentialEnergy += _boundaryForceController.getPotentialEnergy(wrapper.getPosition());
      68            0 :       _particleCounter++;
      69              : 
      70            0 :       it->next();
      71              :     }
      72            0 :     delete it;
      73            0 :   }
      74              : 
      75              :   /** returns the mean potential energy inside a linked cell
      76              :    *    @return _meanPotentialEnergy
      77              :    */
      78            0 :   double getPotentialEnergy() const { return _meanPotentialEnergy; }
      79              : 
      80              : private:
      81              :   coupling::interface::MDSolverInterface<LinkedCell, dim>* const _mdSolverInterface;
      82              :   double _meanPotentialEnergy;
      83              :   unsigned int _particleCounter;
      84              :   const coupling::BoundaryForceController<LinkedCell, dim>& _boundaryForceController;
      85              : };
      86              : #endif // _MOLECULARDYNAMICS_COUPLING_CELLMAPPINGS_COMPUTEMEANPOTENTIALENERGYMAPPING_H_