SupergridCable.h

#pragma once
 
#include "SupergridLineStructure.h"
#include "CollisionManager.h"
 
namespace CoRiBoDynamics {
 
namespace Structures {
    class DiscreteCylinderElement;
 
 
    /*
        Line segment implementation with cylinder elements with hydrodynamical forces
    */
    class CableSegment : public LineSegment 
    {
        friend class DiscreteCylinderElement;
    public:
        CableSegment(cable_spec spec, Environment_Interface* environment, double beta, double length, int num_elements, int sub_division);
        virtual void XmlInfo(TiXmlElement& xml_node);
 
        virtual std::string GetSegmentTypeName();
 
        Environment_Interface* GetEnvironment();
 
        vec6 DiagonalInertia(double length);
        vec6 AddedMassDiagonalInertia(double length);
 
        void SetDisplacementArea(double displacement_area);
 
        double Beta(){return m_beta;}
 
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    protected:
 
        Environment_Interface* m_environment;
        //double m_length_3;
        //double m_diameter_3;
        double m_beta;
 
        vec6 m_DiagonalInertia;
        vec6 m_AddedMassDiagonalInertia;
    };
 
class DiscreteCylinderElement : public DiscreteElement 
{
public:
    DiscreteCylinderElement(CableSegment* line_segment, double length);
    ~DiscreteCylinderElement();
    
    virtual void Setup(double T, const double * const X, mat6& InertiaMatrix, vec6& Force);
 
    virtual void SplitElement(int N);
 
    void SetDisplacementArea(double displacement_area);
protected:
    double m_buoyancy_volume;
};
 
 
 
 
class PointRetractableCable : public SupergridLineStructure {
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    PointRetractableCable(ConstraintSolver* solver, ISimObjectCreator* creator, Environment_Interface* environment, int rigid_element_buffer_size, double beta, std::string name);
 
    virtual void SetRetractedLength(double retracted_length, double retraction_speed);
    double GetRetractedLength(){return m_retracted_length;}
    double GetRetractionSpeed(){return m_retraction_speed;}
 
    vec3 GetCableUpperEndPosition();
    vec3 GetCableLowerEndPosition();
 
    virtual void AllocateElementBuffer(const double T, double* const X);
 
    virtual void InitialConditionSetup(const double T, double* const updatedIC, const vec3& PA, const vec3& PB, double initial_retracted_length);
 
    /*
        Extends SuperGridLineStructure with endpoint connections at both sides to either a controlled point or element.
        "Second element straightening" to prepare for element deactivation when winching.
        "sub-element straightening" to prepare for super element merging when winching.
    */
    virtual void ComputeConstraints(const double T, const double * const X); 
 
    void SetEndpointPositionA(const vec3& position, const vec3& velocity, double connection_strength = 1.0);
    void SetEndpointPositionB(const vec3& position, const vec3& velocity, double connection_strength = 1.0);
    void SetEndpointElementConnectionA(RigidElement* connection_element, double element_connection_strength = 1.0);
    void SetEndpointElementConnectionB(RigidElement* connection_element, double element_connection_strength = 1.0);
    void SetEndpointElementConnectionA(RigidElement* connection_element, const vec3& ConnectionVector, double element_connection_strength = 1.0);
    void SetEndpointElementConnectionB(RigidElement* connection_element, const vec3& ConnectionVector, double element_connection_strength = 1.0);
 
#ifdef FH_VISUALIZATION
    virtual void RenderUpdate(const double T, const double* const X);
#endif
 
    vec3 GetEndpointReactionForceA();
    vec3 GetEndpointA();
 
    vec3 GetEndpointReactionForceB();
    vec3 GetEndpointB();
 
    vec3 GetElementConnectionForceA(){return m_element_connectionA.ReactionForce.segment<3>(0);}
    vec3 GetElementConnectionForceB(){return m_element_connectionB.ReactionForce.segment<3>(0);}
 
    DiscreteElement* GetDiscreteElementA(); 
    DiscreteElement* GetDiscreteElementB(); 
 
    virtual void XmlInfo(TiXmlElement& xml_node);
 
 
    virtual void AddSegment(LineSegment* l);
 
 
protected:
    /*
    For the current retracted length, what is the index of the super and sub element that are in active simulation.
    Recomputes m_retracted_element_length and m_residual_length
    */
    void NumRetractedElements(size_t &super_element_ix, size_t &sub_element_ix);
 
    double m_retracted_length; 
    double m_retraction_speed; 
    double m_max_retraction_length;
 
    size_t m_num_retracted_super; 
    size_t m_num_retracted_sub; 
    size_t m_sub_super_threshold_ix; 
    size_t m_num_free_rigid_elements; 
    size_t m_minimum_sub_super_treshold; 
    double m_sub_super_threshold_strength; 
 
    double m_residual_length; 
    double m_retracted_element_length; 
 
    RigidElement* m_connection_elementA;
    RigidElement* m_connection_elementB;
    double m_element_connection_strengthA;
    double m_element_connection_strengthB;
    vec3 m_connection_vector_elementA;
    vec3 m_connection_vector_elementB;
 
    double m_endpoint_connectionA_strength;
    double m_endpoint_positionA[3];
    double m_endpoint_velocityA[3];
    ExternalBallJointCoupling m_endpoint_connectionA;
    double m_endpoint_connectionB_strength;
    double m_endpoint_positionB[3];
    double m_endpoint_velocityB[3];
    ExternalBallJointCoupling m_endpoint_connectionB;
 
    RigidCoupling m_element_connectionA;
    RigidCoupling m_element_connectionB;
};
 
 
/*
    Contact detection between cable elements in a SupergridLineStructure. 
*/
class SupergridCableCollisionManager : public CollisionManager{
public:
    SupergridCableCollisionManager(ConstraintSolver* solver, SupergridLineStructure* cable, double timeConstant);
 
    /*
        Contact detection between cable elements. Skips contact between consecutive elements.
    */
    virtual void ComputeConstraints(const double T, const double * const X);
 
protected:
    SupergridLineStructure* m_cable;
};
 
} 
}