pointData.hpp

#ifndef ABLATELIBRARY_POINTDATA_HPP
#define ABLATELIBRARY_POINTDATA_HPP
 
#include <petsc.h>
#include <map>
#include "particles/field.hpp"
#include "utilities/petscUtilities.hpp"
 
namespace ablate::particles::accessors {
template <class DataType>
struct Data {
    DataType* values = nullptr;
 
    PetscInt numberComponents = 0;
 
    PetscInt dataSize = 0;
 
    PetscInt offset = 0;
 
    Data() = default;
 
    Data(DataType* values, PetscInt numberComponents, PetscInt dataSizeIn = 0, PetscInt offset = 0)
        : values(values), numberComponents(numberComponents), dataSize(dataSizeIn ? dataSizeIn : numberComponents), offset(offset) {}
 
    Data(DataType* values, const ablate::particles::Field& field) : values(values), numberComponents(field.numberComponents), dataSize(field.dataSize), offset(field.offset) {}
 
    template <class IndexType>
    inline DataType* operator[](IndexType particle) const {
        return values + (particle * dataSize + offset);
    }
 
    template <class IndexType>
    inline DataType& operator()(IndexType particle) {
        return values[particle * dataSize + offset];
    }
 
    template <class IndexType, class DimType>
    inline DataType& operator()(IndexType particle, DimType dim) {
        return values[particle * dataSize + offset + dim];
    }
 
    template <class DestinationDataType, class IndexType>
    inline void CopyFrom(DestinationDataType* source, IndexType p) const {
        for (PetscInt d = 0; d < numberComponents; d++) {
            values[p * dataSize + offset + d] = source[d];
        }
    }
 
    template <class DestinationDataType, class IndexType>
    inline void AddFrom(DestinationDataType* source, IndexType p) const {
        for (PetscInt d = 0; d < numberComponents; d++) {
            values[p * dataSize + offset + d] += source[d];
        }
    }
 
    template <class DestinationDataType, class IndexType>
    inline void CopyAll(DestinationDataType* destination, IndexType np) const {
        for (IndexType p = 0; p < np; p++) {
            for (PetscInt d = 0; d < numberComponents; d++) {
                destination[p * numberComponents + d] = values[p * dataSize + offset + d];
            }
        }
    }
};
 
using ConstPointData = Data<const PetscReal>;
using PointData = Data<PetscReal>;
 
}  // namespace ablate::particles::accessors
#endif  // ABLATELIBRARY_POINTDATA_HPP