CouplingCellService.h

// Copyright (C) 2015 Technische Universitaet Muenchen
// This file is part of the Mamico project. For conditions of distribution
// and use, please see the copyright notice in Mamico's main folder, or at
// www5.in.tum.de/mamico
#ifndef _MOLECULARDYNAMICS_COUPLING_SERVICES_COUPLINGCELLSERVICE_H_
#define _MOLECULARDYNAMICS_COUPLING_SERVICES_COUPLINGCELLSERVICE_H_
 
#pragma once
 
#include "coupling/CouplingCellPlotter.h"
#include "coupling/KineticEnergyController.h"
#include "coupling/MomentumController.h"
#include "coupling/cell-mappings/ComputeMeanPotentialEnergyMapping.h"
#include "coupling/cell-mappings/ComputeMomentumMapping.h"
#include "coupling/cell-mappings/PerturbateVelocityMapping.h"
#include "coupling/configurations/BoundaryForceConfiguration.h"
#include "coupling/configurations/CouplingCellConfiguration.h"
#include "coupling/configurations/MaMiCoConfiguration.h"
#include "coupling/configurations/MomentumInsertionConfiguration.h"
#include "coupling/configurations/ParallelTopologyConfiguration.h"
#include "coupling/configurations/ParticleInsertionConfiguration.h"
#include "coupling/configurations/ThermostatConfiguration.h"
#include "coupling/configurations/TransferStrategyConfiguration.h"
#include "coupling/datastructures/CellContainer.h"
#include "coupling/indexing/IndexingService.h"
#include "coupling/interface/MDSolverInterface.h"
#include "coupling/interface/MacroscopicSolverInterface.h"
#include "coupling/sendrecv/DataExchangeFromMD2Macro.h"
#include "coupling/sendrecv/DataExchangeFromMacro2MD.h"
#include "coupling/sendrecv/DataExchangeFromAllMacro2MD.h"
#include "coupling/sendrecv/FromMD2Macro.h"
#include "coupling/sendrecv/FromMacro2MD.h"
#include "tarch/utils/MultiMDService.h"
 
#include "coupling/filtering/FilterPipeline.h"
 
namespace coupling {
namespace services {
 
template <unsigned int dim> class CouplingCellService;
 
template <class LinkedCell, unsigned int dim> class CouplingCellServiceImpl;
} // namespace services
} // namespace coupling


template <unsigned int dim> class coupling::services::CouplingCellService {
public:
  CouplingCellService(unsigned int ID, unsigned int topologyOffset) : _id(ID), _topologyOffset(topologyOffset) {
#if (COUPLING_MD_DEBUG == COUPLING_MD_YES)
    std::cout << "CouplingCellService::CouplingCellService(): Set ID=" << _id << std::endl;
#endif
  }
  virtual ~CouplingCellService() {}
 
  virtual double applyFilterPipeline() = 0;
  virtual void sendFromMacro2MDPreProcess() = 0;
  virtual void sendFromMacro2MDPostProcess() = 0;
  virtual void sendFromMacro2MD(const coupling::datastructures::FlexibleCellContainer<dim>& macro2MDBuffer) = 0;
  virtual void sendFromMD2MacroPreProcess() = 0;
  virtual void sendFromMD2MacroPostProcess() = 0;
  virtual double sendFromMD2Macro(const coupling::datastructures::FlexibleCellContainer<dim>& couplingCellContainerFromMacroscopicSolver) = 0;
  virtual void processInnerCouplingCellAfterMDTimestep() = 0;
  virtual void computeAndStoreTemperature(double temperature) = 0;
  virtual void applyTemperatureToMolecules(unsigned int t) = 0;
  virtual void distributeMass(unsigned int t) = 0;
  virtual void distributeMomentum(unsigned int t) = 0;
  virtual void applyBoundaryForce(unsigned int t) = 0;
  virtual void perturbateVelocity() = 0;
  virtual void plotEveryMicroscopicTimestep(unsigned int t) = 0;
  virtual void plotEveryMacroscopicTimestep(unsigned int t) = 0;
  virtual void setInnerMomentumImposition(bool enable) = 0;
 
  virtual void initFiltering() {
    throw std::runtime_error("CouplingCellService: Error: Called "
                             "initFiltering for non-Impl object.");
  } /*Note: This is not pure virtual, because some implementations of this
       interface don't have a FilterPipeline. */
  virtual const coupling::filtering::FilterPipeline<I02, dim>* getFilterPipeline() const {
    throw std::runtime_error("CouplingCellService: Error: Called getFilterPipeline() in instance "
                             "without FilterPipeline.");
  } /*Note: This is not pure virtual, because some implementations of this
       interface don't have a FilterPipeline. */
 
  unsigned int getID() const { return _id; }
 
protected:
  const unsigned int _id; 
  unsigned int _topologyOffset;
};

 * MD as well as between the coupling tool and the macroscopic solver.
 *  @author Philipp Neumann
 */
template <class LinkedCell, unsigned int dim> class coupling::services::CouplingCellServiceImpl : public coupling::services::CouplingCellService<dim> {
public:
   * the momentum transfer on MD side transferStrategyConfiguration     -
   * configuration object which determines the respective transfer strategy
   *  parallelTopologyConfiguration     - configuratio object which defines the
   * parallel topology of the simulation (domain decomposition of the MD
   * simulation) numberMDTimestepsPerCouplingCycle - number of MD time steps per
   * coupling cycle couplingCellConfiguration      - configuration object
   * which determines the properties of the coupling cells topologyOffset -
   * offset in linearized topology of ranks topologyGlobalNumberProcesses     -
   * global number of processes available in overall topology
   *
   *  Note: the interface pointers are used by the CouplingCellServiceImpl;
   * they are not deleted at the end of the simulation since other (external)
   * routines may use those as well.
   */
  CouplingCellServiceImpl(
      unsigned int ID, coupling::interface::MDSolverInterface<LinkedCell, dim>* mdSolverInterface,       // interface to MD simulation
      coupling::interface::MacroscopicSolverInterface<dim>* macroscopicSolverInterface,                  // interface to macroscopic solver
      tarch::la::Vector<dim, unsigned int> numberProcesses,                                              // number of processes in all directions
      unsigned int rank,                                                                                 // current rank
      const coupling::configurations::ParticleInsertionConfiguration& particleInsertionConfiguration,    // configuration for particle
                                                                                                         // insertion
      const coupling::configurations::MomentumInsertionConfiguration& momentumInsertionConfiguration,    // configuration for momentum
                                                                                                         // insertion
      const coupling::configurations::BoundaryForceConfiguration<dim>& boundaryForceConfiguration,       // configuration for boundary forces
      const coupling::configurations::TransferStrategyConfiguration<dim>& transferStrategyConfiguration, // configuration for transfer strategy
      const coupling::configurations::ParallelTopologyConfiguration& parallelTopologyConfiguration,      // configuration for parallel topology
      const coupling::configurations::ThermostatConfiguration& thermostatConfiguration,
      unsigned int numberMDTimestepsPerCouplingCycle,                                            // number MD timesteps per coupling
                                                                                                 // cycle (required to initialise
                                                                                                 // transfer strategy)
      const coupling::configurations::CouplingCellConfiguration<dim>& couplingCellConfiguration, // configuration for coupling cells
                                                                                                 // and respective plotting
      const char* filterPipelineConfiguration, const tarch::utils::MultiMDService<dim>& multiMDService, unsigned int topologyOffset, int tws = 0);
 
  CouplingCellServiceImpl(
      unsigned int ID, coupling::interface::MDSolverInterface<LinkedCell, dim>* mdSolverInterface,       // interface to MD simulation
      coupling::interface::MacroscopicSolverInterface<dim>* macroscopicSolverInterface,                  // interface to macroscopic solver
      tarch::la::Vector<dim, unsigned int> numberProcesses,                                              // number of processes in all directions
      unsigned int rank,                                                                                 // current rank
      const coupling::configurations::ParticleInsertionConfiguration& particleInsertionConfiguration,    // configuration for particle
                                                                                                         // insertion
      const coupling::configurations::MomentumInsertionConfiguration& momentumInsertionConfiguration,    // configuration for momentum
                                                                                                         // insertion
      const coupling::configurations::BoundaryForceConfiguration<dim>& boundaryForceConfiguration,       // configuration for boundary forces
      const coupling::configurations::TransferStrategyConfiguration<dim>& transferStrategyConfiguration, // configuration for transfer strategy
      const coupling::configurations::ParallelTopologyConfiguration& parallelTopologyConfiguration,      // configuration for parallel topology
      const coupling::configurations::ThermostatConfiguration& thermostatConfiguration,
      unsigned int numberMDTimestepsPerCouplingCycle,                                            // number MD timesteps per coupling
                                                                                                 // cycle (required to initialise
                                                                                                 // transfer strategy)
      const coupling::configurations::CouplingCellConfiguration<dim>& couplingCellConfiguration, // configuration for coupling cells
                                                                                                 // and respective plotting
      const char* filterPipelineConfiguration, const tarch::utils::MultiMDService<dim>& multiMDService)
      : CouplingCellServiceImpl<LinkedCell, dim>(ID, mdSolverInterface, macroscopicSolverInterface, numberProcesses, rank, particleInsertionConfiguration,
                                                 momentumInsertionConfiguration, boundaryForceConfiguration, transferStrategyConfiguration,
                                                 parallelTopologyConfiguration, thermostatConfiguration, numberMDTimestepsPerCouplingCycle,
                                                 couplingCellConfiguration, filterPipelineConfiguration, multiMDService, 0) {}

  virtual ~CouplingCellServiceImpl();

  void sendFromMacro2MD(const coupling::datastructures::FlexibleCellContainer<dim>& macro2MDBuffer) override;

  double sendFromMD2Macro(const coupling::datastructures::FlexibleCellContainer<dim>& macroscopicSolverCellContainer) override;

  double applyFilterPipeline() override;
 
  void sendFromMacro2MDPreProcess() override;
 
  void sendFromMacro2MDPostProcess() override;
 
  void sendFromMD2MacroPreProcess() override;
 
  void sendFromMD2MacroPostProcess() override {}

  void processInnerCouplingCellAfterMDTimestep() override;

  void computeAndStoreTemperature(double temperature) override;

  /** applies a thermostat in all non-ghost coupling cells. */
  void applyTemperatureToMolecules(unsigned int t) override;

  void applyBoundaryForce(unsigned int t) override;

  void distributeMass(unsigned int t) override;


  void distributeMomentum(unsigned int t) override;

  /** applies a new velocity to each particle according to its cell's mean
   * velocity. */
  void perturbateVelocity() override;

  void plotEveryMicroscopicTimestep(unsigned int t) override;
  void plotEveryMacroscopicTimestep(unsigned int t) override;
  void setInnerMomentumImposition(bool enable) override;

  void initFiltering() override {
    _filterPipeline = new coupling::filtering::FilterPipeline<I02, dim>(_couplingCells, coupling::filtering::Scope::perInstance, _multiMDService,
                                                                        _filterPipelineConfiguration);
  }
 
  const coupling::filtering::FilterPipeline<I02, dim>* getFilterPipeline() const override { return _filterPipeline; }

  /*
   * TODO: MOVE COMMENT
  void addFilterToSequence( const char *sequenceIdentifier,
                                                          const
  std::function<std::vector<double> (std::vector<double> cells_s,
  std::vector<std::array<unsigned int, dim>> indices)>* applyScalar, const
  std::function<std::vector<std::array<double, dim>>
  (std::vector<std::array<double, dim>> cells_v, std::vector<std::array<unsigned
  int, dim>> indices)>* applyVector, int filterIndex = -1
  );*/

  coupling::datastructures::LinkedCellContainer<LinkedCell, dim>& getCouplingCells() { return _couplingCells; }
 
private:
// ------------------- INCLUDE WRAPPER DEFINITIONS
// -------------------------------------
#include "CouplingCellTraversalWrappers.cpph"

  void initIndexVectors4Usher();
 
  tarch::la::Vector<dim, double> getPositionOfFirstLocalGhostCell() const;
 
  std::function<void(Wrapper&)> initCorrectApplicationOfThermostat(const coupling::configurations::ThermostatConfiguration& thermostatConfiguration) {
    if (thermostatConfiguration.getThermostatRegionType() == coupling::configurations::ThermostatConfiguration::ThermostatRegion::all)
      return [this](Wrapper& wrapper) { _couplingCells.applyToLocalNonGhostCouplingCellsWithLinkedCells(wrapper); };
    else if (thermostatConfiguration.getThermostatRegionType() == coupling::configurations::ThermostatConfiguration::ThermostatRegion::outerLayers)
      return [this, &thermostatConfiguration](Wrapper& wrapper) {
        _couplingCells.applyXLayersOfGlobalNonGhostCellsWithLinkedCells(wrapper, thermostatConfiguration.getCells2Use());
      };
    else if (thermostatConfiguration.getThermostatRegionType() == coupling::configurations::ThermostatConfiguration::ThermostatRegion::onlyOutestLayer)
      return [this](Wrapper& wrapper) { _couplingCells.applyToFirstLayerOfGlobalNonGhostCellsWithLinkedCells(wrapper); };
    else
      return [](Wrapper& wrapper) {};
  }

  const unsigned int _numberMDTimestepsPerCouplingCycle;

  coupling::interface::MDSolverInterface<LinkedCell, dim>* _mdSolverInterface;

  coupling::interface::MacroscopicSolverInterface<dim>* _macroscopicSolverInterface;

  coupling::sendrecv::FromMacro2MD<coupling::datastructures::CouplingCell<dim>, dim> _fromMacro2MD;
  coupling::sendrecv::DataExchangeFromMacro2MD<dim> _deFromMacro2MD;
  coupling::sendrecv::DataExchangeFromAllMacro2MD<dim> _deFromAllMacro2MD;
  bool _enableInnerImposition;
  coupling::sendrecv::FromMD2Macro<coupling::datastructures::CouplingCell<dim>, dim> _fromMD2Macro;
  coupling::sendrecv::DataExchangeFromMD2Macro<dim> _deFromMD2Macro;

  coupling::datastructures::LinkedCellContainer<LinkedCell, dim> _couplingCells;

  coupling::filtering::FilterPipeline<I02, dim>* _filterPipeline;

  const char* _filterPipelineConfiguration;
  const tarch::utils::MultiMDService<dim> _multiMDService;

  coupling::MomentumInsertion<LinkedCell, dim>* _momentumInsertion;
  coupling::configurations::MomentumInsertionConfiguration::MomentumInsertionType _momentumInsertionType;
  coupling::ParticleInsertion<LinkedCell, dim>* _particleInsertion;
  const tarch::la::Vector<dim, unsigned int> _numberLinkedCellsPerCouplingCell;
  const coupling::configurations::ParticleInsertionConfiguration::ParticleInsertionType _particleInsertionType;
  coupling::transferstrategies::TransferStrategy<LinkedCell, dim>* _transferStrategy;

  coupling::KineticEnergyController<LinkedCell, dim> _kineticEnergyController;
  coupling::BoundaryForceController<LinkedCell, dim>* _boundaryForceController;
  coupling::MomentumController<LinkedCell, dim> _momentumController;
 
  std::function<void(Wrapper&)> _applyAccordingToConfiguration;

  const std::string _microscopicFilename;
  const unsigned int _writeEveryMicroscopicTimestep;
  const std::string _macroscopicFilename;
  const unsigned int _writeEveryMacroscopicTimestep;

  // start and end coordinate for block loop over coupling cells (with 3
  // entries always!)
  tarch::la::Vector<3, unsigned int> _usherCellStart[1 << dim];
  tarch::la::Vector<3, unsigned int> _usherCellEnd[1 << dim];
  tarch::la::Vector<dim, unsigned int> _usherRange[1 << dim];
  // offset in red-black loops nested within the block loops (always 0 or 1
  // entries)
  tarch::la::Vector<3, unsigned int> _usherCellOffset[1 << dim];
};
#include "CouplingCellService.cpph"
 
#endif // _MOLECULARDYNAMICS_COUPLING_SERVICES_COUPLINGCELLSERVICE_H_