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_TRANSFERSTRATEGIES_DIFFERENCETRANSFERSTRATEGY_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_TRANSFERSTRATEGIES_DIFFERENCETRANSFERSTRATEGY_H_
       7             : 
       8             : #include "coupling/cell-mappings/ComputeMassMapping.h"
       9             : #include "coupling/cell-mappings/ComputeMomentumMapping.h"
      10             : #include "coupling/transferstrategies/TransferStrategy.h"
      11             : #include "tarch/la/Vector.h"
      12             : 
      13             : namespace coupling {
      14             : namespace transferstrategies {
      15             : template <class LinkedCell, unsigned int dim> class DifferenceTransferStrategy;
      16             : }
      17             : } // namespace coupling
      18             : 
      19             : /** from MD to macroscopic solver: mass and momentum are computed at the current
      20             :  * timestep and mapped to macroscopic solver. The values are averaged over a
      21             :  * certain time. from macroscopic solver to MD: The difference in mass and
      22             :  * momentum between both solvers is computed and introduced on MD side.
      23             :  *  @author Philipp Neumann
      24             :  *  @tparam LinkedCell the LinkedCell class is given by the implementation of
      25             :  * linked cells in the molecular dynamics simulation
      26             :  *  @tparam dim  refers to the spacial dimension of the simulation, can be 1, 2,
      27             :  * or 3*/
      28             : template <class LinkedCell, unsigned int dim>
      29             : class coupling::transferstrategies::DifferenceTransferStrategy : public coupling::transferstrategies::TransferStrategy<LinkedCell, dim> {
      30             : public:
      31             :   /** @brief a simple constructor
      32             :    *  @param mdSolverInterface interface for the md solver
      33             :    *  @param numberMDSteps number of md steps within one coupling time step */
      34           0 :   DifferenceTransferStrategy(coupling::interface::MDSolverInterface<LinkedCell, dim>* const mdSolverInterface, unsigned int numberMDsteps)
      35           0 :       : coupling::transferstrategies::TransferStrategy<LinkedCell, dim>(mdSolverInterface), _numberMDsteps(numberMDsteps), _zero(0.0),
      36           0 :         _massMapping(mdSolverInterface), _momentumMapping(mdSolverInterface) {}
      37             : 
      38             :   /** @brief a dummy destructor */
      39           0 :   virtual ~DifferenceTransferStrategy() {}
      40             : 
      41             :   /** @brief
      42             :    *  @param cell coupling cell to process
      43             :    *  @param index index of the coupling cell */
      44           0 :   void processInnerCouplingCellBeforeReceivingMacroscopicSolverData(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell,
      45             :                                                                     I02 index) override {
      46             :     // reset quantities
      47           0 :     cell.setMicroscopicMass(0.0);
      48           0 :     cell.setMicroscopicMomentum(_zero);
      49           0 :   }
      50             : 
      51             :   /** @brief the microscopicMass and -Momentum are reseted to zero
      52             :    *  @param cell coupling cell to process
      53             :    *  @param index index of the coupling cell */
      54           0 :   void processOuterCouplingCellBeforeReceivingMacroscopicSolverData(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell,
      55             :                                                                     I02 index) override {
      56             :     // reset quantities
      57           0 :     cell.setMicroscopicMass(0.0);
      58           0 :     cell.setMicroscopicMomentum(_zero);
      59           0 :   }
      60             : 
      61             :   /** @brief difference between microscopic and macroscopic values is evaluated
      62             :    * and stored in the macroscopic quantity
      63             :    *  @param cell coupling cell to process
      64             :    *  @param index index of the coupling cell */
      65           0 :   void processInnerCouplingCellAfterReceivingMacroscopicSolverData(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell,
      66             :                                                                    I02 index) override {
      67             :     // compute difference between macroscopic and microscopic mass and momentum
      68             :     // values; this value is set in the microscopic data buffer of the
      69             :     // coupling cell.
      70           0 :     const double diffMass = cell.getMicroscopicMass() - cell.getMacroscopicMass();
      71           0 :     const tarch::la::Vector<dim, double> diffMomentum = cell.getMicroscopicMomentum() - cell.getMacroscopicMomentum();
      72           0 :     cell.setMicroscopicMass(diffMass);
      73           0 :     cell.setMicroscopicMomentum(diffMomentum);
      74             :     // reset coupling cell buffers
      75           0 :     cell.setMacroscopicMass(0.0);
      76           0 :     cell.setMacroscopicMomentum(_zero);
      77           0 :   }
      78             : 
      79             :   /** @brief the quantities (mass & momentum) are averaged (divided by the
      80             :    * amount of md time steps)
      81             :    *  @param cell coupling cell to process
      82             :    *  @param index index of the coupling cell */
      83           0 :   void processInnerCouplingCellBeforeSendingMDSolverData(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, I02 index) override {
      84             :     // average quantities
      85           0 :     const double mass = cell.getMacroscopicMass() / ((double)_numberMDsteps);
      86           0 :     const tarch::la::Vector<dim, double> momentum = cell.getMacroscopicMomentum() * (1.0 / ((double)_numberMDsteps));
      87           0 :     cell.setMacroscopicMass(mass);
      88           0 :     cell.setMacroscopicMomentum(momentum);
      89           0 :   }
      90             : 
      91             :   /** @brief compute current mass and momentum and add it to averaged buffer
      92             :    * value
      93             :    *  @param cell coupling cell to process
      94             :    *  @param index index of the coupling cell */
      95           0 :   void processInnerCouplingCellAfterMDTimestep(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, I02 index) override {
      96           0 :     cell.iterateConstCells(_massMapping);
      97           0 :     const double mass = _massMapping.getMass();
      98           0 :     cell.iterateConstCells(_momentumMapping);
      99           0 :     const tarch::la::Vector<dim, double> momentum = _momentumMapping.getMomentum();
     100           0 :     cell.addMacroscopicMass(mass);
     101           0 :     cell.addMacroscopicMomentum(momentum);
     102           0 :   }
     103             : 
     104             : private:
     105             :   /** number of md time steps within one coupling time step  */
     106             :   const unsigned int _numberMDsteps;
     107             :   /** vector containing zeros, the dimension is the spacial dimension of the
     108             :    * simulation */
     109             :   const tarch::la::Vector<dim, double> _zero;
     110             :   /** class to compute the mass within every single cell */
     111             :   coupling::cellmappings::ComputeMassMapping<LinkedCell, dim> _massMapping;
     112             :   /** class to compute the momentum within every single cell */
     113             :   coupling::cellmappings::ComputeMomentumMapping<LinkedCell, dim> _momentumMapping;
     114             : };
     115             : #endif // _MOLECULARDYNAMICS_COUPLING_TRANSFERSTRATEGIES_DIFFERENCETRANSFERSTRATEGY_H_