TAPsSpringRef.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsSpringRef.hpp

SpringRef class is a class for creating a spring connecting between two 
ParticleRef objects (refer to TAPsParticleRef.hpp).
It needs to know (ref) the address of the particles.

SUKITTI PUNAK   (02/24/2006)
UPDATE          (03/01/2006)
******************************************************************************/
#ifndef TAPs_SPRING_REF_HPP
#define TAPs_SPRING_REF_HPP

#include "TAPsParticleRef.hpp"

BEGIN_NAMESPACE_TAPs
template <typename T>
class SpringRef {
//=============================================================================
    //-------------------------------------------------------------------------
    // put it through ostream
    friend std::ostream &operator<< ( std::ostream &output, SpringRef<T> const &S )
    {
        output  << "Spring<" << typeid(T).name() << "> ==> "
                << "\n  -------START--SPRING_VERTEX--INFO-------"
                << "\n  Particle#1: " << *(S.m_refP1)
                << "\n  Particle#2: " << *(S.m_refP2)
                << "\n  K Constant: " << S.m_tK
                << "\n  D Damping:  " << S.m_tD
                << "\n  L Length:   " << S.m_tL
                << "\n  Force#1:      " << S.GetForce1()
                << "\n  Force#2:      " << S.GetForce2()
                << "\n  Current Length: " << S.GetCurrentLength()
                << "\n  --------END--SPRING_VERTEX--INFO--------\n";
        return output;
    }
//-----------------------------------------------------------------------------
private:
    // Data Members     ========================================================
    ParticleRef<T> *    m_refP1;    // reference to connected ParticleRef #1
    ParticleRef<T> *    m_refP2;    // reference to connected ParticleRef #2
    T                   m_tK;       // tensile spring constant (K)
    T                   m_tD;       // damping factor (D)
    T                   m_tL;       // rest length of spring (L)
    //------------------------------------------------------
    int                 m_iNumHops; // number of hops on mesh
    //-------------------------------------------------------------------------
public:
    // Member Functions     ====================================================
    SpringRef (             // The rest length is calculated
        ParticleRef<T> & P1, 
        ParticleRef<T> & P2, 
        T k, T d, 
        int hops = 1 );     // Constructor
    //----------------------------------------------------------------
    SpringRef (             // The rest length is given
        ParticleRef<T> & P1, 
        ParticleRef<T> & P2, 
        T k, T d, T l, 
        int hops = 1 );     // Constructor
    //----------------------------------------------------------------
    ~SpringRef ();          // Destructor
    //-------------------------------------------------------------------------
    // Calculate and Return the (Internal) Force of a Spring
    Vector3<T>  GetForce1 () const;
    Vector3<T>  GetForce2 () const;
    void        GetForce ( Vector3<T> & F1, Vector3<T> & F2 ) const;
    void        CalAndSetForce ();
    //-------------------------------------------------------------------------
    // Get/Set Functions
    // REMARK: No const for Particle<T> & and const after the get fns
    //         so that the return ref can be modified.
    inline ParticleRef<T> & GetParticleOne ();
    inline ParticleRef<T> & GetParticleTwo ();
    inline ParticleRef<T> const & GetParticleOne () const;
    inline ParticleRef<T> const & GetParticleTwo () const;
    inline T    GetConstantK ()     const;
    inline T    GetDampingD ()      const;
    inline T    GetRestLengthL ()   const;
    inline T    GetCurrentLength () const;
    inline void SetConstantK    ( T Ks );
    inline void SetDampingD     ( T Kd );
    inline void SetRestLengthL  ( T length );
    //-------------------------------------------------------------------------
    //==========================================================================
    // Create Spring Connections for Mesh (Vertex, XVertex, HalfEdge)
    // All O/P pointers must be null pointers!
    // To avoid memory leak, the O/P pointers must be "delete []" by user.
    //--------------------------------------------
    // Create Spring Connections for Mesh Vertex
    static void SpringsCreation ( 
        Vertex<T> *      meshVertex, // I/P: Mesh Vertex
        int *            vertexNo,   // O/P: vertex# associates Mesh Vertex w/ Spring#
        ParticleRef<T> * particleNo, // O/P: particle#
        T                mass,       // I/P: mass for each particle
        SpringRef<T> *   springNo,   // O/P: Spring#
        T Ks, T Kd,                  // I/P: Spring Stiffness and Damping Constant
        int hopDistance = 1          // I/P: Number of distance/rigidity for spring connection
    );
    //--------------------------------------------
    // Create Spring Connections for Mesh XVertex
    static void SpringsCreation ( 
        XVertex<T> *     meshVertex, // I/P: Mesh XVertex
        int *            vertexNo,   // O/P: vertex# associates Mesh XVertex w/ Spring#
        ParticleRef<T> * particleNo, // O/P: particle#
        T                mass,       // I/P: mass for each particle
        SpringRef<T> *   springNo,   // O/P: Spring#
        T Ks, T Kd,                  // I/P: Spring Stiffness and Damping Constant
        int hopDistance = 1          // I/P: Number of distance/rigidity for spring connection
    );
    //--------------------------------------------
    // Create Spring Connections for Mesh HEVertex
    static void SpringsCreation ( 
        HEVertexList<T> * meshVertex, // I/P: Mesh HEVertex
        std::list<int>  & vertexNo,  // O/P: vertex# associates Mesh HEVertex w/ Spring#
        std::list< ParticleRef<T> > & particleList, // O/P: Particle List
        T                 mass,       // I/P: mass for each particle
        std::list< SpringRef<T> >   & springNo,   // O/P: Spring List
        T Ks, T Kd,                   // I/P: Spring Stiffness and Damping Constant
        int hopDistance = 1           // I/P: Number of distance/rigidity for spring connection
    );
private:
    //static void SpringCreation
    //-------------------------------------------------------------------------
private:
    // Member Functions -------------------------------------------------------
    // Prohibited Functions ===================================================
    // Since a spring refers to two particles, therefore
    // Copy Constructor and Assignment Operator are prohibited.
    SpringRef<T> const & operator= ( SpringRef<T> const &S )    // assignment operator
    {
        std::cerr << "SpringRef<T> operator= must not be used!\n";
        exit( 1 );
    }
    // Data Members -----------------------------------------------------------
    //=========================================================================
#if defined(__gl_h_) || defined(__GL_H__)
public:
    // DrawByOpenGL
    virtual void DrawByOpenGL () const;
    virtual inline void DrawByOpenGL ( int hopNumber ) const;
    virtual inline void DrawByOpenGL ( int startHopNumber, int endHopNumber ) const;
#endif
    //-------------------------------------------------------------------------
}; // END CLASS SpringRef
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsSpringRef.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8