SpringHalfEdgeModel< T > Class Template Reference

#include <TAPsSpringHalfEdgeModel.hpp>

Inheritance diagram for SpringHalfEdgeModel< T >:

[legend]

Collaboration diagram for SpringHalfEdgeModel< T >:

[legend]

List of all members.

Public Member Functions
virtual void	AdvanceSimulation (MATH::SimClock< T > &simClock)
virtual void	AdvanceSimulation (T tCurrent, T tNext)
void	CreateMeshSprings (int rigidity=1, T mass=1, T Ks=1, T Kd=1)
T	GetKDamper () const
T	GetKPointMass () const
T	GetKStiffness () const
int	GetRigidity () const
virtual void	Initialize ()
void	SetKDamper (T val)
void	SetKPointMass (T val)
void	SetKStiffness (T val)
	SpringHalfEdgeModel ()
virtual	~SpringHalfEdgeModel ()
Protected Member Functions
void	ArrayToState (T *src)
void	BFSCreateSprings (T Ks, T Kd, int rigidity, int p1, int p2, std::vector< int > &particleSet, bool *isMark)
void	ChangeConstantDampingOfAllSprings (T val)
void	ChangeConstantStiffnessOfAllSprings (T val)
void	ChangeMassOfAllPoints (T val)
bool	CheckASpringExistance (int p1, int p2)
void	ClearAllForces ()
void	CreateASpring (T Ks, T Kd, int p1, int p2, int hops)
void	CreateSprings (T Ks, T Kd, int rigidity=1)
void	DdtStateToArray (T *xdot, T dt)
void	DeleteAllData ()
void	PrepareData ()
void	SetListOf1RingVertices ()
void	SetMassOfParticles (T mass)
void	StateToArray (T *dst)
Static Protected Member Functions
static bool	DxDt (T dt, MATH::VectorSet< T > &x, MATH::VectorSet< T > &xdot, void *userData)
Protected Attributes
int	m_iLimitStepCount
int	m_iRigidity
int	m_iStateSize
MATH::ODESolver< T > *	m_prODESolver
std::vector< int > *	m_pviListConnectedVertex
std::vector< int > *	m_pviListSpring
std::vector< int > *	m_pviListVertexRing1
T	m_tKDamper
T	m_tKStiffness
T	m_tPtMass
std::vector< HEVertex< T > * >	m_vpHEVertex
std::vector< ParticleRef< T > * >	m_vpParticleRef
std::vector< SpringRef< T > * >	m_vpSpringRef
MATH::VectorSet< T > *	x0
MATH::VectorSet< T >	xData_1
MATH::VectorSet< T >	xData_2
MATH::VectorSet< T > *	xEnd
Friends
std::ostream &	operator<< (std::ostream &output, SpringHalfEdgeModel< T > const &o)

---

Detailed Description

template<typename T>
class SpringHalfEdgeModel< T >

Definition at line 76 of file TAPsSpringHalfEdgeModel.hpp.

---

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs__OpenGL SpringHalfEdgeModel< T >::SpringHalfEdgeModel

(

)

[inline]

Definition at line 21 of file TAPsSpringHalfEdgeModel.cpp.

    : HalfEdgeModel<T>(), 
      m_pviListVertexRing1( NULL ), 
      m_pviListConnectedVertex( NULL ), 
      m_pviListSpring( NULL ), 
      m_iRigidity( 1 ), 
      m_tPtMass( 1 ), 
      m_tKStiffness( 1 ), 
      m_tKDamper( 1 ) 
{
    //----------------------------------------------------------------
    //std::cout << "Number of Vertex: " << GetNoVertices();
    //std::cout << "Number of Vertex: " << GetNoVertices();
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "SpringHalfEdgeModel<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_ENABLE_DEBUG
}

template<typename T>

SpringHalfEdgeModel< T >::~SpringHalfEdgeModel

(

)

[inline, virtual]

Definition at line 41 of file TAPsSpringHalfEdgeModel.cpp.

{
    DeleteAllData();
    //----------------------------------------------------------------
    // For simulation
    delete m_prODESolver;
    //----------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "SpringHalfEdgeModel<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_ENABLE_DEBUG
}

---

Member Function Documentation

template<typename T>

void SpringHalfEdgeModel< T >::AdvanceSimulation

(

MATH::SimClock< T > &

simClock

)

[inline, virtual]

Reimplemented from PhysicsSupport< T >.

Definition at line 415 of file TAPsSpringHalfEdgeModel.cpp.

{
    std::cout << "SpringHalfEdgeModel<T>::AdvanceSimulation ( MATH::SimClock<T> & simClock ) -- NOT IMPLEMENTED YET!!!\n";
}

template<typename T>

void SpringHalfEdgeModel< T >::AdvanceSimulation	(	T	tCurrent,
		T	tNext
	)			[inline, virtual]

Reimplemented from PhysicsSupport< T >.

Definition at line 392 of file TAPsSpringHalfEdgeModel.cpp.

{
    //-----------------------------------------------------
    // Swap pointers
    MATH::VectorSet<T> * tmpPtr = x0;
    x0   = xEnd;
    xEnd = tmpPtr;
    //------------------------------------------------------
    // ODE Solver
    m_prODESolver->Solve( *x0, *xEnd, tCurrent, tNext, DxDt, this );
    //------------------------------------------------------
    // Copy d/dt X(tNext) into state variables xEnd
    ArrayToState( &(*xEnd)[0] );
    //------------------------------------------------------
    //SimGravity( tCurrent, tNext );
    //------------------------------------------------------
    GetBVHTree()->Update();

    CalAndSetNormals();
}

template<typename T>

void SpringHalfEdgeModel< T >::ArrayToState

(

T *

src

)

[inline, protected]

Definition at line 488 of file TAPsSpringHalfEdgeModel.cpp.

{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        m_vpParticleRef[i]->SetPosition( *src, *(src+1), *(src+2) );
        src += 3;
        m_vpParticleRef[i]->SetVelocity( *src, *(src+1), *(src+2) );
        src += 3;
    }
    //*/
}

template<typename T>

void SpringHalfEdgeModel< T >::BFSCreateSprings	(	T	Ks,
		T	Kd,
		int	rigidity,
		int	p1,
		int	p2,
		std::vector< int > &	particleSet,
		bool *	isMark
	)			[inline, protected]

Definition at line 321 of file TAPsSpringHalfEdgeModel.cpp.

{
    if ( rigidity >= m_iRigidity ) return;
    //--------------------------------------------------------------------
    // Keep the particle reference in particleSet
    // And mark it as visited
    particleSet.push_back( p2 );
    isMark[ p2 ] = true;
    //--------------------------------------------------------------------
    // Traverse each edge of p1
    ++rigidity;
    int p3;
    for ( int i = 0; i < static_cast<int>( m_pviListVertexRing1[p2].size() ); ++i ) {
        p3 = m_pviListVertexRing1[p2][i];
        if ( !isMark[ p3 ] ) {
            if ( !CheckASpringExistance( p1, p3 ) ) {
                CreateASpring( Ks, Kd, p1, p3, rigidity );
            }
        }
    }
    // This makes it become Breath First Search
    for ( int i = 0; i < static_cast<int>( m_pviListVertexRing1[p2].size() ); ++i ) {
        p3 = m_pviListVertexRing1[p2][i];
        BFSCreateSprings( Ks, Kd, rigidity, p1, p3, particleSet, isMark );
    }
    //--------------------------------------------------------------------
}

template<typename T>

void SpringHalfEdgeModel< T >::ChangeConstantDampingOfAllSprings

(

T

val

)

[inline, protected]

Definition at line 146 of file TAPsSpringHalfEdgeModel.cpp.

{
    std::vector< SpringRef<T> * >::iterator pos;
    for ( pos = m_vpSpringRef.begin(); pos < m_vpSpringRef.end(); ++pos ) {
        (*pos)->SetDampingD( val );
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::ChangeConstantStiffnessOfAllSprings

(

T

val

)

[inline, protected]

Definition at line 137 of file TAPsSpringHalfEdgeModel.cpp.

{
    std::vector< SpringRef<T> * >::iterator pos;
    for ( pos = m_vpSpringRef.begin(); pos < m_vpSpringRef.end(); ++pos ) {
        (*pos)->SetConstantK( val );
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::ChangeMassOfAllPoints

(

T

val

)

[inline, protected]

Definition at line 155 of file TAPsSpringHalfEdgeModel.cpp.

{
    std::vector< ParticleRef<T> * >::iterator pos;
    for ( pos = m_vpParticleRef.begin(); pos < m_vpParticleRef.end(); ++pos ) {
        (*pos)->SetMass( val );
    }
}

template<typename T>

bool SpringHalfEdgeModel< T >::CheckASpringExistance	(	int	p1,
		int	p2
	)			[inline, protected]

Definition at line 269 of file TAPsSpringHalfEdgeModel.cpp.

{
    int size = static_cast<int>( m_pviListConnectedVertex[p1].size() );
    for ( int i = 0; i < size; ++i ) {
        if ( m_pviListConnectedVertex[p1][i] == p2 )    return true;
    }
    return false;
}

template<typename T>

void SpringHalfEdgeModel< T >::ClearAllForces

(

)

[inline, protected]

Definition at line 532 of file TAPsSpringHalfEdgeModel.cpp.

{
    for ( int i = 0; i < static_cast<int>( m_vpParticleRef.size() ); ++i ) {
        m_vpParticleRef[i]->SetForce( 0, 0, 0 );
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::CreateASpring	(	T	Ks,
		T	Kd,
		int	p1,
		int	p2,
		int	hops
	)			[inline, protected]

Definition at line 279 of file TAPsSpringHalfEdgeModel.cpp.

{
    int pos = static_cast<int>( m_vpSpringRef.size() );
    m_vpSpringRef.push_back( 
        new SpringRef<T>( 
                *(m_vpParticleRef[p1]), 
                *(m_vpParticleRef[p2]), 
                Ks, Kd, 
                hops ) );
    m_pviListConnectedVertex[p1].push_back( p2 );
    m_pviListConnectedVertex[p2].push_back( p1 );
    m_pviListSpring[p1].push_back( pos );
    m_pviListSpring[p2].push_back( pos );
    //std::cout << "# of Hops: " << hops << "\n";
    //std::cout << "Create Spring with " << hops << " hop(s)\n";
}

template<typename T>

void SpringHalfEdgeModel< T >::CreateMeshSprings	(	int	rigidity = 1,
		T	mass = 1,
		T	Ks = 1,
		T	Kd = 1
	)			[inline]

Definition at line 67 of file TAPsSpringHalfEdgeModel.cpp.

{
    PrepareData();
    //--------------------------------------------------------------------
    // For Simulation
    if ( ( m_prODESolver = new MATH::ODESolverEuler<T>() ) == NULL ) {
    //if ( ( m_prODESolver = new MATH::ODESolverMidpoint<T>() ) == NULL ) {
    //if ( ( m_prODESolver = new MATH::ODESolverRungeKutta4<T>() ) == NULL ) {
        #ifdef TAPs_ENABLE_DEBUG
        std::cerr   << "ERROR => SpringHalfEdgeModel Constructor:" 
                    << " Cannot allocate memory for an ODE solver!" 
                    << std::endl;
        #endif
        delete this;
        return;
    }
    //--------------------------------------------------------------------
    m_iStateSize = static_cast<int>( m_vpParticleRef.size() );
    m_prODESolver->SetSize( m_iStateSize * 6 );
    x0   = &xData_1;
    xEnd = &xData_2;
    x0->resize(   m_iStateSize * 6 );
    xEnd->resize( m_iStateSize * 6 );
    StateToArray( &(*xEnd)[0] );
    //--------------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
    std::cout << "++++++++++++++ --> m_iStateSize = " << m_iStateSize << "\n";
    std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
    #endif//TAPs_ENABLE_DEBUG
    //--------------------------------------------------------------------
    SetListOf1RingVertices();
    SetMassOfParticles( mass );
    CreateSprings( Ks, Kd, rigidity );  // A recursive method for creating springs

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "Spring Mesh Rigidity: " << m_iRigidity << "\n";
    std::cout << "The Total Number of Springs is " << static_cast<int>(m_vpSpringRef.size()) << "\n";
    #endif//TAPs_ENABLE_DEBUG

    /*
    //--------------------------------------------------------------------
    // DEBUG PRINTOUT
    for ( int i = 0; i < static_cast<int>( m_vpParticleRef.size() ); ++i ) {
        std::cout << *m_vpParticleRef[i] << "\n";
    }
    for ( int i = 0; i < static_cast<int>( m_vpSpringRef.size() ); ++i ) {
        std::cout << *m_vpSpringRef[i] << "\n";
    }
    //*/

    //--------------------------------------------------------------------
    /*
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        std::cout << "Vertex#" << i << ":";
        for ( int j = 0; j < static_cast<int>(m_pviListConnectedVertex[i].size()); ++j ) {
            std::cout << " " << m_pviListConnectedVertex[i][j];
        }
        std::cout << "\n";
    }
    //*/
}

template<typename T>

void SpringHalfEdgeModel< T >::CreateSprings	(	T	Ks,
		T	Kd,
		int	rigidity = 1
	)			[inline, protected]

Definition at line 298 of file TAPsSpringHalfEdgeModel.cpp.

{
    m_iRigidity = rigidity;
    int size = static_cast<int>( m_vpParticleRef.size() );
    bool * isMark = new bool[size];
    for ( int i = 0; i < size; ++i ) {
        isMark[i] = false;
    }
    //--------------------------------------------------------------------
    for ( int i = 0; i < size; ++i ) {
        std::vector<int> particleSet;       // start as empty set
        //std::cout << static_cast<int>(particleSet.size()) << "\n";
        BFSCreateSprings(   Ks, Kd, 0, 
                            i, i,           // particle#1, particle#2
                            particleSet, 
                            isMark );
        for ( int j = 0; j < static_cast<int>( particleSet.size() ); ++j ) {
            isMark[ particleSet[j] ] = false;
        }
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::DdtStateToArray	(	T *	xdot,
		T	dt
	)			[inline, protected]

Definition at line 502 of file TAPsSpringHalfEdgeModel.cpp.

{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        if ( m_vpParticleRef[i]->GetFixStatus() ) {
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 0;
        }
        else {
            //m_prForce[i] = m_StructForce[i].gravity;
            //m_prVelocity[i][1] = m_prForce[i][1] * m_prVertex[i][1] * dt;
            //----------------------------------------
            *(xdot++) = m_vpParticleRef[i]->GetVelocity()[0];
            *(xdot++) = m_vpParticleRef[i]->GetVelocity()[1];
            *(xdot++) = m_vpParticleRef[i]->GetVelocity()[2];
            *(xdot++) = m_vpParticleRef[i]->GetForce()[0];
            *(xdot++) = m_vpParticleRef[i]->GetForce()[1];
            *(xdot++) = m_vpParticleRef[i]->GetForce()[2];
        }
    }
    //*/
}

template<typename T>

void SpringHalfEdgeModel< T >::DeleteAllData

(

)

[inline, protected]

Definition at line 169 of file TAPsSpringHalfEdgeModel.cpp.

{
    //m_ptrHEVertex.clear();
    delete [] m_pviListVertexRing1;
    delete [] m_pviListConnectedVertex;
    delete [] m_pviListSpring;
    //m_listParticleRef.clear();
    //m_listSpringRef.clear();
    //m_ptrSpringRef.clear();
    for ( int i = 0; i < static_cast<int>( m_vpParticleRef.size() ); ++i ) {
        delete m_vpParticleRef[i];
    }
    for ( int i = 0; i < static_cast<int>( m_vpSpringRef.size() ); ++i ) {
        delete m_vpSpringRef[i];
    }
}

template<typename T>

bool SpringHalfEdgeModel< T >::DxDt	(	T	dt,
		MATH::VectorSet< T > &	x,
		MATH::VectorSet< T > &	xdot,
		void *	userData
	)			[inline, static, protected]

Definition at line 422 of file TAPsSpringHalfEdgeModel.cpp.

                                              : time step
    MATH::VectorSet<T> &    x,          // I/p: array  x = {pos, vel}
    MATH::VectorSet<T> &    xdot,       // O/P: array xdot = {vel, accel}
    void *                  userData    // O/P: array of user data
)
{   
    //------------------------------------------------------
    // Convert userData ptr to ModelStrand ptr
    SpringHalfEdgeModel<T> *pThis = static_cast<SpringHalfEdgeModel<T> *>( userData );
    assert( pThis );
    //*

    pThis->ClearAllForces();
    //------------------------------------------------------
    for ( int i = 0; i < static_cast<int>( pThis->m_vpSpringRef.size() ); ++i ) {
        pThis->m_vpSpringRef[i]->CalAndSetForce();
        //std::cout << "Force1: " << pThis->m_vpSpringRef[i]->GetForce1() << "\n";
        //std::cout << "Force2: " << pThis->m_vpSpringRef[i]->GetForce2() << "\n";
    }
    /*
    //------------------------------------------------------
    for ( int i = 0; i < pThis->m_iStateSize; ++i ) {
//      pThis->m_vpParticleRef[i]->SetVelocity( 0, 0, 0 );
//      pThis->m_vpParticleRef[i]->SetForce( 0, 0, 0 );

        if ( pThis->m_vpParticleRef[i]->GetFixStatus() ) {
            pThis->m_vpParticleRef[i]->SetVelocity( 0, 0, 0 ); 
            pThis->m_vpParticleRef[i]->SetForce( 0, 0, 0 );
        }
        else {
//          pThis->m_vpParticleRef[i]->SetForce( 0, 0, 0 );
//          pThis->m_prForce[i] = pThis->m_StructForce[i].gravity;
//          pThis->m_prVelocity[i][1] = pThis->m_prForce[i][1] * 
//                                      pThis->m_prVertex[i][1] *
//                                      dt;
            //Vector3<T> newForce = pThis->m_vpParticleRef[i]->GetForce() / 10;
            //pThis->m_vpParticleRef[i]->SetForce( newForce );
        }
    }
    //*/
    //------------------------------------------------------
    pThis->DdtStateToArray( &xdot[0], dt );
    //pThis->ClearForces();
    //------------------------------------------------------
    return true;
}

template<typename T>

T SpringHalfEdgeModel< T >::GetKDamper

(

)

const [inline]

Definition at line 151 of file TAPsSpringHalfEdgeModel.hpp.

{ return m_tKDamper; }

template<typename T>

T SpringHalfEdgeModel< T >::GetKPointMass

(

)

const [inline]

Definition at line 149 of file TAPsSpringHalfEdgeModel.hpp.

{ return m_tPtMass; }

template<typename T>

T SpringHalfEdgeModel< T >::GetKStiffness

(

)

const [inline]

Definition at line 150 of file TAPsSpringHalfEdgeModel.hpp.

{ return m_tKStiffness; }

template<typename T>

int SpringHalfEdgeModel< T >::GetRigidity

(

)

const [inline]

Definition at line 148 of file TAPsSpringHalfEdgeModel.hpp.

{ return m_iRigidity; }

template<typename T>

void SpringHalfEdgeModel< T >::Initialize

(

)

[inline, virtual]

Reimplemented from HalfEdgeModel< T >.

Definition at line 56 of file TAPsSpringHalfEdgeModel.cpp.

{
    HalfEdgeModel<T>::Initialize();
    //--------------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "++++++++++++++Initialize HALF-EDGE SPRING MODEL++++++++++++++\n";
    #endif//TAPs_ENABLE_DEBUG
}

template<typename T>

void SpringHalfEdgeModel< T >::PrepareData

(

)

[inline, protected]

Definition at line 236 of file TAPsSpringHalfEdgeModel.cpp.

{
    int size = GetVertexList()->Size();
    if ( m_pviListVertexRing1 )     delete [] m_pviListVertexRing1;
    if ( m_pviListConnectedVertex ) delete [] m_pviListConnectedVertex;
    if ( m_pviListSpring )          delete [] m_pviListSpring;
    m_pviListVertexRing1     = new std::vector<int>[ size ];
    m_pviListConnectedVertex = new std::vector<int>[ size ];
    m_pviListSpring          = new std::vector<int>[ size ];
    //-----------------------------------------------------------------------
    // Setup pointers to HEVertex
    HEVertex<T> * heVertex = GetVertexList()->Head();
    while ( heVertex ) {
        m_vpHEVertex.push_back( heVertex );
        m_vpParticleRef.push_back( new ParticleRef<T>( heVertex->GetProtectedPosition() ) );
        //m_vpParticleRef.push_back( new ParticleRef<T>( const_cast< Vector3<T> & >( heVertex->GetPosition() ) ) );
        heVertex = heVertex->Next();
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::SetKDamper

(

T

val

)

[inline]

Definition at line 154 of file TAPsSpringHalfEdgeModel.hpp.

{ m_tKDamper = val; }

template<typename T>

void SpringHalfEdgeModel< T >::SetKPointMass

(

T

val

)

[inline]

Definition at line 152 of file TAPsSpringHalfEdgeModel.hpp.

{ m_tPtMass = val; }

template<typename T>

void SpringHalfEdgeModel< T >::SetKStiffness

(

T

val

)

[inline]

Definition at line 153 of file TAPsSpringHalfEdgeModel.hpp.

{ m_tKStiffness = val; }

template<typename T>

void SpringHalfEdgeModel< T >::SetListOf1RingVertices

(

)

[inline, protected]

Definition at line 187 of file TAPsSpringHalfEdgeModel.cpp.

{
    HEHalfEdge<T> * firstHalfEdge, * currentHalfEdge;
    HEVertex<T> *   heVertex = GetVertexList()->Head();
    HEVertex<T> *   currentVertex;

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "Progress: ";
    #endif//TAPs_ENABLE_DEBUG

    #ifdef  TAPs_ENABLE_DEBUG
    int count = 0;
    #endif//TAPs_ENABLE_DEBUG

    int size = static_cast<int>( m_vpHEVertex.size() );
    for ( int v = 0; v < size; ++v ) {

        #ifdef  TAPs_ENABLE_DEBUG
        if ( ++count % 100 == 0 )   std::cout << ".";
        #endif//TAPs_ENABLE_DEBUG

        currentHalfEdge = firstHalfEdge = heVertex->IncidentHalfEdge();
        do {
            currentVertex = currentHalfEdge->Pair()->Vertex();
            for ( int i = 0; i < size; ++i ) {
                if ( currentVertex == m_vpHEVertex[i] ) {
                    m_pviListVertexRing1[v].push_back( i );
                    break;
                }
            }
            currentHalfEdge = currentHalfEdge->Pair()->Next();
        } while ( firstHalfEdge != currentHalfEdge );
        heVertex = heVertex->Next();

        //std::cout << "One Ring Size " 
        //  << static_cast<int>( m_pviListVertexRing1[v].size() ) << ":";
        //for ( int i = 0; i < static_cast<int>( m_pviListVertexRing1[v].size() ); ++i ) {
        //  std::cout << " " << m_pviListVertexRing1[v][i];
        //}
        //std::cout << "\n";
    }

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << " Done\n";
    #endif//TAPs_ENABLE_DEBUG
}

template<typename T>

void SpringHalfEdgeModel< T >::SetMassOfParticles

(

T

mass

)

[inline, protected]

Definition at line 257 of file TAPsSpringHalfEdgeModel.cpp.

{
    //std::list< ParticleRef<T> >::iterator pos;
    //for ( pos = m_listParticleRef.begin(); pos != m_listParticleRef.end(); ++pos ) {
    //  pos->SetMass( mass );
    //}
    for ( int i = 0; i < static_cast<int>( m_vpParticleRef.size() ); ++i ) {
        m_vpParticleRef[i]->SetMass( mass );
    }
}

template<typename T>

void SpringHalfEdgeModel< T >::StateToArray

(

T *

dst

)

[inline, protected]

Definition at line 472 of file TAPsSpringHalfEdgeModel.cpp.

{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        *(dst++) = m_vpParticleRef[i]->GetPosition()[0];
        *(dst++) = m_vpParticleRef[i]->GetPosition()[1];
        *(dst++) = m_vpParticleRef[i]->GetPosition()[2];
        *(dst++) = m_vpParticleRef[i]->GetVelocity()[0];
        *(dst++) = m_vpParticleRef[i]->GetVelocity()[1];
        *(dst++) = m_vpParticleRef[i]->GetVelocity()[2];
    }
    //*/
}

---

Friends And Related Function Documentation

template<typename T>

std::ostream& operator<<	(	std::ostream &	output,
		SpringHalfEdgeModel< T > const &	o
	)			[friend]

Definition at line 79 of file TAPsSpringHalfEdgeModel.hpp.

    {
        // NOT FINISHED YET!

        output  << "\n======================\n"
                <<   "TAPs::SpringHalfEdgeModel<"
                << typeid(T).name() << "> Class:\n"
                <<   "======================\n";
        //----------------------------------------------------------------
        output << "Name: " << o.GetName() << "\n";
        // Vertex Nodes
        output  << "\n\nVertices " << o.m_listVertex->Size();
        /*
        int i;
        i = 0;
        HEVertex<T> *vertex = o.m_listVertex->Head();
        output << "\n{";
        while ( vertex ) {
            output << "\n  #" << ++i << "\t" << *vertex;
            vertex = vertex->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        // Face Nodes
        output  << "\n\nFaces " << o.m_listFace->Size();
        /*
        i = 0;
        HEFace<T> *face = o.m_listFace->Head();
        output << "\n{";
        while ( face ) {
            output << "\n  #" << ++i << "\t" << *face;
            face = face->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        // Hole Face Nodes
        output  << "\n\nHole Faces " << o.m_listHoleFace->Size();
        /*
        i = 0;
        face = o.m_listHoleFace->Head();
        output << "\n{";
        while ( face ) {
            output << "\n  #" << ++i << "\t" << *face;
            face = face->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        return output;
    }

---

Member Data Documentation

template<typename T>

int SpringHalfEdgeModel< T >::m_iLimitStepCount [protected]

Definition at line 312 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

int SpringHalfEdgeModel< T >::m_iRigidity [protected]

Definition at line 266 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

int SpringHalfEdgeModel< T >::m_iStateSize [protected]

Definition at line 310 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

MATH::ODESolver<T>* SpringHalfEdgeModel< T >::m_prODESolver [protected]

Definition at line 305 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector<int>* SpringHalfEdgeModel< T >::m_pviListConnectedVertex [protected]

Definition at line 269 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector<int>* SpringHalfEdgeModel< T >::m_pviListSpring [protected]

Definition at line 271 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector<int>* SpringHalfEdgeModel< T >::m_pviListVertexRing1 [protected]

Definition at line 268 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

T SpringHalfEdgeModel< T >::m_tKDamper [protected]

Definition at line 264 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

T SpringHalfEdgeModel< T >::m_tKStiffness [protected]

Definition at line 263 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

T SpringHalfEdgeModel< T >::m_tPtMass [protected]

Definition at line 262 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector<HEVertex<T> *> SpringHalfEdgeModel< T >::m_vpHEVertex [protected]

Definition at line 267 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector< ParticleRef<T> * > SpringHalfEdgeModel< T >::m_vpParticleRef [protected]

Definition at line 275 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

std::vector< SpringRef<T> * > SpringHalfEdgeModel< T >::m_vpSpringRef [protected]

Definition at line 276 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

MATH::VectorSet<T>* SpringHalfEdgeModel< T >::x0 [protected]

Definition at line 306 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

MATH::VectorSet<T> SpringHalfEdgeModel< T >::xData_1 [protected]

Definition at line 308 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

MATH::VectorSet<T> SpringHalfEdgeModel< T >::xData_2 [protected]

Definition at line 309 of file TAPsSpringHalfEdgeModel.hpp.

template<typename T>

MATH::VectorSet<T>* SpringHalfEdgeModel< T >::xEnd [protected]

Definition at line 307 of file TAPsSpringHalfEdgeModel.hpp.

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsSpringHalfEdgeModel.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsSpringHalfEdgeModel.cpp