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_MOMENTUMCONTROLLER_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_MOMENTUMCONTROLLER_H_
       7             : 
       8             : #include "coupling/cell-mappings/ComputeMassMapping.h"
       9             : #include "coupling/cell-mappings/ComputeMomentumMapping.h"
      10             : #include "coupling/cell-mappings/SetMomentumMapping.h"
      11             : #include "coupling/datastructures/CouplingCell.h"
      12             : #include "tarch/la/Vector.h"
      13             : 
      14             : namespace coupling {
      15             : template <class LinkedCell, unsigned int dim> class MomentumController;
      16             : }
      17             : 
      18             : /** This class can compute the momentum and set a certain value for the
      19             :  * momentum.
      20             :  *  @brief controls the momentum in a coupling cell.
      21             :  *  @author Philipp Neumann
      22             :  *  @tparam LinkedCell the LinkedCell class is given by the implementation of
      23             :  * linked cells in the molecular dynamics simulation
      24             :  *  @tparam dim  refers to the spacial dimension of the simulation, can be 1, 2,
      25             :  * or 3 */
      26             : template <class LinkedCell, unsigned int dim> class coupling::MomentumController {
      27             : public:
      28             :   /** @brief a simple constructor
      29             :    *  @param mdSolverInterface interface to the md solver */
      30           4 :   MomentumController(coupling::interface::MDSolverInterface<LinkedCell, dim>* const mdSolverInterface)
      31           4 :       : _computeMassMapping(mdSolverInterface), _computeMomentumMapping(mdSolverInterface), _mdSolverInterface(mdSolverInterface) {}
      32             : 
      33             :   /** a simple destructor */
      34           0 :   ~MomentumController() {}
      35             : 
      36             :   /** @brief computes and returns the momentum and mean velocity of a
      37             :    * coupling cell
      38             :    *  @param cell the coupling cell, for which the values shall be calculated
      39             :    *  @param momentum vector to which the momentum of the cell will be written
      40             :    * to
      41             :    *  @param meanVelocity vector to which the mean velocity of the cell will be
      42             :    * written to*/
      43           0 :   void computeMomentumAndMeanVelocity(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, tarch::la::Vector<dim, double>& momentum,
      44             :                                       tarch::la::Vector<dim, double>& meanVelocity) {
      45           0 :     cell.iterateConstCells(_computeMomentumMapping);
      46           0 :     momentum = _computeMomentumMapping.getMomentum();
      47           0 :     meanVelocity = _computeMomentumMapping.getMeanVelocity();
      48           0 :   }
      49             : 
      50             :   /** @brief computes and returns the momentum of a coupling cell
      51             :    * @param cell the coupling cell, for which the values shall be calculated
      52             :    *  @param momentum vector to which the momentum of the cell will be written
      53             :    * to */
      54           0 :   void computeMomentum(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, tarch::la::Vector<dim, double>& momentum) {
      55           0 :     cell.iterateConstCells(_computeMomentumMapping);
      56           0 :     momentum = _computeMomentumMapping.getMomentum();
      57           0 :   }
      58             : 
      59             :   /** computes and returns the mean velocity of a coupling cell
      60             :    *  @param cell the coupling cell, for which the values shall be calculated
      61             :    *  @param meanVelocity vector to which the mean velocity of the cell will be
      62             :    * written to*/
      63             :   void computeMeanVelocity(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, tarch::la::Vector<dim, double>& meanVelocity) {
      64             :     cell.iterateConstCells(_computeMomentumMapping);
      65             :     meanVelocity = _computeMomentumMapping.getMeanVelocity();
      66             :   }
      67             : 
      68             :   /** This cell does not consider the kinetic energy of the system, so the
      69             :    * kinetic energy will be different after executing this method! In order to
      70             :    * also retain the kinetic energy, one might compute the kinetic energy before
      71             :    * calling this method (using the KineticEnergyController) and set the old
      72             :    * kinetic energy afterwards (again using the KineticEnergyController). This
      73             :    * will then set the right kinetic energy again, conserving both mass and
      74             :    * momentum over this cell.
      75             :    *  @brief sets the momentum of a coupling cell to the input value.
      76             :    *  @param cell the coupling cell in which the momentum shall be changed
      77             :    *  @param newMomentum the value to which the momentum will be set */
      78           0 :   void setMomentum(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const tarch::la::Vector<dim, double>& newMomentum) {
      79           0 :     tarch::la::Vector<dim, double> currentMomentum(0.0);
      80           0 :     computeMomentum(cell, currentMomentum);
      81           0 :     cell.iterateConstCells(_computeMassMapping);
      82           0 :     unsigned int numberParticles = _computeMassMapping.getNumberOfParticles();
      83           0 :     coupling::cellmappings::SetMomentumMapping<LinkedCell, dim> setMomentumMapping(currentMomentum, newMomentum, numberParticles, _mdSolverInterface);
      84           0 :     cell.iterateCells(setMomentumMapping);
      85           0 :   }
      86             : 
      87             : private:
      88             :   /** instance of the ComputeMassMapping */
      89             :   coupling::cellmappings::ComputeMassMapping<LinkedCell, dim> _computeMassMapping;
      90             :   /** instance of the ComputeMomentumMapping*/
      91             :   coupling::cellmappings::ComputeMomentumMapping<LinkedCell, dim> _computeMomentumMapping;
      92             :   /** interface to the md solver*/
      93             :   coupling::interface::MDSolverInterface<LinkedCell, dim>* const _mdSolverInterface;
      94             : };
      95             : #endif // _MOLECULARDYNAMICS_COUPLING_MOMENTUMCONTROLLER_H_