particle_system_data3.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_PARTICLE_SYSTEM_DATA3_H_
#define INCLUDE_JET_PARTICLE_SYSTEM_DATA3_H_
 
#include <jet/array1.h>
#include <jet/serialization.h>
#include <jet/point_neighbor_searcher3.h>
 
#include <memory>
#include <vector>
 
#ifndef JET_DOXYGEN
 
namespace flatbuffers {
 
class FlatBufferBuilder;
template<typename T> struct Offset;
 
}
 
namespace jet {
namespace fbs {
 
struct ParticleSystemData3;
 
}
}
 
#endif  // JET_DOXYGEN
 
namespace jet {
 
class ParticleSystemData3 : public Serializable {
 public:
    typedef Array1<double> ScalarData;
 
    typedef Array1<Vector3D> VectorData;
 
    ParticleSystemData3();
 
    explicit ParticleSystemData3(size_t numberOfParticles);
 
    ParticleSystemData3(const ParticleSystemData3& other);
 
    virtual ~ParticleSystemData3();
 
    void resize(size_t newNumberOfParticles);
 
    size_t numberOfParticles() const;
 
    size_t addScalarData(double initialVal = 0.0);
 
    size_t addVectorData(const Vector3D& initialVal = Vector3D());
 
    double radius() const;
 
    virtual void setRadius(double newRadius);
 
    double mass() const;
 
    virtual void setMass(double newMass);
 
    ConstArrayAccessor1<Vector3D> positions() const;
 
    ArrayAccessor1<Vector3D> positions();
 
    ConstArrayAccessor1<Vector3D> velocities() const;
 
    ArrayAccessor1<Vector3D> velocities();
 
    ConstArrayAccessor1<Vector3D> forces() const;
 
    ArrayAccessor1<Vector3D> forces();
 
    ConstArrayAccessor1<double> scalarDataAt(size_t idx) const;
 
    ArrayAccessor1<double> scalarDataAt(size_t idx);
 
    ConstArrayAccessor1<Vector3D> vectorDataAt(size_t idx) const;
 
    ArrayAccessor1<Vector3D> vectorDataAt(size_t idx);
 
    void addParticle(
        const Vector3D& newPosition,
        const Vector3D& newVelocity = Vector3D(),
        const Vector3D& newForce = Vector3D());
 
    void addParticles(
        const ConstArrayAccessor1<Vector3D>& newPositions,
        const ConstArrayAccessor1<Vector3D>& newVelocities
            = ConstArrayAccessor1<Vector3D>(),
        const ConstArrayAccessor1<Vector3D>& newForces
            = ConstArrayAccessor1<Vector3D>());
 
    const PointNeighborSearcher3Ptr& neighborSearcher() const;
 
    void setNeighborSearcher(
        const PointNeighborSearcher3Ptr& newNeighborSearcher);
 
    const std::vector<std::vector<size_t>>& neighborLists() const;
 
    void buildNeighborSearcher(double maxSearchRadius);
 
    void buildNeighborLists(double maxSearchRadius);
 
    void serialize(std::vector<uint8_t>* buffer) const override;
 
    void deserialize(const std::vector<uint8_t>& buffer) override;
 
    void set(const ParticleSystemData3& other);
 
    ParticleSystemData3& operator=(const ParticleSystemData3& other);
 
 protected:
    void serializeParticleSystemData(
        flatbuffers::FlatBufferBuilder* builder,
        flatbuffers::Offset<fbs::ParticleSystemData3>* fbsParticleSystemData)
        const;
 
    void deserializeParticleSystemData(
        const fbs::ParticleSystemData3* fbsParticleSystemData);
 
 private:
    double _radius = 1e-3;
    double _mass = 1e-3;
    size_t _numberOfParticles = 0;
    size_t _positionIdx;
    size_t _velocityIdx;
    size_t _forceIdx;
 
    std::vector<ScalarData> _scalarDataList;
    std::vector<VectorData> _vectorDataList;
 
    PointNeighborSearcher3Ptr _neighborSearcher;
    std::vector<std::vector<size_t>> _neighborLists;
};
 
typedef std::shared_ptr<ParticleSystemData3> ParticleSystemData3Ptr;
 
}  // namespace jet
 
#endif  // INCLUDE_JET_PARTICLE_SYSTEM_DATA3_H_