InstanceHandling.h

// Copyright (C) 2016 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 _INSTANCE_HANDLING_H_
#define _INSTANCE_HANDLING_H_
 
#include "coupling/interface/MDSimulationFactory.h"
#include "coupling/services/MultiMDCellService.h"
#include "tarch/utils/MultiMDService.h"
 
namespace coupling {
template <class LinkedCell, unsigned int dim> class InstanceHandling;
}
class InstanceHandlingTest;

template <class LinkedCell, unsigned int dim> class coupling::InstanceHandling {
 
public:
  InstanceHandling(simplemd::configurations::MolecularDynamicsConfiguration& mdConfig, coupling::configurations::MaMiCoConfiguration<dim>& mamicoConfig,
                   tarch::utils::MultiMDService<dim>& multiMDService)
      : _mdSimulations(), _mdSolverInterface(), _mdConfig(mdConfig), _mamicoConfig(mamicoConfig), _multiMDService(multiMDService) {
    for (unsigned int i = 0; i < multiMDService.getLocalNumberOfMDSimulations(); i++) {
      _mdSimulations.push_back(coupling::interface::SimulationAndInterfaceFactory::getInstance().getMDSimulation(_mdConfig, _mamicoConfig
#if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
                                                                                                                 ,
                                                                                                                 _multiMDService.getLocalCommunicator()
#endif
                                                                                                                     ));
 
      if (_mdSimulations[i] == nullptr) {
        std::cout << "ERROR InstanceHandling : _mdSimulations [" << i << "] == NULL!" << std::endl;
        std::exit(EXIT_FAILURE);
      }
 
      _mdSimulations[i]->init(_multiMDService, _multiMDService.getGlobalNumberOfLocalMDSimulation(i));
    }
  }

  ~InstanceHandling() { shutdown(); }

  void equilibrate(const unsigned int& t, const unsigned int& T) {
    for (auto& md : _mdSimulations) {
      md->switchOffCoupling();
      md->simulateTimesteps(t, T);
    }
  }

  auto& getSimpleMD() const { return _mdSimulations; }

  void setMDSolverInterface() {
 
    for (unsigned int i = 0; i < _mdSimulations.size(); ++i) {
      _mdSolverInterface.push_back(
          coupling::interface::SimulationAndInterfaceFactory::getInstance().getMDSolverInterface(_mdConfig, _mamicoConfig, _mdSimulations[i]));
      if (_mdSolverInterface[i] == NULL) {
        std::cout << "ERROR InstanceHandling: mdSolverInterface[" << i << "] == NULL!" << std::endl;
        exit(EXIT_FAILURE);
      }
    }
  }

  auto& getMDSolverInterface() const { return _mdSolverInterface; }

  void switchOnCoupling() {
    for (auto& simpleMD : _mdSimulations) {
      simpleMD->switchOnCoupling();
    }
  }

  void switchOnCoupling(const unsigned int& i) { _mdSimulations[i]->switchOnCoupling(); }

  void switchOffCoupling() {
    for (auto& simpleMD : _mdSimulations) {
      simpleMD->switchOffCoupling();
    }
  }

  void switchOffCoupling(const unsigned int& i) { _mdSimulations[i]->switchOffCoupling(); }

  void simulateTimesteps(const unsigned int& t, unsigned int& T) {
    for (auto& simpleMD : _mdSimulations) {
      simpleMD->simulateTimesteps(t, T);
    }
  }

  void writeCheckpoint(const std::string& filestem, const unsigned int& T) const {
    if (_mdSimulations.size() > 0 && _mdSimulations[0] != nullptr) {
      _mdSimulations[0]->writeCheckpoint(filestem, T);
    }
  }

  void simulateTimesteps(const unsigned int& t, unsigned int& T, coupling::services::MultiMDCellService<LinkedCell, dim>& multiMDCellService) {
    for (unsigned int i = 0; i < _mdSimulations.size(); ++i) {
      coupling::interface::MamicoInterfaceProvider<LinkedCell, dim>::getInstance().setCouplingCellService(&multiMDCellService.getCouplingCellService(i));
      coupling::interface::MamicoInterfaceProvider<LinkedCell, dim>::getInstance().setMDSolverInterface(_mdSolverInterface[i]);
 
      if (_mdSimulations[i] != nullptr) {
        _mdSimulations[i]->simulateTimesteps(t, T);
      }
    }
  }

  void simulateTimesteps(const unsigned int& t, unsigned int& T, const unsigned int& i) { _mdSimulations[i]->simulateTimesteps(t, T); }

  void addSimulationBlock() {
    _mdSimulations.push_back(nullptr);
    _mdSolverInterface.push_back(nullptr);
  }

  void rmSimulationBlock() {
    _mdSimulations.pop_back();
    _mdSolverInterface.pop_back();
  }

  coupling::interface::MDSolverInterface<LinkedCell, dim>* addMDSimulation(unsigned int slot, unsigned int localIndex) {
    auto* mdSim = coupling::interface::SimulationAndInterfaceFactory::getInstance().getMDSimulation(_mdConfig, _mamicoConfig
#if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
                                                                                                    ,
                                                                                                    _multiMDService.getLocalCommunicator()
#endif
    );
    if (mdSim == NULL) {
      std::cout << "ERROR! coupling::InstanceHandling::addMDSimulation(): "
                   "mdSim == NULL!"
                << std::endl;
      std::exit(EXIT_FAILURE);
    }
    // NB: ls1 coupling will break if getMDSolverInterface does not happen immediately after init()
    // since the solver interface relies on the global simulation instance set by ls1 in init()
 
    mdSim->init(_multiMDService, slot);
 
    _mdSimulations[localIndex] = mdSim;
 
    _mdSolverInterface[localIndex] =
        coupling::interface::SimulationAndInterfaceFactory::getInstance().getMDSolverInterface(_mdConfig, _mamicoConfig, _mdSimulations[localIndex]);
 
    return _mdSolverInterface[localIndex];
  }

  void rmMDSimulation(const unsigned int& index) {
    if (_mdSimulations[index] != nullptr) {
      _mdSimulations[index]->shutdown();
      delete _mdSimulations[index];
      _mdSimulations[index] = nullptr;
    } else {
      std::cout << "WARNING coupling::InstanceHandling::rmMDSimulation() : "
                   "_mdSimulations at index "
                << index << " == null!" << std::endl;
    }
    //_mdSimulations.erase(_mdSimulations.begin()+index);
 
    if (_mdSolverInterface[index] != nullptr) {
      delete _mdSolverInterface[index];
      _mdSolverInterface[index] = nullptr;
    } else {
      std::cout << "WARNING coupling::InstanceHandling::rmMDSimulation() : "
                   "_mdSolverInterface at index "
                << index << " == null!" << std::endl;
    }
    //_mdSolverInterface.erase(_mdSolverInterface.begin()+index);
  }

  void setCouplingCellServices(coupling::services::MultiMDCellService<LinkedCell, dim>& multiMDCellService) {
    for (unsigned int i = 0; i < _mdSimulations.size(); ++i) {
      _mdSimulations[i]->setCouplingCellService(&(multiMDCellService.getCouplingCellService(i)));
    }
  }
 
private:
  void shutdown() {
    for (unsigned int i = 0; i < _mdSimulations.size(); ++i) {
      coupling::interface::MamicoInterfaceProvider<LinkedCell, dim>::getInstance().setMDSolverInterface(_mdSolverInterface[i]);
      if (_mdSimulations[i] != nullptr) {
        _mdSimulations[i]->shutdown();
        delete _mdSimulations[i];
        _mdSimulations[i] = nullptr;
      }
      _mdSolverInterface[i] = coupling::interface::MamicoInterfaceProvider<LinkedCell, dim>::getInstance().getMDSolverInterface();
    }
    _mdSimulations.clear();
    for (auto& solverInterface : _mdSolverInterface) {
      if (solverInterface != nullptr) {
        delete solverInterface;
        solverInterface = nullptr;
      }
    }
    _mdSolverInterface.clear();
  }
 
  std::vector<coupling::interface::MDSimulation*> _mdSimulations;
  std::vector<coupling::interface::MDSolverInterface<LinkedCell, dim>*> _mdSolverInterface;
 
  simplemd::configurations::MolecularDynamicsConfiguration& _mdConfig;
  coupling::configurations::MaMiCoConfiguration<dim>& _mamicoConfig;
 
  const tarch::utils::MultiMDService<dim>& _multiMDService;
  friend InstanceHandlingTest;
};
 
#endif //_INSTANCE_HANDLING_H_