18template <
class ParticleCell>
19class TraversalSelector;
21template <
class Particle_T>
22class VLCCellPairTraversalInterface;
29template <
class Particle_T>
46 using SoAListType =
typename std::vector<std::vector<std::vector<SoAPairOfParticleAndList>>>;
48 [[nodiscard]] ContainerOption
getContainerType()
const override {
return ContainerOption::pairwiseVerletLists; }
52 bool particleFound{
false};
53 for (
auto &neighborListsForOneCell : _aosNeighborList) {
54 for (
const auto &neighborListsForCellCellPair : neighborListsForOneCell) {
57 for (
size_t i{0}; i < neighborListsForCellCellPair.size(); ++i) {
58 if (neighborListsForCellCellPair[i].first == particle) {
61 listSize += neighborListsForCellCellPair[i].second.size();
81 return _aosNeighborList;
94 using namespace utils::ArrayMath::literals;
96 if (linkedCells.
getCellBlock().getCellsPerInteractionLength() > 1) {
98 "VLCCellPairNeighborList::buildAoSNeighborList() was called with a CSF < 1 but it only supports CSF>=1.");
102 auto &cells = linkedCells.
getCells();
104 const auto interactionLengthSquared = interactionLength * interactionLength;
106 std::array<double, 3>{interactionLength, interactionLength, interactionLength} * 2.;
109 auto relativeNeighborhoodIndex = [&](
auto cellIndex1,
auto cellIndex2) {
110 const auto cellsPerDimensionWithHalo = linkedCells.
getCellBlock().getCellsPerDimensionWithHalo();
112 cellsPerDimensionWithHalo);
114 cellsPerDimensionWithHalo);
115 const auto offset = threeDPosCell2 - threeDPosCell1;
116 return (offset[0] + 1) * 9 + (offset[1] + 1) * 3 + (offset[2] + 1);
121 linkedCells.
getNumberOfParticles(IteratorBehavior::ownedOrHalo), boxSizeWithHalo, interactionLength, 1.3);
125 for (
auto &neighborCellLists : neighborLists) {
126 for (
auto &cellLists : neighborCellLists) {
127 for (
auto &[particlePtr, neighbors] : cellLists) {
128 particlePtr =
nullptr;
133 neighborLists.resize(cells.size());
135 for (
auto &neighborList : neighborLists) {
136 neighborList.resize(27);
148 auto insert = [&](
auto &p1,
auto &p2,
auto &neighborList) {
150 auto iter = std::find_if(neighborList.begin(), neighborList.end(), [&](
const auto &pair) {
151 const auto &[particlePtr, list] = pair;
152 return particlePtr == &p1;
155 if (iter != neighborList.end()) {
156 iter->second.push_back(&p2);
159 if (
auto insertLoc = std::find_if(neighborList.begin(), neighborList.end(),
160 [&](
const auto &pair) {
161 const auto &[particlePtr, list] = pair;
162 return particlePtr == nullptr;
164 insertLoc != neighborList.end()) {
165 auto &[particlePtr, neighbors] = *insertLoc;
167 neighbors.reserve(listLengthEstimate);
168 neighbors.push_back(&p2);
170 neighborList.emplace_back(&p1, std::vector<Particle_T *>{});
171 neighborList.back().second.reserve(listLengthEstimate);
172 neighborList.back().second.push_back(&p2);
177 const auto &cellsPerDim =
178 utils::ArrayUtils::static_cast_copy_array<int>(linkedCells.
getCellBlock().getCellsPerDimensionWithHalo());
187 switch (vlcTraversalOpt) {
188 case TraversalOption::vlc_c08:
190 xEnd = cellsPerDim[0] - 1;
191 yEnd = cellsPerDim[1] - 1;
192 zEnd = cellsPerDim[2] - 1;
195 xEnd = cellsPerDim[0];
196 yEnd = cellsPerDim[1];
197 zEnd = cellsPerDim[2];
203 for (
int z = 0; z < zEnd; ++z) {
204 for (
int y = 0; y < yEnd; ++y) {
205 for (
int x = 0; x < xEnd; ++x) {
208 auto &baseCell = cells[cellIndexBase];
209 auto &baseCellsLists = neighborLists[cellIndexBase];
213 for (
const auto &[offset1, offset2, _] : offsets) {
214 const auto cell1Index1D = cellIndexBase + offset1;
215 const auto cell2Index1D = cellIndexBase + offset2;
216 auto &cell1List = neighborLists[cell1Index1D];
217 auto &cell2List = neighborLists[cell2Index1D];
221 if (cell2Index3D[0] >= cellsPerDim[0] or cell2Index3D[0] < 0 or cell2Index3D[1] >= cellsPerDim[1] or
222 cell2Index3D[1] < 0 or cell2Index3D[2] >= cellsPerDim[2] or cell2Index3D[2] < 0) {
233 for (
size_t particleIndexCell1 = 0; particleIndexCell1 < cells[cell1Index1D].size(); ++particleIndexCell1) {
234 auto &p1 = cells[cell1Index1D][particleIndexCell1];
241 size_t startIndexCell2 = 0;
242 if (cell1Index1D == cell2Index1D and vlcTraversalOpt != TraversalOption::vlp_c01) {
243 startIndexCell2 = particleIndexCell1 + 1;
246 for (
size_t particleIndexCell2 = startIndexCell2; particleIndexCell2 < cells[cell2Index1D].size();
247 ++particleIndexCell2) {
248 auto &p2 = cells[cell2Index1D][particleIndexCell2];
250 if (&p1 == &p2 or p1.isDummy() or p2.isDummy()) {
255 const auto distVec = p2.getR() - p1.getR();
257 if (distSquared < interactionLengthSquared) {
259 const size_t secondCellIndexInFirst = relativeNeighborhoodIndex(cell1Index1D, cell2Index1D);
260 insert(p1, p2, cell1List[secondCellIndexInFirst]);
266 if (not useNewton3 and not(vlcTraversalOpt == TraversalOption::vlp_c01)) {
268 const size_t secondCellIndexInFirst = relativeNeighborhoodIndex(cell2Index1D, cell1Index1D);
269 insert(p2, p1, cell2List[secondCellIndexInFirst]);
281 for (
auto &neighborCellLists : neighborLists) {
282 for (
auto &cellLists : neighborCellLists) {
283 cellLists.erase(std::remove_if(cellLists.begin(), cellLists.end(),
284 [](
const auto &pair) {
285 const auto &[particlePtr, neighbors] = pair;
286 return particlePtr == nullptr;
294 _soaNeighborList.clear();
297 std::unordered_map<Particle_T *, size_t> particlePtrToIndex;
298 particlePtrToIndex.reserve(linkedCells.
size());
300 for (
auto iter = linkedCells.
begin(IteratorBehavior::ownedOrHaloOrDummy); iter.isValid(); ++iter, ++i) {
301 particlePtrToIndex[&(*iter)] = i;
304 _soaNeighborList.resize(linkedCells.
getCells().size());
307 for (
size_t firstCellIndex = 0; firstCellIndex < _aosNeighborList.size(); ++firstCellIndex) {
308 const auto &aosLists = _aosNeighborList[firstCellIndex];
309 auto &soaLists = _soaNeighborList[firstCellIndex];
310 soaLists.resize(aosLists.size());
313 for (
size_t secondCellIndex = 0; secondCellIndex < aosLists.size(); ++secondCellIndex) {
314 const auto &aosCellPairLists = aosLists[secondCellIndex];
315 auto &soaCellPairLists = soaLists[secondCellIndex];
316 soaCellPairLists.reserve(aosCellPairLists.capacity());
319 for (
const auto &[particlePtr, neighbors] : aosCellPairLists) {
321 size_t currentParticleGlobalIndex = particlePtrToIndex.at(particlePtr);
324 std::vector<size_t, autopas::AlignedAllocator<size_t>> currentSoANeighborList{};
325 currentSoANeighborList.reserve(neighbors.size());
328 for (
const auto &neighborOfCurrentParticle : neighbors) {
329 currentSoANeighborList.emplace_back(particlePtrToIndex.at(neighborOfCurrentParticle));
333 soaCellPairLists.emplace_back(currentParticleGlobalIndex, currentSoANeighborList);
351 "Trying to use a traversal of wrong type in VerletListCells.h. TraversalID: {}",
362 std::vector<std::vector<std::vector<std::pair<Particle_T *, std::vector<Particle_T *>>>>>();
369 std::vector<std::vector<std::pair<size_t, std::vector<size_t, autopas::AlignedAllocator<size_t>>>>>>();
#define AUTOPAS_OPENMP(args)
Empty macro to throw away any arguments.
Definition: WrapOpenMP.h:126
double getInteractionLength() const final
Return the interaction length (cutoff+skin) of the container.
Definition: CellBasedParticleContainer.h:89
size_t getNumberOfParticles(IteratorBehavior behavior) const override
Get the number of particles with respect to the specified IteratorBehavior.
Definition: CellBasedParticleContainer.h:113
size_t size() const override
Get the total number of particles saved in the container (owned + halo + dummy).
Definition: CellBasedParticleContainer.h:131
const std::array< double, 3 > & getBoxMin() const final
Get the lower corner of the container without halo.
Definition: CellBasedParticleContainer.h:74
const std::array< double, 3 > & getBoxMax() const final
Get the upper corner of the container without halo.
Definition: CellBasedParticleContainer.h:69
LinkedCells class.
Definition: LinkedCells.h:40
internal::CellBlock3D< ParticleCell > & getCellBlock()
Get the cell block, not supposed to be used except by verlet lists.
Definition: LinkedCells.h:458
ContainerIterator< ParticleType, true, false > begin(IteratorBehavior behavior=autopas::IteratorBehavior::ownedOrHalo, typename ContainerIterator< ParticleType, true, false >::ParticleVecType *additionalVectors=nullptr) override
Iterate over all particles using for(auto iter = container.begin(); iter.isValid(); ++iter) .
Definition: LinkedCells.h:307
std::vector< ParticleCell > & getCells()
Returns a non-const reference to the cell data structure.
Definition: LinkedCells.h:470
This interface serves as a common parent class for all traversals.
Definition: TraversalInterface.h:18
virtual TraversalOption getTraversalType() const =0
Return a enum representing the name of the traversal class.
Neighbor list to be used with VerletListsCells container.
Definition: VLCCellPairNeighborList.h:30
auto & getSoANeighborList()
Returns the neighbor list in SoA layout.
Definition: VLCCellPairNeighborList.h:88
ContainerOption getContainerType() const override
Returns the container type of this neighbor list and the container it belongs to.
Definition: VLCCellPairNeighborList.h:48
typename std::vector< std::vector< std::vector< SoAPairOfParticleAndList > > > SoAListType
Helper type definition.
Definition: VLCCellPairNeighborList.h:46
void buildAoSNeighborList(TraversalOption vlcTraversalOpt, LinkedCells< Particle_T > &linkedCells, bool useNewton3)
Builds AoS neighbor list from underlying linked cells object.
Definition: VLCCellPairNeighborList.h:93
std::pair< size_t, std::vector< size_t, autopas::AlignedAllocator< size_t > > > SoAPairOfParticleAndList
Helper type definition.
Definition: VLCCellPairNeighborList.h:40
VerletListsCellsHelpers::PairwiseNeighborListsType< Particle_T > & getAoSNeighborList()
Returns the neighbor list in AoS layout.
Definition: VLCCellPairNeighborList.h:80
size_t getNumberOfPartners(const Particle_T *particle) const override
Gets the number of neighbors over all neighbor lists that belong to this particle.
Definition: VLCCellPairNeighborList.h:50
void setUpTraversal(TraversalInterface *traversal) override
Assigns the current traversal to the correct traversal interface.
Definition: VLCCellPairNeighborList.h:339
void generateSoAFromAoS(LinkedCells< Particle_T > &linkedCells) override
Generates neighbor list in SoA layout from available neighbor list in AoS layout.
Definition: VLCCellPairNeighborList.h:293
typename VerletListsCellsHelpers::PairwiseNeighborListsType< Particle_T > ListType
Type of the data structure used to save the neighbor lists.
Definition: VLCCellPairNeighborList.h:35
Interface for traversals used with VLCCellPairNeighborList.
Definition: VLCCellPairTraversalInterface.h:16
void setVerletList(VLCCellPairNeighborList< Particle_T > &verlet)
Sets the verlet list for the traversal to iterate over.
Definition: VLCCellPairTraversalInterface.h:22
Interface of neighbor lists to be used with VerletListsCells container.
Definition: VLCNeighborListInterface.h:19
void setLinkedCellsPointer(LinkedCells< Particle_T > *linkedCells)
Set the Linked Cells Pointer for this List.
Definition: VLCNeighborListInterface.h:110
This class provides the Traversal Interface for the verlet lists cells container.
Definition: VLCTraversalInterface.h:27
virtual void setVerletList(NeighborList &verlet)
Sets the verlet list for the traversal to iterate over.
Definition: VLCTraversalInterface.h:41
static void exception(const Exception e)
Handle an exception derived by std::exception.
Definition: ExceptionHandler.h:63
std::vector< std::vector< std::vector< std::pair< Particle_T *, std::vector< Particle_T * > > > > > PairwiseNeighborListsType
Pairwise verlet lists: For every cell a vector, for every neighboring cell a vector of particle-neigh...
Definition: VerletListsCellsHelpers.h:41
size_t estimateListLength(size_t numParticles, const std::array< double, 3 > &boxSize, double interactionLength, double correctionFactor)
Simple heuristic to calculate the average number of particles per verlet list assuming particles are ...
Definition: VerletListsCellsHelpers.cpp:16
std::vector< BaseStepOffsets > buildBaseStep(const std::array< int, 3 > &cellsPerDim, const TraversalOption traversal)
Builds the list of offsets from the base cell for the c01, c08, and c18 base step.
Definition: VerletListsCellsHelpers.cpp:26
constexpr T dot(const std::array< T, SIZE > &a, const std::array< T, SIZE > &b)
Generates the dot product of two arrays.
Definition: ArrayMath.h:233
constexpr std::array< T, 3 > oneToThreeD(T ind, const std::array< T, 3 > &dims)
Convert a 1d index to a 3d index.
Definition: ThreeDimensionalMapping.h:55
constexpr T threeToOneD(T x, T y, T z, const std::array< T, 3 > &dims)
Convert a 3d index to a 1d index.
Definition: ThreeDimensionalMapping.h:29
This is the main namespace of AutoPas.
Definition: AutoPasDecl.h:32
int autopas_get_max_threads()
Dummy for omp_get_max_threads() when no OpenMP is available.
Definition: WrapOpenMP.h:144
@ owned
Owned state, a particle with this state is an actual particle and owned by the current AutoPas object...
int autopas_get_thread_num()
Dummy for omp_set_lock() when no OpenMP is available.
Definition: WrapOpenMP.h:132