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_COUPLINGCELLTRAVERSALWRAPPERS_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_COUPLINGCELLTRAVERSALWRAPPERS_H_
       7             : 
       8             : /** the following wrappers and smaller functional classes are included in the
       9             :  * CouplingCellServiceImpl for internal use in this class only. They are used
      10             :  * together with the applyTo...() methods of CellContainer to bring
      11             :  *  functionality which is defined cellwise onto the grid of coupling cells.
      12             :  *  @author Philipp Neumann
      13             :  */
      14             : 
      15             : /** wrapper to carry out functionality on a single coupling cell. This
      16             :  * function can be called on several coupling cells using the callback
      17             :  * patterns of CellContainer. In the following, several wrappers are provided
      18             :  * for the TransferStrategy as well as some further functional stuff which is
      19             :  * required from the CouplingCellServiceImpl.
      20             :  */
      21             : class Wrapper {
      22             : public:
      23           0 :   Wrapper(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : _thisPtr(thisPtr) {}
      24           0 :   virtual ~Wrapper() {}
      25             :   virtual void beginCellIteration() = 0;
      26             :   virtual void endCellIteration() = 0;
      27             :   virtual void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) = 0;
      28             : 
      29             : protected:
      30             :   coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* _thisPtr;
      31             : };
      32             : 
      33             : /** wrapper for method
      34             :  * processInnerCouplingCellBeforeReceivingMacroscopicSolverData of
      35             :  * TransferStrategy */
      36           0 : class Wrapper4ProcessInnerCouplingCellBeforeReceivingMacroscopicSolverData : public Wrapper {
      37             : public:
      38           0 :   Wrapper4ProcessInnerCouplingCellBeforeReceivingMacroscopicSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr)
      39           0 :       : Wrapper(thisPtr) {}
      40             : 
      41           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessInnerCouplingCellsBeforeReceivingMacroscopicSolverData(); }
      42           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessInnerCouplingCellsBeforeReceivingMacroscopicSolverData(); }
      43           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
      44           0 :     Wrapper::_thisPtr->_transferStrategy->processInnerCouplingCellBeforeReceivingMacroscopicSolverData(cell, index);
      45           0 :   }
      46             : };
      47             : 
      48             : /** wrapper for method
      49             :  * processOuterCouplingCellBeforeReceivingMacroscopicSolverData of
      50             :  * TransferStrategy */
      51           0 : class Wrapper4ProcessOuterCouplingCellBeforeReceivingMacroscopicSolverData : public Wrapper {
      52             : public:
      53           0 :   Wrapper4ProcessOuterCouplingCellBeforeReceivingMacroscopicSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr)
      54           0 :       : Wrapper(thisPtr) {}
      55             : 
      56           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessOuterCouplingCellsBeforeReceivingMacroscopicSolverData(); }
      57           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessOuterCouplingCellsBeforeReceivingMacroscopicSolverData(); }
      58             : 
      59           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
      60           0 :     Wrapper::_thisPtr->_transferStrategy->processOuterCouplingCellBeforeReceivingMacroscopicSolverData(cell, index);
      61           0 :   }
      62             : };
      63             : 
      64             : /** wrapper for method
      65             :  * processInnerCouplingCellAfterReceivingMacroscopicSolverData of
      66             :  * TransferStrategy */
      67           0 : class Wrapper4ProcessInnerCouplingCellAfterReceivingMacroscopicSolverData : public Wrapper {
      68             : public:
      69           0 :   Wrapper4ProcessInnerCouplingCellAfterReceivingMacroscopicSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr)
      70           0 :       : Wrapper(thisPtr) {}
      71             : 
      72           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessInnerCouplingCellsAfterReceivingMacroscopicSolverData(); }
      73           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessInnerCouplingCellsAfterReceivingMacroscopicSolverData(); }
      74           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
      75           0 :     Wrapper::_thisPtr->_transferStrategy->processInnerCouplingCellAfterReceivingMacroscopicSolverData(cell, index);
      76           0 :   }
      77             : };
      78             : 
      79             : /** wrapper for method
      80             :  * processOuterCouplingCellAfterReceivingMacroscopicSolverData of
      81             :  * TransferStrategy */
      82           0 : class Wrapper4ProcessOuterCouplingCellAfterReceivingMacroscopicSolverData : public Wrapper {
      83             : public:
      84           0 :   Wrapper4ProcessOuterCouplingCellAfterReceivingMacroscopicSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr)
      85           0 :       : Wrapper(thisPtr) {}
      86             : 
      87           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessOuterCouplingCellsAfterReceivingMacroscopicSolverData(); }
      88           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessOuterCouplingCellsAfterReceivingMacroscopicSolverData(); }
      89           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
      90           0 :     Wrapper::_thisPtr->_transferStrategy->processOuterCouplingCellAfterReceivingMacroscopicSolverData(cell, index);
      91           0 :   }
      92             : };
      93             : 
      94             : /** wrapper for method processInnerCouplingCellBeforeSendingMDSolverData of
      95             :  * TransferStrategy */
      96           0 : class Wrapper4ProcessInnerCouplingCellBeforeSendingMDSolverData : public Wrapper {
      97             : public:
      98           0 :   Wrapper4ProcessInnerCouplingCellBeforeSendingMDSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
      99             : 
     100           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessInnerCouplingCellsBeforeSendingMDSolverData(); }
     101           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessInnerCouplingCellsBeforeSendingMDSolverData(); }
     102           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     103           0 :     Wrapper::_thisPtr->_transferStrategy->processInnerCouplingCellBeforeSendingMDSolverData(cell, index);
     104           0 :   }
     105             : };
     106             : 
     107             : /** wrapper for method processOuterCouplingCellBeforeSendingMDSolverData of
     108             :  * TransferStrategy */
     109           0 : class Wrapper4ProcessOuterCouplingCellBeforeSendingMDSolverData : public Wrapper {
     110             : public:
     111           0 :   Wrapper4ProcessOuterCouplingCellBeforeSendingMDSolverData(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     112             : 
     113           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessOuterCouplingCellsBeforeSendingMDSolverData(); }
     114           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessOuterCouplingCellsBeforeSendingMDSolverData(); }
     115           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     116           0 :     Wrapper::_thisPtr->_transferStrategy->processOuterCouplingCellBeforeSendingMDSolverData(cell, index);
     117           0 :   }
     118             : };
     119             : 
     120             : /** wrapper for method processInnerCouplingCellAfterMDTimestep of
     121             :  * TransferStrategy */
     122           0 : class Wrapper4ProcessInnerCouplingCellAfterMDTimestep : public Wrapper {
     123             : public:
     124           0 :   Wrapper4ProcessInnerCouplingCellAfterMDTimestep(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     125             : 
     126           0 :   void beginCellIteration() override { Wrapper::_thisPtr->_transferStrategy->beginProcessInnerCouplingCellsAfterMDTimestep(); }
     127           0 :   void endCellIteration() override { Wrapper::_thisPtr->_transferStrategy->endProcessInnerCouplingCellsAfterMDTimestep(); }
     128           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     129           0 :     Wrapper::_thisPtr->_transferStrategy->processInnerCouplingCellAfterMDTimestep(cell, index);
     130           0 :   }
     131             : };
     132             : 
     133             : /** computes and stores the current velocity in each non-ghost coupling cell.
     134             :  */
     135           0 : class Wrapper4ComputeAndSetCurrentVelocity : public Wrapper {
     136             : public:
     137           0 :   Wrapper4ComputeAndSetCurrentVelocity(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     138             : 
     139           0 :   void beginCellIteration() override {}
     140           0 :   void endCellIteration() override {}
     141           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     142           0 :     coupling::cellmappings::ComputeMomentumMapping<LinkedCell, dim> computeMomentumMapping(Wrapper::_thisPtr->_mdSolverInterface);
     143           0 :     cell.iterateConstCells(computeMomentumMapping);
     144           0 :     const tarch::la::Vector<dim, double> velocity = computeMomentumMapping.getMeanVelocity();
     145           0 :     cell.setCurrentVelocity(velocity);
     146           0 :   }
     147             : };
     148             : 
     149             : /** calls the MomentumInsertion-mechanisms on each non-ghost coupling cell,
     150             :  * including the energy controller */
     151           0 : class Wrapper4DistributeMomentum : public Wrapper {
     152             : public:
     153           0 :   Wrapper4DistributeMomentum(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr, unsigned int t) : Wrapper(thisPtr) {}
     154             : 
     155           0 :   void beginCellIteration() override {}
     156           0 :   void endCellIteration() override {}
     157           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     158           0 :     const double temperature = Wrapper::_thisPtr->_kineticEnergyController.computeTemperature(cell);
     159           0 :     Wrapper::_thisPtr->_momentumInsertion->insertMomentum(cell, index);
     160           0 :     Wrapper::_thisPtr->_kineticEnergyController.setTemperature(cell, temperature);
     161           0 :   }
     162             : };
     163             : 
     164             : /** computes and stores the temperature value in all non-ghost cells. If the
     165             :  * temperature parameter is set to -1.0, the current temperature of the
     166             :  * molecules in this cell is stored. Otherwise, the temperature variable is used
     167             :  * and applied to the molecules using the thermostat of the
     168             :  * KineticEnergyController.
     169             :  */
     170           0 : class Wrapper4ComputeAndStoreTemperature : public Wrapper {
     171             : public:
     172           0 :   Wrapper4ComputeAndStoreTemperature(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr, double temperature)
     173           0 :       : Wrapper(thisPtr), _temperature(temperature) {}
     174             : 
     175           0 :   void beginCellIteration() override {}
     176           0 :   void endCellIteration() override {}
     177           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     178             :     // if this value is -1.0, we just set the temperature in the cell according
     179             :     // to current temperature...
     180           0 :     if (_temperature == -1.0) {
     181           0 :       const double myTemperature = Wrapper::_thisPtr->_kineticEnergyController.computeTemperature(cell);
     182           0 :       cell.setTemperature(myTemperature);
     183             :       // otherwise we use the temperature value of _setTemperature
     184             :     } else {
     185           0 :       cell.setTemperature(_temperature);
     186           0 :       Wrapper::_thisPtr->_kineticEnergyController.setTemperature(cell, _temperature);
     187             :     }
     188           0 :   }
     189             : 
     190             : private:
     191             :   const double _temperature;
     192             : };
     193             : 
     194           0 : class Wrapper4PerturbateVelocity : public Wrapper {
     195             : public:
     196           0 :   Wrapper4PerturbateVelocity(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     197             : 
     198           0 :   void beginCellIteration() override {}
     199           0 :   void endCellIteration() override {}
     200           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     201           0 :     coupling::cellmappings::ComputeMomentumMapping<LinkedCell, dim> computeMomentumMapping(Wrapper::_thisPtr->_mdSolverInterface);
     202           0 :     cell.iterateConstCells(computeMomentumMapping);
     203             : 
     204           0 :     coupling::cellmappings::ComputeTemperatureMapping<LinkedCell, dim> computeTemperatureMapping(computeMomentumMapping.getMeanVelocity(),
     205           0 :                                                                                                  Wrapper::_thisPtr->_mdSolverInterface);
     206           0 :     cell.iterateConstCells(computeTemperatureMapping);
     207             : 
     208           0 :     coupling::cellmappings::PerturbateVelocityMapping<LinkedCell, dim> perturbateVelocity(
     209           0 :         Wrapper::_thisPtr->_mdSolverInterface, computeMomentumMapping.getMeanVelocity(), computeTemperatureMapping.getTemperature());
     210             : 
     211           0 :     cell.iterateCells(perturbateVelocity);
     212           0 :   }
     213             : };
     214             : 
     215             : /** applies the thermostat in all non-ghost cells */
     216           0 : class Wrapper4ApplyTemperature : public Wrapper {
     217             : public:
     218           0 :   Wrapper4ApplyTemperature(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     219             : 
     220           0 :   void beginCellIteration() override {}
     221           0 :   void endCellIteration() override {}
     222           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     223           0 :     const double temperature = cell.getTemperature();
     224           0 :     Wrapper::_thisPtr->_kineticEnergyController.setTemperature(cell, temperature);
     225           0 :   }
     226             : };
     227             : 
     228             : /** applies the boundary force in all non-ghost cells which are close to an open
     229             :  * boundary */
     230           0 : class Wrapper4ApplyBoundaryForce : public Wrapper {
     231             : public:
     232           0 :   Wrapper4ApplyBoundaryForce(coupling::services::CouplingCellServiceImpl<LinkedCell, dim>* thisPtr) : Wrapper(thisPtr) {}
     233             : 
     234           0 :   void beginCellIteration() override {}
     235           0 :   void endCellIteration() override {}
     236           0 :   void apply(coupling::datastructures::CouplingCellWithLinkedCells<LinkedCell, dim>& cell, const I02& index) override {
     237           0 :     Wrapper::_thisPtr->_boundaryForceController->applyBoundaryForce(cell);
     238           0 :   }
     239             : };
     240             : #endif // _MOLECULARDYNAMICS_COUPLING_COUPLINGCELLTRAVERSALWRAPPERS_H_