LAMMPS_NS::PairHDNNPDevelop Class Reference

#include <pair_hdnnp_develop.h>

Inheritance diagram for LAMMPS_NS::PairHDNNPDevelop:

Collaboration diagram for LAMMPS_NS::PairHDNNPDevelop:

Public Member Functions
	PairHDNNPDevelop (class LAMMPS *)
void	compute (int, int) override
void	init_style () override
double	init_one (int i, int j) override
Public Member Functions inherited from LAMMPS_NS::PairHDNNP
	PairHDNNP (class LAMMPS *)
	~PairHDNNP () override
void	compute (int, int) override
void	settings (int, char **) override
void	coeff (int, char **) override
void	init_style () override
double	init_one (int, int) override

Protected Member Functions
void	transferNeighborList (double const cutoffRadius)
void	updateNeighborlistCutoff ()
	Update neighborlist if maxCutoffRadiusNeighborList has changed.
Protected Member Functions inherited from LAMMPS_NS::PairHDNNP
virtual void	allocate ()
void	transferNeighborList ()
void	handleExtrapolationWarnings ()

Protected Attributes
double	maxCutoffRadiusNeighborList
	Keeps track of the maximum cutoff radius that was used for the neighbor list.
Protected Attributes inherited from LAMMPS_NS::PairHDNNP
bool	showew
bool	resetew
int	showewsum
int	maxew
long	numExtrapolationWarningsTotal
long	numExtrapolationWarningsSummary
double	cflength
double	cfenergy
double	maxCutoffRadius
char *	directory
std::string	emap
nnp::InterfaceLammps *	interface

Detailed Description

Definition at line 30 of file pair_hdnnp_develop.h.

Constructor & Destructor Documentation

PairHDNNPDevelop()

PairHDNNPDevelop::PairHDNNPDevelop

(

class LAMMPS *

lmp

)

Definition at line 44 of file pair_hdnnp_develop.cpp.

: PairHDNNP(lmp) {}

References LAMMPS_NS::PairHDNNP::PairHDNNP().

Here is the call graph for this function:

Member Function Documentation

compute()

void PairHDNNPDevelop::compute ( int eflag, int vflag )

override

Definition at line 48 of file pair_hdnnp_develop.cpp.

{
  if(eflag || vflag) ev_setup(eflag,vflag);
  else evflag = vflag_fdotr = eflag_global = eflag_atom = 0;
 
  // Set number of local atoms and add index and element.
  interface->setLocalAtoms(atom->nlocal, atom->type);
  // Transfer tags separately. Interface::setLocalTags is overloaded internally
  // to work with both -DLAMMPS_SMALLBIG (tagint = int) and -DLAMMPS_BIGBIG
  // (tagint = int64_t)
  interface->setLocalTags(atom->tag);
 
 
  // Also set absolute atom positions.
  interface->setLocalAtomPositions(atom->x);
 
  // Set Box vectors if system is periodic in all 3 dims.
  if(domain->nonperiodic == 0)
  {
      interface->setBoxVectors(domain->boxlo,
                               domain->boxhi,
                               domain->xy,
                               domain->xz,
                               domain->yz);
  }
 
  updateNeighborlistCutoff();
 
  // Transfer local neighbor list to NNP interface. Has to be called after
  // setBoxVectors if structure is periodic!
  transferNeighborList(maxCutoffRadiusNeighborList);
 
  // Compute symmetry functions, atomic neural networks and add up energy.
  interface->processDevelop();
 
  // Do all stuff related to extrapolation warnings.
  if(showew == true || showewsum > 0 || maxew >= 0) {
    handleExtrapolationWarnings();
  }
 
  // Calculate forces of local and ghost atoms.
  interface->getForcesDevelop(atom->f);
 
  // Transfer charges LAMMPS. Does nothing if nnpType != 4G.
  interface->getCharges(atom->q);
 
  // Add energy contribution to total energy.
  if (eflag_global)
     ev_tally(0,0,atom->nlocal,1,interface->getEnergy(),0.0,0.0,0.0,0.0,0.0);
 
  // Add atomic energy if requested (CAUTION: no physical meaning!).
  if (eflag_atom)
    for (int i = 0; i < atom->nlocal; ++i)
      eatom[i] = interface->getAtomicEnergy(i);
 
  // If virial needed calculate via F dot r.
  if (vflag_fdotr) virial_fdotr_compute();
 
    //interface.writeToFile("md_run.data", true);
}

References LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings(), LAMMPS_NS::PairHDNNP::interface, maxCutoffRadiusNeighborList, LAMMPS_NS::PairHDNNP::maxew, LAMMPS_NS::PairHDNNP::showew, LAMMPS_NS::PairHDNNP::showewsum, LAMMPS_NS::PairHDNNP::transferNeighborList(), and updateNeighborlistCutoff().

Here is the call graph for this function:

init_style()

void PairHDNNPDevelop::init_style ( )

override

Definition at line 113 of file pair_hdnnp_develop.cpp.

{
  if (comm->nprocs > 1) {
    throw runtime_error("ERROR: Pair style \"nnp/develop\" can only be used "
                        "with a single MPI task.\n");
  }
 
  if(domain->dimension != 3)
    throw runtime_error("ERROR: Only 3d systems can be used!");
 
  if (!(domain->xperiodic == domain->yperiodic
     && domain->yperiodic == domain->zperiodic))
    throw runtime_error("ERROR: System must be either aperiodic or periodic "
                        "in all 3 dimmensions!");
 
  // Required for charge equilibration scheme.
  if (atom->map_style == Atom::MAP_NONE)
      throw runtime_error("ERROR: pair style requires atom map yes");
 
  PairHDNNP::init_style();
 
 
  maxCutoffRadiusNeighborList = maxCutoffRadius;
 
  interface->setGlobalStructureStatus(true);
}

References LAMMPS_NS::PairHDNNP::init_style(), LAMMPS_NS::PairHDNNP::interface, LAMMPS_NS::PairHDNNP::maxCutoffRadius, and maxCutoffRadiusNeighborList.

Here is the call graph for this function:

init_one()

double PairHDNNPDevelop::init_one ( int i, int j )

override

Definition at line 141 of file pair_hdnnp_develop.cpp.

{
    //cutsq[i][j] = cutsq[j][i] = pow(maxCutoffRadiusNeighborList,2);
    return maxCutoffRadiusNeighborList;
}

References maxCutoffRadiusNeighborList.

transferNeighborList()

void PairHDNNPDevelop::transferNeighborList ( double const cutoffRadius )

protected

Definition at line 148 of file pair_hdnnp_develop.cpp.

{
  // Transfer neighbor list to NNP.
  double rc2 = cutoffRadius * cutoffRadius;
  interface->allocateNeighborlists(list->numneigh);
#ifdef _OPENMP
  #pragma omp parallel for
#endif
  for (int ii = 0; ii < list->inum; ++ii) {
    int i = list->ilist[ii];
    for (int jj = 0; jj < list->numneigh[i]; ++jj) {
      int j = list->firstneigh[i][jj];
      j &= NEIGHMASK;
      double dx = atom->x[i][0] - atom->x[j][0];
      double dy = atom->x[i][1] - atom->x[j][1];
      double dz = atom->x[i][2] - atom->x[j][2];
      double d2 = dx * dx + dy * dy + dz * dz;
      if (d2 <= rc2) {
        if (!interface->getGlobalStructureStatus())
          // atom->tag[j] will be implicitly converted to int64_t internally.
          interface->addNeighbor(i,j,atom->tag[j],atom->type[j],dx,dy,dz,d2);
        else
          interface->addNeighbor(i,j,atom->map(atom->tag[j]),atom->type[j],dx,dy,dz,d2);
      }
    }
  }
  interface->finalizeNeighborList();
}

References LAMMPS_NS::PairHDNNP::interface.

updateNeighborlistCutoff()

void PairHDNNPDevelop::updateNeighborlistCutoff ( )

protected

Update neighborlist if maxCutoffRadiusNeighborList has changed.

Definition at line 178 of file pair_hdnnp_develop.cpp.

{
    double maxCutoffRadiusOverall = interface->getMaxCutoffRadiusOverall();
    if(maxCutoffRadiusOverall > maxCutoffRadiusNeighborList)
    {
        // TODO: Increase slightly to compensate for rounding errors?
        utils::logmesg(lmp, fmt::format("WARNING: Cutoff too small, need at "
                                        "least: {}\n", maxCutoffRadiusOverall));
 
        //maxCutoffRadiusNeighborList = maxCutoffRadiusOverall;
        //reinit();
 
        //mixed_flag = 1;
        //for (int i = 1; i <= atom->ntypes; i++)
        //{
        //    for (int j = i; j <= atom->ntypes; j++)
        //    {
        //        if ((i != j) && setflag[i][j]) mixed_flag = 0;
        //        cutsq[i][j] = cutsq[j][i] = pow(maxCutoffRadiusNeighborList, 2);
        //    }
        //}
        //cutforce = MAX(cutforce, maxCutoffRadiusNeighborList);
 
        //neighbor->init();
        //neighbor->build(0);
    }
}

References LAMMPS_NS::PairHDNNP::interface, and maxCutoffRadiusNeighborList.

Referenced by compute().

Here is the caller graph for this function:

Member Data Documentation

maxCutoffRadiusNeighborList

double LAMMPS_NS::PairHDNNPDevelop::maxCutoffRadiusNeighborList

protected

Keeps track of the maximum cutoff radius that was used for the neighbor list.

Definition at line 41 of file pair_hdnnp_develop.h.

Referenced by compute(), init_one(), init_style(), and updateNeighborlistCutoff().

---

The documentation for this class was generated from the following files:

• /home/runner/work/n2p2/n2p2/src/interface/LAMMPS/src/ML-HDNNP/pair_hdnnp_develop.h
• /home/runner/work/n2p2/n2p2/src/interface/LAMMPS/src/ML-HDNNP/pair_hdnnp_develop.cpp