particle_system_data2.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_DATA2_H_
#define INCLUDE_JET_PARTICLE_SYSTEM_DATA2_H_
 
#include <jet/array1.h>
#include <jet/point_neighbor_searcher2.h>
#include <jet/serialization.h>
 
#include <memory>
#include <vector>
 
#ifndef JET_DOXYGEN
 
namespace flatbuffers {
 
class FlatBufferBuilder;
template<typename T> struct Offset;
 
}
 
namespace jet {
namespace fbs {
 
struct ParticleSystemData2;
 
}
}
 
#endif  // JET_DOXYGEN
 
namespace jet {
 
class ParticleSystemData2 : public Serializable {
 public:
    typedef Array1<double> ScalarData;
 
    typedef Array1<Vector2D> VectorData;
 
    ParticleSystemData2();
 
    explicit ParticleSystemData2(size_t numberOfParticles);
 
    ParticleSystemData2(const ParticleSystemData2& other);
 
    virtual ~ParticleSystemData2();
 
    void resize(size_t newNumberOfParticles);
 
    size_t numberOfParticles() const;
 
    size_t addScalarData(double initialVal = 0.0);
 
    size_t addVectorData(const Vector2D& initialVal = Vector2D());
 
    double radius() const;
 
    virtual void setRadius(double newRadius);
 
    double mass() const;
 
    virtual void setMass(double newMass);
 
    ConstArrayAccessor1<Vector2D> positions() const;
 
    ArrayAccessor1<Vector2D> positions();
 
    ConstArrayAccessor1<Vector2D> velocities() const;
 
    ArrayAccessor1<Vector2D> velocities();
 
    ConstArrayAccessor1<Vector2D> forces() const;
 
    ArrayAccessor1<Vector2D> forces();
 
    ConstArrayAccessor1<double> scalarDataAt(size_t idx) const;
 
    ArrayAccessor1<double> scalarDataAt(size_t idx);
 
    ConstArrayAccessor1<Vector2D> vectorDataAt(size_t idx) const;
 
    ArrayAccessor1<Vector2D> vectorDataAt(size_t idx);
 
    void addParticle(
        const Vector2D& newPosition,
        const Vector2D& newVelocity = Vector2D(),
        const Vector2D& newForce = Vector2D());
 
    void addParticles(
        const ConstArrayAccessor1<Vector2D>& newPositions,
        const ConstArrayAccessor1<Vector2D>& newVelocities
            = ConstArrayAccessor1<Vector2D>(),
        const ConstArrayAccessor1<Vector2D>& newForces
            = ConstArrayAccessor1<Vector2D>());
 
    const PointNeighborSearcher2Ptr& neighborSearcher() const;
 
    void setNeighborSearcher(
        const PointNeighborSearcher2Ptr& 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 ParticleSystemData2& other);
 
    ParticleSystemData2& operator=(const ParticleSystemData2& other);
 
 protected:
    void serializeParticleSystemData(
        flatbuffers::FlatBufferBuilder* builder,
        flatbuffers::Offset<fbs::ParticleSystemData2>* fbsParticleSystemData)
        const;
 
    void deserializeParticleSystemData(
        const fbs::ParticleSystemData2* 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;
 
    PointNeighborSearcher2Ptr _neighborSearcher;
    std::vector<std::vector<size_t>> _neighborLists;
};
 
typedef std::shared_ptr<ParticleSystemData2> ParticleSystemData2Ptr;
 
}  // namespace jet
 
#endif  // INCLUDE_JET_PARTICLE_SYSTEM_DATA2_H_