MDIEngine.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (c) 2017-2025 The Regents of the University of Michigan and DFT-FE
// authors.
//
// This file is part of the DFT-FE code.
//
// The DFT-FE code is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the DFT-FE distribution.
//
// ---------------------------------------------------------------------
//
 
#if defined(DFTFE_WITH_MDI)
#  ifndef dftfeMDIEngine_H_
#    define dftfeMDIEngine_H_
#    include "dftfeWrapper.h"
#    include <mdi.h>
#    include <mpi.h>
#    include <string>
#    include <vector>
 
namespace dftfe
{
  /**
   * @brief MDIEngine interface class for dftfe
   *
   * @author Sambit Das
   */
  class MDIEngine
  {
  public:
    /**
     * @brief constructor
     */
    MDIEngine(MPI_Comm &dftfeMPIComm, dftfe::Int argc, char *argv[]);
 
    dftfe::Int
    execute_command(const char *command, MDI_Comm &mdicomm);
 
    void
    engine_node(const char *node);
 
 
  private:
    /// 1 for proc 0, otherwise 0
    dftfe::Int d_root;
 
    /// MDI communicator
    MDI_Comm d_mdicomm;
 
    /// MDI communicator
    MPI_Comm d_dftfeMPIComm;
 
    /// DFT-FE object
    dftfeWrapper d_dftfeWrapper;
 
    // state of MDI engine
 
    /// which mode engine is in ()
    dftfe::Int d_mode;
    /// current MDI command being processed
    char *d_mdicmd;
    /// which node engine is at
    char *d_node_engine;
    /// which node driver has requested
    char *d_node_driver;
    /// true if driver and engine node currently match
    bool d_node_match;
    /// true if EXIT command received from driver
    bool d_exit_command;
 
    // flags for data received by engine
    // not acted on until a request to send <ENERGY,<FORCES,<PE,<STRESS
    dftfe::Int d_actionflag;
    dftfe::Int d_flag_natoms, d_flag_elements;
    dftfe::Int d_flag_cell, d_flag_dimensions, d_flag_cell_displ;
    dftfe::Int d_flag_charges, d_flag_coords;
    dftfe::Int d_flag_mpGrid, d_flag_mpShift;
    dftfe::Int d_flag_spin;
 
    dftfe::Int              d_sys_natoms;
    dftfe::Int              d_sys_dimensions[3];
    std::vector<dftfe::Int> d_sys_elements;
    std::vector<double>     d_sys_coords;
    double                  d_sys_cell[9], d_sys_cell_displ[3];
    dftfe::Int              d_mpGrid[3];
    double                  d_mpShift[3];
    dftfe::Int              d_spinPolarization;
 
    // class methods
    void
    mdi_commands();
 
    void
    evaluate();
    void
    create_system();
    void
    adjust_box();
    void
    adjust_coords();
 
    void
    receive_cell();
    void
    receive_cell_displ();
    void
    receive_coords();
    void
    receive_natoms();
    void
    receive_elements();
    void
    receive_dimensions();
    void
    receive_mpGrid();
    void
    receive_mpShift();
    void
    receive_spinPolarization();
 
    void
    send_name();
    void
    send_cell();
    void
    send_coords();
    void
    send_natoms();
    void
    send_elements();
    void
    send_spinPolarization();
 
    void
    send_energy();
    void
    send_forces();
    void
    send_stress();
  };
} // namespace dftfe
#  endif
#endif