FCCGenerator.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cmath>
 
#include "autopas/utils/ParticleTypeTrait.h"
 
namespace autopas::generators::FCCGenerator {
 
inline constexpr std::array<std::array<double, 3>, 4> fccBasis = {{
    {0.0, 0.0, 0.0},
    {0.5, 0.5, 0.0},
    {0.5, 0.0, 0.5},
    {0.0, 0.5, 0.5},
}};
 
inline size_t getNumberOfParticles(const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax,
                                   const double spacing = 1.0, const bool centeredAlignment = false) {
  if (spacing <= 0.0) {
    return 0;
  }
 
  const double latticeConstant = std::sqrt(2.0) * spacing;
  std::array<double, 3> offset = {0.0, 0.0, 0.0};
  if (centeredAlignment) {
    offset = {latticeConstant / 4.0, latticeConstant / 4.0, latticeConstant / 4.0};
  }
 
  auto countIndices = [&](const double bMin, const double bMax, const double offsetVal,
                          const double basisVal) -> size_t {
    const double startPos = bMin + offsetVal + basisVal * latticeConstant;
    if (startPos >= bMax) {
      return 0;
    }
    const double remaining = bMax - startPos;
    const auto count = static_cast<size_t>(std::ceil(remaining / latticeConstant));
    return count;
  };
 
  size_t totalCount = 0;
  for (const auto &basis : fccBasis) {
    size_t basisCount = 1;
    for (size_t d = 0; d < 3; ++d) {
      basisCount *= countIndices(boxMin[d], boxMax[d], offset[d], basis[d]);
    }
    totalCount += basisCount;
  }
  return totalCount;
}
 
template <class Container>
void fillWithParticles(Container &container, const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax,
                       const typename autopas::utils::ParticleTypeTrait<Container>::value &defaultParticle =
                           typename autopas::utils::ParticleTypeTrait<Container>::value(),
                       const double spacing = 1.0, const bool centeredAlignment = false) {
  const double latticeConstant = std::sqrt(2.0) * spacing;
 
  std::array<double, 3> offset = {0.0, 0.0, 0.0};
  if (centeredAlignment) {
    offset = {latticeConstant / 4.0, latticeConstant / 4.0, latticeConstant / 4.0};
  }
 
  const size_t numCellsX = std::max<size_t>(1, std::ceil((boxMax[0] - boxMin[0]) / latticeConstant));
  const size_t numCellsY = std::max<size_t>(1, std::ceil((boxMax[1] - boxMin[1]) / latticeConstant));
  const size_t numCellsZ = std::max<size_t>(1, std::ceil((boxMax[2] - boxMin[2]) / latticeConstant));
 
  size_t id = defaultParticle.getID();
  for (size_t z = 0; z < numCellsZ; ++z) {
    for (size_t y = 0; y < numCellsY; ++y) {
      for (size_t x = 0; x < numCellsX; ++x) {
        const std::array<double, 3> cellOrigin = {
            boxMin[0] + static_cast<double>(x) * latticeConstant + offset[0],
            boxMin[1] + static_cast<double>(y) * latticeConstant + offset[1],
            boxMin[2] + static_cast<double>(z) * latticeConstant + offset[2],
        };
        for (const auto &basis : fccBasis) {
          const std::array<double, 3> pos = {
              cellOrigin[0] + basis[0] * latticeConstant,
              cellOrigin[1] + basis[1] * latticeConstant,
              cellOrigin[2] + basis[2] * latticeConstant,
          };
          if (pos[0] >= boxMin[0] and pos[0] < boxMax[0] and pos[1] >= boxMin[1] and pos[1] < boxMax[1] and
              pos[2] >= boxMin[2] and pos[2] < boxMax[2]) {
            auto p = defaultParticle;
            p.setR(pos);
            p.setID(id++);
            container.addParticle(p);
          }
        }
      }
    }
  }
}
 
}  // namespace autopas::generators::FCCGenerator