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_NIEVELOCITYIMPOSITIONMAPPING_H_
       6              : #define _MOLECULARDYNAMICS_COUPLING_CELLMAPPINGS_NIEVELOCITYIMPOSITIONMAPPING_H_
       7              : 
       8              : #include "coupling/CouplingMDDefinitions.h"
       9              : #include "coupling/datastructures/CouplingCell.h"
      10              : #include "coupling/interface/MDSolverInterface.h"
      11              : #include "coupling/interface/Molecule.h"
      12              : #include "tarch/la/Matrix.h"
      13              : #include <iostream>
      14              : 
      15              : namespace coupling {
      16              : namespace cellmappings {
      17              : template <class LinkedCell, unsigned int dim> class NieVelocityImpositionMapping;
      18              : }
      19              : } // namespace coupling
      20              : 
      21              : /** employs an acceleration based on velocity gradients (in time) using the
      22              :  *forcing term of the molecules. We currently expect that valid force entries
      23              :  *are provided in each molecule, that is all molecule-molecule interactions have
      24              :  *previously been computed. The scheme follows the descriptions in the paper by
      25              :  *Nie et al., J. Fluid. Mech. 500, 55-64, 2004. However, we only average over
      26              :  *single grid cells (no averaging over one (periodic) dimension or similar
      27              :  *tricks ;-) ).
      28              :  *      @brief This class employs an acceleration based on velocity gradients
      29              :  *(in time) using the forcing term of the molecules.
      30              :  *      @tparam LinkedCell cell type
      31              :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      32              :  *  @author Philipp Neumann
      33              :  */
      34              : template <class LinkedCell, unsigned int dim> class coupling::cellmappings::NieVelocityImpositionMapping {
      35              : public:
      36              :   /** Constructor
      37              :    *    @param continuumVelocity    current velocity in this coupling cell
      38              :    *(=velocity from continuum solver)
      39              :    *    @param avgMDVelocity            current avg. velocity of molecules
      40              :    *    @param avgForce                         average force within this
      41              :    *coupling cell
      42              :    *    @param mdSolverInterface        MD solver interface, required for
      43              :    *molecule iterator and molecule mass
      44              :    */
      45            0 :   NieVelocityImpositionMapping(const tarch::la::Vector<dim, double>& continuumVelocity, const tarch::la::Vector<dim, double>& avgMDVelocity,
      46              :                                const tarch::la::Vector<dim, double>& avgForce, coupling::interface::MDSolverInterface<LinkedCell, dim>* const mdSolverInterface)
      47            0 :       : _mdSolverInterface(mdSolverInterface), _continuumVelocity(continuumVelocity), _avgMDVelocity(avgMDVelocity), _avgForce(avgForce) {}
      48              : 
      49              :   /** Destructor */
      50            0 :   virtual ~NieVelocityImpositionMapping() {}
      51              : 
      52              :   /** empty function
      53              :    */
      54              :   void beginCellIteration() {}
      55              : 
      56              :   /** empty function
      57              :    */
      58              :   void endCellIteration() {}
      59              : 
      60              :   /** This function computes average force contribution inside this linked cell
      61              :    *    @param cell
      62              :    */
      63            0 :   void handleCell(LinkedCell& cell) {
      64            0 :     coupling::interface::MoleculeIterator<LinkedCell, dim>* it = _mdSolverInterface->getMoleculeIterator(cell);
      65              : 
      66            0 :     it->begin();
      67            0 :     while (it->continueIteration()) {
      68            0 :       coupling::interface::Molecule<dim>& wrapper(it->get());
      69            0 :       tarch::la::Vector<dim, double> force(wrapper.getForce());
      70            0 :       force = force - _avgForce - (_mdSolverInterface->getMoleculeMass() / _mdSolverInterface->getDt()) * (_avgMDVelocity - _continuumVelocity);
      71            0 :       wrapper.setForce(force);
      72            0 :       it->next();
      73              :     }
      74            0 :     delete it;
      75            0 :   }
      76              : 
      77              : private:
      78              :   /** MD solver interface, required for molecule iterator and molecule mass */
      79              :   coupling::interface::MDSolverInterface<LinkedCell, dim>* const _mdSolverInterface;
      80              :   /** current velocity in this coupling cell (=velocity from continuum
      81              :    * solver) */
      82              :   const tarch::la::Vector<dim, double> _continuumVelocity;
      83              :   /** current avg. velocity of molecules */
      84              :   const tarch::la::Vector<dim, double> _avgMDVelocity;
      85              :   /** average force within this coupling cell */
      86              :   const tarch::la::Vector<dim, double> _avgForce;
      87              : };
      88              : 
      89              : #endif // _MOLECULARDYNAMICS_COUPLING_CELLMAPPINGS_NIEVELOCITYIMPOSITIONMAPPING_H_