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_DATA_STRUCTURES_COUPLINGCELL_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_DATA_STRUCTURES_COUPLINGCELL_H_
       7             : 
       8             : #include "tarch/la/Vector.h"
       9             : #include <cstdlib>
      10             : #include <fstream>
      11             : #include <iostream>
      12             : #include <string>
      13             : 
      14             : namespace coupling {
      15             : namespace datastructures {
      16             : 
      17             : template <unsigned int dim> class CouplingCell;
      18             : } // namespace datastructures
      19             : } // namespace coupling
      20             : 
      21             : /** describes a quadratic/ cubic coupling cell filled with fluid (no linked
      22             :  *cells). Base class for the class
      23             :  *coupling::datastructures::CouplingCellWithLinkedCells
      24             :  *      @brief defines the cell type with cell-averaged quantities only (no
      25             :  *linked cells).
      26             :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      27             :  *  @author Philipp Neumann
      28             :  */
      29             : template <unsigned int dim> class coupling::datastructures::CouplingCell {
      30             : public:
      31             :   /** Constructor: initialises the coupling cell with zero values.
      32             :    */
      33       56072 :   CouplingCell()
      34       56072 :       : _microscopicMass(0.0), _microscopicMomentum(0.0), _macroscopicMass(0.0), _macroscopicMomentum(0.0), _potentialEnergy(0.0), _temperature(0.0),
      35      112144 :         _currentVelocity(0.0) {}
      36             : 
      37             :   /** Destructor */
      38       55960 :   virtual ~CouplingCell() {}
      39             : 
      40             :   /** sets the microscopic mass
      41             :    * @param mass Mass*/
      42           0 :   void setMicroscopicMass(const double& mass) { _microscopicMass = mass; }
      43             :   /** returns the microscopic mass
      44             :    * @returns _microscopicMass Mass*/
      45           0 :   const double& getMicroscopicMass() const { return _microscopicMass; }
      46             :   /** sets the microscopic moments
      47             :    * @param momentum Momentum*/
      48           0 :   void setMicroscopicMomentum(const tarch::la::Vector<dim, double>& momentum) { _microscopicMomentum = momentum; }
      49             :   /** returns the microscopic moments
      50             :    * @returns _microscopicMomentum Momentum*/
      51           0 :   const tarch::la::Vector<dim, double>& getMicroscopicMomentum() const { return _microscopicMomentum; }
      52             : 
      53             :   /** sets the microscopic mass
      54             :    * @param mass Mass*/
      55       36364 :   void setMacroscopicMass(const double& mass) { _macroscopicMass = mass; }
      56             :   /** returns the microscopic mass
      57             :    * @returns _microscopicMass Mass*/
      58           0 :   const double& getMacroscopicMass() const { return _macroscopicMass; }
      59             :   /** sets the microscopic moments
      60             :    * @param momentum Momentum*/
      61           0 :   void setMacroscopicMomentum(const tarch::la::Vector<dim, double>& momentum) { _macroscopicMomentum = momentum; }
      62             :   /** returns the microscopic moments
      63             :    * @returns _microscopicMomentum Momentum*/
      64           0 :   const tarch::la::Vector<dim, double>& getMacroscopicMomentum() const { return _macroscopicMomentum; }
      65             : 
      66             :   /** returns the mean potential energy over the coupling cell
      67             :    * @returns _potentialEnergy potential energy*/
      68           0 :   const double& getPotentialEnergy() const { return _potentialEnergy; }
      69             :   /** sets the mean potential energy over the coupling cell
      70             :    * @param potentialEnergy potential energy*/
      71           0 :   void setPotentialEnergy(const double& potentialEnergy) { _potentialEnergy = potentialEnergy; }
      72             : 
      73             :   /** adds a certain amount to the microscopic mass
      74             :    * @param mass Mass to be added to the microscopic mass*/
      75           0 :   void addMicroscopicMass(const double& mass) { _microscopicMass += mass; }
      76             :   /** adds a certain amount to the microscopic moments
      77             :    * @param momentum Momentum to be added to the microscopic moments*/
      78             :   void addMicroscopicMomentum(const tarch::la::Vector<dim, double>& momentum) { _microscopicMomentum += momentum; }
      79             : 
      80             :   /** adds a certain amount to the macroscopic mass
      81             :    * @param mass Mass to be added to the macroscopic mass*/
      82           0 :   void addMacroscopicMass(const double& mass) { _macroscopicMass += mass; }
      83             :   /** adds a certain amount to the macroscopic moments
      84             :    * @param momentum Momentum to be added to the macroscopic moments*/
      85           0 :   void addMacroscopicMomentum(const tarch::la::Vector<dim, double>& momentum) { _macroscopicMomentum += momentum; }
      86             : 
      87             :   /** sets current velocity (sampled right before any distributeX(...) call)
      88             :    * @param velocity velocity*/
      89           0 :   void setCurrentVelocity(const tarch::la::Vector<dim, double>& velocity) { _currentVelocity = velocity; }
      90             :   /** returns current velocity (sampled right before any distributeX(...) call)
      91             :    * @return _currentVelocity velocity*/
      92           0 :   const tarch::la::Vector<dim, double>& getCurrentVelocity() const { return _currentVelocity; }
      93             : 
      94             :   /** sets the temperature
      95             :    * @param temperature temperature*/
      96           0 :   void setTemperature(const double& temperature) { _temperature = temperature; }
      97             :   /** returns the temperature
      98             :    * @return _temperature temperature*/
      99           0 :   const double& getTemperature() const { return _temperature; }
     100             : 
     101             :   /** buffers for macroscopic mass that need to be transferred
     102             :    *  from the macroscopic to the microscopic simulation */
     103             :   double _microscopicMass;
     104             :   /** buffers for macroscopic quantities of momentum that need to be transferred
     105             :    *  from the macroscopic to the microscopic simulation */
     106             :   tarch::la::Vector<dim, double> _microscopicMomentum;
     107             : 
     108             :   /** buffers for macroscopic mass that need to be returned
     109             :    *  from the microscopic to the macroscopic simulation */
     110             :   double _macroscopicMass;
     111             :   /** buffers for macroscopic quantities of momentum that need to be returned
     112             :    *  from the microscopic to the macroscopic simulation */
     113             :   tarch::la::Vector<dim, double> _macroscopicMomentum;
     114             : 
     115             :   /** holds the mean potential energy within the coupling cell. This value is
     116             :    * needed as a reference potential energy value for the USHER scheme.
     117             :    */
     118             :   double _potentialEnergy;
     119             : 
     120             :   /** temperature within this cell. Needed for the thermostat. */
     121             :   double _temperature;
     122             : 
     123             :   /** buffer for current mean velocity in the cell. */
     124             :   tarch::la::Vector<dim, double> _currentVelocity;
     125             : };
     126             : 
     127             : #endif // _MOLECULARDYNAMICS_COUPLING_DATA_STRUCTURES_COUPLINGCELL_H_