VectorizedChargeP2PCellProcessor.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdlib.h>
#include "bhfmm/containers/ParticleCellPointers.h"
#include "utils/AlignedArray.h"
#include "particleContainer/adapter/vectorization/SIMD_TYPES.h"
#include "particleContainer/adapter/vectorization/SIMD_VectorizedCellProcessorHelpers.h"
#include "particleContainer/adapter/CellDataSoA.h"
#include "WrapOpenMP.h"
 
#include <iostream>
#include <vector>
#include <cmath>
 
#include "molecules/MoleculeForwardDeclaration.h"
 
class Component;
class Domain;
class Comp2Param;
 
namespace bhfmm {
class VectorizedChargeP2PCellProcessor {
public:
    typedef std::vector<Component> ComponentList;
 
    VectorizedChargeP2PCellProcessor(Domain & domain, double cutoffRadius=0, double LJcutoffRadius=0);
 
    ~~VectorizedChargeP2PCellProcessor();
 
    void initTraversal();
    void preprocessCell(ParticleCellPointers& cell);
    void processCellPair(ParticleCellPointers& cell1, ParticleCellPointers& cell2);
    void processCell(ParticleCellPointers& cell);
    void postprocessCell(ParticleCellPointers& cell);
    void endTraversal();
 
    void printTimers();
 
private:
    double _cutoffRadiusSquare;
 
    typedef std::vector<Molecule *> MoleculeList;
 
    Domain & _domain;
 
    double _upotXpoles;
 
    double _virial;
 
    struct VCP2PCPThreadData {
    public:
        VCP2PCPThreadData(): _charges_dist_lookup(nullptr){
            _upotXpolesV.resize(_numVectorElements);
            _virialV.resize(_numVectorElements);
 
            for (size_t j = 0; j < _numVectorElements; ++j) {
                _upotXpolesV[j] = 0.0;
                _virialV[j] = 0.0;
            }
        }
 
        AlignedArray<vcp_lookupOrMask_single> _centers_dist_lookup;
 
        vcp_lookupOrMask_single* _charges_dist_lookup;
 
        AlignedArray<vcp_real_accum> _upotXpolesV, _virialV;
    };
 
    std::vector<VCP2PCPThreadData *> _threadData;
 
    static const size_t _numVectorElements = VCP_VEC_SIZE;
    size_t _numThreads;
 
    template<bool calculateMacroscopic>
    inline void _loopBodyCharge(
        const RealCalcVec& m1_r_x, const RealCalcVec& m1_r_y, const RealCalcVec& m1_r_z,
        const RealCalcVec& r1_x, const RealCalcVec& r1_y, const RealCalcVec& r1_z,
        const RealCalcVec& qii,
        const RealCalcVec& m2_r_x, const RealCalcVec& m2_r_y, const RealCalcVec& m2_r_z,
        const RealCalcVec& r2_x, const RealCalcVec& r2_y, const RealCalcVec& r2_z,
        const RealCalcVec& qjj,
        RealCalcVec& f_x, RealCalcVec& f_y, RealCalcVec& f_z,
        RealAccumVec& V_x, RealAccumVec& V_y, RealAccumVec& V_z,
        RealAccumVec& sum_upotXpoles, RealAccumVec& sum_virial,
        const MaskCalcVec& forceMask);
 
    template<class ForcePolicy, bool CalculateMacroscopic, class MaskGatherChooser>
    void _calculatePairs(CellDataSoA & soa1, CellDataSoA & soa2);
 
}; /* end of class VectorizedChargeP2PCellProcessor */
 
} // namespace bhfmm