TAPsSpringRef.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsSpringRef.cpp

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

SUKITTI PUNAK   (02/24/2006)
UPDATE          (03/01/2006)
******************************************************************************/
#include "TAPsSpringRef.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
// SpringRef Constructor
template <typename T>
SpringRef<T>::SpringRef
(
    ParticleRef<T> & P1, 
    ParticleRef<T> & P2, 
    T k, T d, T l, 
    int hops 
)   : 
    m_refP1( &P1 ), 
    m_refP2( &P2 ), 
    m_tK( k ), 
    m_tD( d ), 
    m_tL( l ), 
    m_iNumHops( hops )
{}
//-----------------------------------------------------------------------------
// SpringRef Constructor
template <typename T>
SpringRef<T>::SpringRef
(
    ParticleRef<T> & P1, 
    ParticleRef<T> & P2, 
    T k, T d, 
    int hops 
)   : 
    m_refP1( &P1 ), 
    m_refP2( &P2 ), 
    m_tK( k ), 
    m_tD( d ), 
    m_iNumHops( hops )
{
    T x = P2.GetPosition().GetX() - P1.GetPosition().GetX();
    T y = P2.GetPosition().GetY() - P1.GetPosition().GetY();
    T z = P2.GetPosition().GetZ() - P1.GetPosition().GetZ();
    m_tL = sqrt( x*x + y*y + z*z );
}
//-----------------------------------------------------------------------------
// SpringRef Destructor
template <typename T>
SpringRef<T>::~SpringRef()
{}
//-----------------------------------------------------------------------------
//=============================================================================
// Calculate and Return the (Internal) Force of a Spring
//-----------------------------------------------------------------------------
template <typename T>
Vector3<T> SpringRef<T>::GetForce1() const
{

    std::cout << "OBSOLETED: GetForce1() should not be called" << std::endl;
    exit( 1 );

    // Not Home Spring
    if ( m_iNumHops > 0 ) {
        // Local Variables ------------------------------------------
        // spring current length vector
        Vector3<T> cL = ( m_refP1->GetPosition() - m_refP2->GetPosition() );
        // spring current length scalar
        T scl = cL.Length();
        cL /= scl;  // normalize the length vector
        // velocity difference of the two particles linked by the spring
        Vector3<T> V = ( m_refP1->GetVelocity() - m_refP2->GetVelocity() );
        //-----------------------------------------------------------
        // Formula from Physically Based Modeling (Siggraph 2001 Course Note)
        // F1 = -{Ks(l - r) + Kd[(V1-V2)*L]/l}*L/l
        // F2 = -F1
        //   where Ks = spring stiffness, Kd = spring damping,
        //     V1 and V2 are velocity of particles linked by the spring
        //     r = spring rest length
        //     L = vector of difference of positions of particle#1 and #2
        //     l = magnitude of L
        return ( ( m_tK * (scl - m_tL) ) + ( m_tD * V * cL ) ) * cL;
    }
    // Home Spring
    else {
        // Local Variables ------------------------------------------
        // spring current length vector
        Vector3<T> cL = ( m_refP1->GetPosition() - m_refP2->GetPosition() );
        // spring current length scalar
        T scl = cL.Length();
        if ( scl == TAPs::Math<T>::ZERO ) return TAPs::CGMath<T>::ZeroVector;
        cL /= scl;  // normalize the length vector
        // velocity difference of the two particles linked by the spring
        Vector3<T> V = ( m_refP1->GetVelocity() - m_refP2->GetVelocity() );
        //-----------------------------------------------------------
        // Formula from Physically Based Modeling (Siggraph 2001 Course Note)
        // F1 = -{Ks(l - r) + Kd[(V1-V2)*L]/l}*L/l
        // F2 = -F1
        //   where Ks = spring stiffness, Kd = spring damping,
        //     V1 and V2 are velocity of particles linked by the spring
        //     r = spring rest length
        //     L = vector of difference of positions of particle#1 and #2
        //     l = magnitude of L
        //return ( ( m_tK * (scl - m_tL) ) + ( m_tD * V * cL ) ) * cL;
        return ( ( m_tK * scl ) + ( m_tD * V * cL ) ) * cL; // since m_tL is zero
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
// Calculate and Return the (Internal) Force of a Spring
//-----------------------------------------------------------------------------
template <typename T>
Vector3<T> SpringRef<T>::GetForce2() const
{
    // Not Home Spring
    if ( m_iNumHops > 0 ) {
        // Local Variables ------------------------------------------
        // spring current length vector
        Vector3<T> cL = ( m_refP1->GetPosition() - m_refP2->GetPosition() );
        // spring current length scalar
        T scl = cL.Length();
        cL /= scl;  // normalize the length vector
        // velocity difference of the two particles linked by the spring
        Vector3<T> V = ( m_refP1->GetVelocity() - m_refP2->GetVelocity() );
        //-----------------------------------------------------------
        // Formula from Physically Based Modeling (Siggraph 2001 Course Note)
        // F1 = -{Ks(l - r) + Kd[(V1-V2)*L]/l}*L/l
        // F2 = -F1
        //   where Ks = spring stiffness, Kd = spring damping,
        //     V1 and V2 are velocity of particles linked by the spring
        //     r = spring rest length
        //     L = vector of difference of positions of particle#1 and #2
        //     l = magnitude of L
        return ( ( m_tK * (scl - m_tL) ) + ( m_tD * V * cL ) ) * cL;
    }
    // Home Spring
    else {
        // Local Variables ------------------------------------------
        // spring current length vector
        Vector3<T> cL = ( m_refP1->GetPosition() - m_refP2->GetPosition() );
        // spring current length scalar
        T scl = cL.Length();
        if ( scl == TAPs::Math<T>::ZERO ) return TAPs::CGMath<T>::ZeroVector;
        cL /= scl;  // normalize the length vector
        // velocity difference of the two particles linked by the spring
        Vector3<T> V = ( m_refP1->GetVelocity() - m_refP2->GetVelocity() );
        //-----------------------------------------------------------
        // Formula from Physically Based Modeling (Siggraph 2001 Course Note)
        // F1 = -{Ks(l - r) + Kd[(V1-V2)*L]/l}*L/l
        // F2 = -F1
        //   where Ks = spring stiffness, Kd = spring damping,
        //     V1 and V2 are velocity of particles linked by the spring
        //     r = spring rest length
        //     L = vector of difference of positions of particle#1 and #2
        //     l = magnitude of L
        //return ( ( m_tK * (scl - m_tL) ) + ( m_tD * V * cL ) ) * cL;
        return ( ( m_tK * scl ) + ( m_tD * V * cL ) ) * cL; // since m_tL is zero
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
// Calculate and Return the (Internal) Force of a Spring
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::GetForce( Vector3<T> & F1, Vector3<T> & F2 ) const
{
    F2 = GetForce2();
    F1 = -F2;
}
//=============================================================================
// Calculate and Return the (Internal) Force of a Spring
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::CalAndSetForce()
{
    Vector3<T> F2 = GetForce2();
    if ( m_refP2->GetFixStatus() ) {
        m_refP2->SetVelocity( 0, 0, 0 );
        m_refP2->SetForce( 0, 0 , 0 );
    }
    else {
        m_refP2->SetForce( m_refP2->GetForce() + F2 );
    }
    if ( m_refP1->GetFixStatus() ) {
        m_refP1->SetVelocity( 0, 0, 0 );
        m_refP1->SetForce( 0, 0 , 0 );
    }
    else {
        m_refP1->SetForce( m_refP1->GetForce() - F2 );
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
// Get/Set Functions
//-----------------------------------------------------------------------------
// Get Particle #1
template <typename T>
inline ParticleRef<T> & SpringRef<T>::GetParticleOne ()
{   return *m_refP1;    }
//-----------------------------------------------------------------------------
// Get Particle #2
template <typename T>
inline ParticleRef<T> & SpringRef<T>::GetParticleTwo ()
{   return *m_refP2;    }
//-----------------------------------------------------------------------------
// Get Particle #1
template <typename T>
inline ParticleRef<T> const & SpringRef<T>::GetParticleOne () const
{   return *m_refP1;    }
//-----------------------------------------------------------------------------
// Get Particle #2
template <typename T>
inline ParticleRef<T> const & SpringRef<T>::GetParticleTwo () const
{   return *m_refP2;    }
//-----------------------------------------------------------------------------
// Get Constant K
template <typename T>
inline T SpringRef<T>::GetConstantK () const
{   return m_tK;    }
//-----------------------------------------------------------------------------
// Get Damping D
template <typename T>
inline T SpringRef<T>::GetDampingD () const
{   return m_tD;    }
//-----------------------------------------------------------------------------
// Get Rest Length L
template <typename T>
inline T SpringRef<T>::GetRestLengthL () const
{   return m_tL;    }
//-----------------------------------------------------------------------------
// Get Current Length
template <typename T>
inline T SpringRef<T>::GetCurrentLength () const
{   return ( m_refP1->GetPosition() - m_refP2->GetPosition() ).Length();    }
//-----------------------------------------------------------------------------
// Set Constant K
template <typename T>
inline void SpringRef<T>::SetConstantK ( T Ks )
{   m_tK = Ks;  }
//-----------------------------------------------------------------------------
// Set Damping D
template <typename T>
inline void SpringRef<T>::SetDampingD ( T Kd )
{   m_tD = Kd;  }
//-----------------------------------------------------------------------------
// Set Rest Length L
template <typename T>
inline void SpringRef<T>::SetRestLengthL ( T length )
{   m_tL = length;  }
//-----------------------------------------------------------------------------
//=============================================================================
// Spring Creations (Static Functions)
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::SpringsCreation (
        HEVertexList<T> * meshVertex, // I/P: Mesh XVertex
        std::list<int>  & vertexNo,   // O/P: vertex# associates Mesh XVertex 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               // I/P: Number of distance/rigidity for spring connection
)
{
    if ( !meshVertex )  return;
    //----------------------------------------------------------------
    HEVertex<T> * vertex = meshVertex.Head();
    //----------------------------------------------------------------
    vertexNo.clear();
    for ( int i = 0; i < meshVertex.Size(); ++i ) {
    //  vertex = 
    }
    //----------------------------------------------------------------
    //----------------------------------------------------------------
    //----------------------------------------------------------------
}
//-----------------------------------------------------------------------------
//=============================================================================

//-----------------------------------------------------------------------------
#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::DrawByOpenGL () const
{
    glPushAttrib( GL_CURRENT_BIT | GL_LIGHTING_BIT );
    glPushMatrix();
    //----------------------------------------------------------------
    glDisable( GL_LIGHTING );
    glPointSize( 3 );
    glLineWidth( 1 );
    //----------------------------------------------------------
    // Draw Points
    glBegin( GL_POINTS );
        glColor3f( 1, 1, 0 );
        glVertex3f( static_cast<GLfloat>(GetParticleOne().GetPosition()[0]), 
                    static_cast<GLfloat>(GetParticleOne().GetPosition()[1]), 
                    static_cast<GLfloat>(GetParticleOne().GetPosition()[2]) );
        glColor3f( 0, 1, 1 );
        glVertex3f( static_cast<GLfloat>(GetParticleTwo().GetPosition()[0]), 
                    static_cast<GLfloat>(GetParticleTwo().GetPosition()[1]), 
                    static_cast<GLfloat>(GetParticleTwo().GetPosition()[2]) );
    glEnd();
    //----------------------------------------------------------
    // Draw Lines
    glBegin( GL_LINES );
        if ( m_iNumHops > 0 )
            glColor3f( 1, 0.5f/m_iNumHops, 1 );
        else
            glColor3f( 1, 1, 1 );
        glVertex3f( static_cast<GLfloat>(GetParticleOne().GetPosition()[0]), 
                    static_cast<GLfloat>(GetParticleOne().GetPosition()[1]), 
                    static_cast<GLfloat>(GetParticleOne().GetPosition()[2]) );
        glVertex3f( static_cast<GLfloat>(GetParticleTwo().GetPosition()[0]), 
                    static_cast<GLfloat>(GetParticleTwo().GetPosition()[1]), 
                    static_cast<GLfloat>(GetParticleTwo().GetPosition()[2]) );
    glEnd();
    //----------------------------------------------------------------
    glPopMatrix();
    glPopAttrib();
}
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::DrawByOpenGL ( int hopNumber ) const
{
    if ( hopNumber == m_iNumHops ) {
        DrawByOpenGL();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void SpringRef<T>::DrawByOpenGL ( int startHopNumber, int endHopNumber ) const
{
    if ( startHopNumber <= m_iNumHops && m_iNumHops <= endHopNumber ) {
        DrawByOpenGL();
    }
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8