VectorizedLJP2PCellProcessor.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdlib.h>
#include "particleContainer/adapter/CellProcessor.h"
#include "utils/AlignedArray.h"
#include <iostream>
#include <vector>
#include <cmath>
#include "particleContainer/adapter/vectorization/SIMD_TYPES.h"
#include "particleContainer/adapter/vectorization/SIMD_VectorizedCellProcessorHelpers.h"
#include "WrapOpenMP.h"
 
#include "molecules/MoleculeForwardDeclaration.h"
 
class Component;
class Domain;
class Comp2Param;
class CellDataSoA;
 
namespace bhfmm {
class VectorizedLJP2PCellProcessor : public CellProcessor {
public:
    typedef std::vector<Component> ComponentList;
 
    VectorizedLJP2PCellProcessor(Domain & domain, double cutoffRadius, double LJcutoffRadius);
 
    ~~VectorizedLJP2PCellProcessor();
 
    void initTraversal();
    void preprocessCell(ParticleCell& /*cell*/) {}
 
    double processSingleMolecule(Molecule* /*m1*/, ParticleCell& /*cell2*/) {
        return 0.0;
    }
 
    void processCell(ParticleCell& cell);
        
        void processCellPair(ParticleCell& c1, ParticleCell& c2, bool sumAll = false);
    void postprocessCell(ParticleCell& /*cell*/) {}
    void endTraversal();
 
    void printTimers();
 
 
private:
    typedef std::vector<Molecule *> MoleculeList;
 
    Domain & _domain;
 
    //const double _cutoffRadiusSquare;
 
    //const double _LJcutoffRadiusSquare;
 
    const double _epsRFInvrc3;
 
    std::vector<AlignedArray<vcp_real_calc> > _eps_sig;
 
    std::vector<AlignedArray<vcp_real_calc> > _shift6;
 
    double _upot6lj;
 
    double _virial;
 
    struct VLJP2PCPThreadData {
    public:
        VLJP2PCPThreadData(): _ljc_dist_lookup(nullptr){
            _upot6ljV.resize(_numVectorElements);
            _virialV.resize(_numVectorElements);
 
            for (size_t j = 0; j < _numVectorElements; ++j) {
                _upot6ljV[j] = 0.0;
                _virialV[j] = 0.0;
            }
        }
 
        AlignedArray<vcp_lookupOrMask_single> _centers_dist_lookup;
 
        vcp_lookupOrMask_single* _ljc_dist_lookup;
 
        AlignedArray<vcp_real_accum> _upot6ljV, _virialV;
    };
 
    std::vector<VLJP2PCPThreadData *> _threadData;
 
    static const size_t _numVectorElements = VCP_VEC_SIZE;
    size_t _numThreads;
 
    template<bool calculateMacroscopic>
    inline
    void _loopBodyLJ(
            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& 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,
            RealCalcVec& f_x, RealCalcVec& f_y, RealCalcVec& f_z,
            RealAccumVec& V_x, RealAccumVec& V_y, RealAccumVec& V_z,
            RealAccumVec& sum_upot6lj, RealAccumVec& sum_virial,
            const MaskCalcVec& forceMask,
            const RealCalcVec& eps_24, const RealCalcVec& sig2,
            const RealCalcVec& shift6);
 
    template<class ForcePolicy, bool CalculateMacroscopic, class MaskGatherChooser>
    void _calculatePairs(CellDataSoA & soa1, CellDataSoA & soa2);
 
}; /* end of class VectorizedLJP2PCellProcessor */
 
} // namespace bhfmm