SupergridLineStructure.h

#pragma once
 
#include "JointConstraint.h"
#include "CollisionManager.h"
#include <SimObject.h>
#include <tinyxml.h>
#include <vector>
 
#ifdef FH_VISUALIZATION
#include <sfh/ogre/C3DLine.h>
#endif
 
namespace CoRiBoDynamics {
 
    class Environment_Interface{
    public:
        virtual ~Environment_Interface(){};
        virtual vec3    Current     (double T, const double* X, const double* Position) = 0;
        virtual double  OceanSurfaceElevation(double T, const double* X, const double* Position) = 0;
        virtual void CurrentQuery(double T, const double* X, const vec3& Position, vec3& current, double& surface_elevation, double& density) = 0;
        virtual double  SeaDepth    (const double* Position) = 0;
    };
 
namespace Structures {
    class DiscreteElement;
    class LineSegment;
    class CableSegment;
    class SupergridLineStructure;
 
 
static const mat6 Identity_memory = mat6::Identity();
class ModifiableRigidElement: public RigidElement {
 
public:
    ModifiableRigidElement(int ix_P, int ix_Q, int ix_V, int ix_W);
    void SetDiscreteElement(DiscreteElement* discrete_element){m_discrete_element = discrete_element;}
 
    DiscreteElement* GetDiscreteElement();
 
    virtual void Setup(double T, const double * const X);
    virtual const mat6& InertialMatrix();
    virtual const vec6& Forces();
 
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
protected:
    DiscreteElement* m_discrete_element;
 
    mat6 m_FullInertiaMatrix;
    vec6 m_Force;
};
 
class DiscreteElement {
public:
    DiscreteElement(LineSegment* line_segment, double length);
 
    virtual ~DiscreteElement();
 
    ModifiableRigidElement* GetRigidElement();
 
    const std::vector<DiscreteElement*>* GetSubElements();
 
    DiscreteElement* GetSuperElement();
 
    LineSegment* GetLineSegment();
 
 
    void SetRigidElement(ModifiableRigidElement* rigid_element);
    virtual void Setup(double T, const double * const X, mat6& InertiaMatrix, vec6& Force) = 0;
 
    double GetElementLength();
    double GetElementRadius();
    double GetElementMass();
 
 
    struct TempStates{
        Quat Q;
        vec3 P;
        vec3 V;
        vec3 W;
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    };
 
    /*
        Copy current states from the currently bound rigid element into the discrete object. State values are stored in a buffer from temp_states_buffer.
    */
    virtual void StoreTempStates(const double* X, ObjectFactoryStack<DiscreteElement::TempStates>& temp_states_buffer);
 
    /*
        Set the given states to the discrete object. State values are stored in a buffer from temp_states_buffer.
    */
    virtual void SetTempStates(const vec3& P,const Quat& Q, const vec3& V, const vec3& W, ObjectFactoryStack<DiscreteElement::TempStates>& temp_states_buffer);
 
    /*
        Divide the states of this discrete elements into its sub-elements
        'next' and 'prev' are optional parameters.
        they refer to the next and previous element in the chain, and are used to initialize the distance between sub elements so initial tension is correct
        State values are stored in a buffer from temp_states_buffer.
    */
    virtual void SplitTempStates(DiscreteElement* prev, DiscreteElement* next, ObjectFactoryStack<DiscreteElement::TempStates>& temp_states_buffer);
 
    /*
        Gather an 'average' state from all sub elements into the super element.
        State values are stored in a buffer from temp_states_buffer.
    */
    virtual void CollectTempStates(ObjectFactoryStack<DiscreteElement::TempStates>& temp_states_buffer);
 
    /*
        Overwrite the state vector with previously stored values.
        The state vector index is given by the currently bound rigid element
    */
    virtual void OverrideStates(double T, double * X);
 
    /*
        retrieve currently stored state values
    */
    virtual void GetTempStates( vec3& P, Quat& Q, vec3& V, vec3& W);
 
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
 
protected:
    ModifiableRigidElement* m_rigid_element;
    LineSegment* m_line_segment;
    DiscreteElement* m_super_element;
    std::vector<DiscreteElement*> m_sub_element;
    TempStates* m_temp_states;
    float m_length;
    float m_radius;
    float m_mass;
};
 
 
/*
    Discrete line segment with uniform material parameters.
    A LineSegment is subdivided into DiscreteElements.
*/
class LineSegment {
public:
    struct cable_spec {
        double D; 
        double W; 
        double EA; 
        double EI; 
        double Stabilizer;
        cable_spec (){}
        cable_spec (double Diameter, double rho, double E);
    };
 
 
    LineSegment(cable_spec spec, double segment_length);
 
    virtual ~LineSegment();
 
    const std::vector<DiscreteElement*>* GetDiscreteElements();
 
 
    const cable_spec& GetCableSpecification();
    double GetAxialStiffness(){return m_cable_spec.EA;}
    double GetBendingStiffness(){return m_cable_spec.EI;}
    double GetStabilizer(){return m_cable_spec.Stabilizer;}
 
    double GetSegmentLength();
    double GetCableStartPosition();
    int GetCableIndex();
 
    CollisionManager::MaterialCharacteristic GetMaterialCharacteristic(){return m_material_characteristics;}
 
    virtual void XmlInfo(TiXmlElement& xml_node);
    virtual std::string GetSegmentTypeName() = 0;
 
#ifdef FH_VISUALIZATION
    std::string Material(){return m_material;}
    double GetMaxTension(){return m_max_tension;}
    void SetMaxTension(double max_tension){m_max_tension = max_tension;}
#endif
 
    virtual void SetLineStructure(SupergridLineStructure* linestructure);
protected:
    cable_spec m_cable_spec;
    double m_length;
    double m_line_structure_start_length; 
    int m_line_structure_ix;
    CollisionManager::MaterialCharacteristic m_material_characteristics;
 
    SupergridLineStructure* m_line_structure;
    std::vector<DiscreteElement*> m_discrete_element;
 
#ifdef FH_VISUALIZATION
    double m_max_tension;
    std::string m_material;
#endif
};
 
 
class SupergridLineStructure : public JointConstraint  {
    friend class LineSegment;
public:
    virtual void AddSegment(LineSegment* l);
 
    const std::vector<DiscreteElement*>* GetDiscreteElements();
 
    const std::vector<ModifiableRigidElement*>* GetRigidElements();
 
    const std::vector<double>* GetRigidElementTension();
 
    const std::vector<LineSegment*>* GetLineSegments();
 
    double GetLength();
 
 
    SupergridLineStructure(ConstraintSolver* solver, ISimObjectCreator* creator, Environment_Interface* environment, int rigid_element_buffer_size, double beta, std::string name);
 
    virtual ~SupergridLineStructure();
 
    virtual void XmlInfo(TiXmlElement& xml_node);
 
    virtual void ComputeConstraints(const double T, const double * const X); 
 
#ifdef FH_VISUALIZATION
    virtual void RenderInit(Ogre::Root* const ogreRoot);
    virtual void RenderUpdate(const double T, const double* const X);
    void UpdateData(const double* const X);
    virtual Ogre::ColourValue Color(size_t ix);
    void SetHQ_Render(bool HQ_render){m_HQ_render = HQ_render;}
    static double log_scale(const double max_limit, double x);
    static Ogre::ColourValue RYGCBM(double f);
#endif
 
    double GetBeta();
    Environment_Interface* GetEnvironment();
 
 
protected:
    double m_length;
    double m_beta;
    Environment_Interface* m_environment;
    std::vector<ModifiableRigidElement*> m_rigid_element_buffer;
    std::vector<LineSegment*> m_segment;
    std::vector<DiscreteElement*> m_super_element;
    std::vector<double> m_rigid_element_tension;
    std::string m_name;
 
#ifdef FH_VISUALIZATION
    C3DLine* m_line;
    std::vector<Ogre::SceneNode*> m_nodes;
    bool m_HQ_render;
    int m_colour_counter;
#endif
};
 
} 
}