eonc::GroupSchedule Class Reference

Which calculator group evaluates which system. More...

#include <GroupSchedule.h>

Public Member Functions
	GroupSchedule (int groups)
int	groups () const noexcept
int	defaultHome (std::int64_t key, long position) const
	The home of a key never seen: key mod G for a key of zero or more, the batch position mod G otherwise.
std::vector< int >	assign (const std::vector< std::int64_t > &keys)
	Groups for a batch of systems with these keys.
void	record (std::int64_t key, const double *positions, long n3, const double *cell=nullptr)
	Remember the geometry a key was last evaluated at.
int	nearest (const double *positions, long n3, const double *cell=nullptr) const
	The group for a single request: the home of the recorded geometry nearest to positions (root-mean-square over coordinates), group 0 when nothing of this size is recorded.
void	settle (std::int64_t key, int group)
	A single request's group becomes the home of the single-request key.

Private Member Functions
int	homeOf (std::int64_t key, long position) const

Private Attributes
int	groups_
std::map< std::int64_t, int >	home_
std::map< std::int64_t, std::vector< double > >	last_
std::map< std::int64_t, std::vector< double > >	cells_

Detailed Description

Which calculator group evaluates which system.

A group keeps the converged orbitals of every system it evaluated, under the system's key (a NEB image, a ring bead). Sending a key back to the group that holds its orbitals is what makes the next SCF warm, so a key stays on its home group. A batch caps each group at ceil(M / G) systems: a key whose home group is full moves to the least-loaded group, which becomes its home, because one extra evaluation on a full group costs a whole SCF while a move costs the difference between a warm and a cooler start. A single request goes to the group that last evaluated the geometry nearest to it.

Every decision is made on the driver and sent to the other ranks, so the state here lives on the driver only.

Definition at line 39 of file GroupSchedule.h.

Constructor & Destructor Documentation

GroupSchedule()

eonc::GroupSchedule::GroupSchedule ( int groups )

inlineexplicit

Definition at line 41 of file GroupSchedule.h.

: groups_{std::max(groups, 1)} {}

Member Function Documentation

assign()

std::vector< int > eonc::GroupSchedule::assign ( const std::vector< std::int64_t > & keys )

inlinenodiscard

Groups for a batch of systems with these keys.

Definition at line 53 of file GroupSchedule.h.

                                                                         {
    const long m = static_cast<long>(keys.size());
    const long cap = (m + groups_ - 1) / groups_;
    std::vector<long> load(static_cast<size_t>(groups_), 0);
    std::vector<int> route(static_cast<size_t>(m), -1);
    for (long j = 0; j < m; ++j) {
      const int home = homeOf(keys[static_cast<size_t>(j)], j);
      if (load[static_cast<size_t>(home)] < cap) {
        route[static_cast<size_t>(j)] = home;
        ++load[static_cast<size_t>(home)];
      }
    }
    for (long j = 0; j < m; ++j) {
      if (route[static_cast<size_t>(j)] >= 0)
        continue;
      const auto least = std::min_element(load.begin(), load.end());
      const int g = static_cast<int>(least - load.begin());
      route[static_cast<size_t>(j)] = g;
      ++*least;
    }
    for (long j = 0; j < m; ++j)
      home_[keys[static_cast<size_t>(j)]] = route[static_cast<size_t>(j)];
    return route;
  }

defaultHome()

int eonc::GroupSchedule::defaultHome ( std::int64_t key, long position ) const

inlinenodiscard

The home of a key never seen: key mod G for a key of zero or more, the batch position mod G otherwise.

Definition at line 47 of file GroupSchedule.h.

                                                                     {
    const std::int64_t base = key >= 0 ? key : position;
    return static_cast<int>(((base % groups_) + groups_) % groups_);
  }

groups()

int eonc::GroupSchedule::groups ( ) const

inlinenodiscardnoexcept

Definition at line 43 of file GroupSchedule.h.

{ return groups_; }

homeOf()

int eonc::GroupSchedule::homeOf ( std::int64_t key, long position ) const

inlinenodiscardprivate

Definition at line 128 of file GroupSchedule.h.

                                                                {
    const auto it = home_.find(key);
    return it != home_.end() ? it->second : defaultHome(key, position);
  }

nearest()

int eonc::GroupSchedule::nearest ( const double * positions, long n3, const double * cell = nullptr ) const

inlinenodiscard

The group for a single request: the home of the recorded geometry nearest to positions (root-mean-square over coordinates), group 0 when nothing of this size is recorded.

Definition at line 92 of file GroupSchedule.h.

                                                              {
    double best = std::numeric_limits<double>::infinity();
    int group = 0;
    for (const auto &[key, stored] : last_) {
      if (static_cast<long>(stored.size()) != n3)
        continue;
      const auto recordedCell = cells_.find(key);
      if (cell && recordedCell != cells_.end() &&
          !std::equal(recordedCell->second.begin(), recordedCell->second.end(),
                      cell))
        continue;
      std::vector<double> differences(static_cast<size_t>(n3));
      for (long i = 0; i < n3; ++i) {
        differences[static_cast<size_t>(i)] =
            stored[static_cast<size_t>(i)] - positions[i];
      }
      if (cell &&
          std::any_of(cell, cell + 9, [](double x) { return x != 0.0; }))
        pbc::closestDisplacements(differences.data(), differences.size(), cell);
      double d2 = 0.0;
      for (double d : differences)
        d2 += d * d;
      const auto home = home_.find(key);
      if (d2 < best && home != home_.end()) {
        best = d2;
        group = home->second;
      }
    }
    return group;
  }

record()

void eonc::GroupSchedule::record ( std::int64_t key, const double * positions, long n3, const double * cell = nullptr )

inline

Remember the geometry a key was last evaluated at.

Definition at line 79 of file GroupSchedule.h.

                                          {
    auto &stored = last_[key];
    stored.assign(positions, positions + n3);
    if (cell)
      cells_[key].assign(cell, cell + 9);
    else
      cells_.erase(key);
  }

settle()

void eonc::GroupSchedule::settle ( std::int64_t key, int group )

inline

A single request's group becomes the home of the single-request key.

Definition at line 125 of file GroupSchedule.h.

{ home_[key] = group; }

Member Data Documentation

cells_

std::map<std::int64_t, std::vector<double> > eonc::GroupSchedule::cells_

private

Definition at line 136 of file GroupSchedule.h.

groups_

int eonc::GroupSchedule::groups_

private

Definition at line 133 of file GroupSchedule.h.

home_

std::map<std::int64_t, int> eonc::GroupSchedule::home_

private

Definition at line 134 of file GroupSchedule.h.

last_

std::map<std::int64_t, std::vector<double> > eonc::GroupSchedule::last_

private

Definition at line 135 of file GroupSchedule.h.

---

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

• /home/runner/work/eOn/eOn/include/eon/potentials/Rgpot/GroupSchedule.h