HETriMeshOneModelMultiParts< T > Class Template Reference

A HETriMeshOneModelMultiParts model is a deformable triangular mesh model with underlie polygon data is based on half-edge data structure. More...

#include <TAPsHETriMeshOneModelMultiParts.hpp>

Inheritance diagram for HETriMeshOneModelMultiParts< T >:

[legend]

Collaboration diagram for HETriMeshOneModelMultiParts< T >:

[legend]

List of all members.

Public Member Functions

virtual void AdvanceSimulation (MATH::SimClock< T > &simClock)

Advance a simulation step with a simulation clock.

virtual void AdvanceSimulation (T tCurrent)

Advance a simulation step with the predefined time step.

virtual void AdvanceSimulation (T tCurrent, T tNext)

Advance a simulation step.

virtual void ApplyAndResetTransform ()

Apply the current transformation to the model permanently. Then reset the transformation to identity.

void CreateMeshSprings (T mass, T Ks, T Kd, T HKs, T HKd, int rigidity=1, T predefinedTimeStep=0.01, int numSimSubSteps=10, bool enableColDet=true, bool enableSimulation=true)

Create mesh springs with home springs.

T GetHomeKDamper () const

Get home spring damping value.

T GetHomeKStiffness () const

Get home spring stiffness.

T GetKDamper () const

Get spring damping value.

T GetKPointMass () const

Get the mass value of point.

T GetKStiffness () const

Get spring stiffness.

std::vector
< SimPropForMultiPartMeshModel_HalfEdge
< T > > & GetListOfParts ()

Get list of parts.

int GetNumSimSubSteps () const

Get number of simulation sub-steps.

T GetPredefinedTimeStep () const

Get the predefined time step in sec.

SimPropForMultiPartMeshModel_HalfEdge
< T > * GetPtrToPartNo (unsigned int i)

Get the pointer to part number.

int GetRigidity () const

Get rigidity value.

HETriMeshOneModelMultiParts ()

Default constructor.

virtual void Initialize ()

A virtual funciton from HalfEdgeModel ---> Model class for initialization.

void SetHomeKDamper (T val)

void SetHomeKStiffness (T val)

void SetKDamper (T val)

void SetKPointMass (T val)

void SetKStiffness (T val)

void SetNumSimSubSteps (int i)

Set number of simulation sub-steps.

void SetPredefinedTimeStep (T ts)

Set the predefined time step in sec.

virtual ~HETriMeshOneModelMultiParts ()

Destructor.

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 SeparateIntoParts (T mass, T Ks, T Kd, T HKs, T HKd, int rigidity, T predefinedTimeStep, int numSimSubSteps, bool enableColDet, bool enableSimulation)

Separate the model into parts.

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

std::vector
< HEVertexPtrWithExtraInfo< T > * > m_HEVertexList_1

vertex list (Each vertex has a pointer to a particle ref and has a particle for home position.)

int m_iLimitStepCount

Limit step count.

int m_iNumSimSubSteps

number of simulation sub-steps for moving from current time to next time

int m_iRigidity

number of spring hops

int m_iStateSize

Mass Points (mesh vertices) where 6 = 3 positions + 3 velocities (for x,y,z)

std::vector
< SimPropForMultiPartMeshModel_HalfEdge
< T > > m_Parts

list of parts

std::vector
< HEVertexPtrWithExtraInfo< T > * > * m_pHEVertexList

pointer to the vertex list

TAPs::MATH::ODESolver< T > * m_prODESolver

ODE solver.

std::vector< ParticleRef< T > * > m_svpParticleRef

particle reference list (Its size is the same as the size of vertex list.)

T m_tHomeKDamper

home spring damper constant

T m_tHomeKStiffness

home spring stiffness constant

T m_tKDamper

spring damper constant

T m_tKStiffness

spring stiffness constant

std::vector< int > m_tmpForPuttingSpringRefIntoParts

T m_tPredefinedTimeStep

predefined time step in sec

T m_tPtMass

mass of point (vertex)

std::vector< SpringRef< T > * > m_vpSpringRef

pointers to spring

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, HETriMeshOneModelMultiParts< T > const &o)

Detailed Description

template<typename T>
class HETriMeshOneModelMultiParts< T >

A HETriMeshOneModelMultiParts model is a deformable triangular mesh model with underlie polygon data is based on half-edge data structure.

The mesh model must be a triangular mesh.

The model can be divided into segments or parts.

Each part has its own behavior: simulation properties (including simulation on/off, collision on/off, and rigid/deform) and rendering properties (including visible/invisible).

Definition at line 89 of file TAPsHETriMeshOneModelMultiParts.hpp.

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs__OpenGL HETriMeshOneModelMultiParts< T >::HETriMeshOneModelMultiParts ( ) [inline]

Default constructor.

A Polygonal Model based on half-edge data structure. See TAPsHETriMeshOneModelMultiParts.hpp for details.

Definition at line 25 of file TAPsHETriMeshOneModelMultiParts.cpp.

00026     : HalfEdgeModel<T>(), 
00027       m_iRigidity( 1 ), 
00028       m_tPtMass( 1 ), 
00029       m_tKStiffness( 1 ), 
00030       m_tKDamper( 0.5 ), 
00031       m_tHomeKStiffness( 1 ), 
00032       m_tHomeKDamper( 0.5 ) 
00033 #ifdef  TAPs_ADVANCED_SIMULATION
00034       , AdvSimID( TotalModels++ )
00035 #endif//TAPs_ADVANCED_SIMULATION
00036 {
00037     //---------------------------------------------------------------
00038     //std::cout << "Number of Vertex: " << GetNoVertices();
00039     //std::cout << "Number of Vertex: " << GetNoVertices();
00040     #ifdef  TAPs_ENABLE_DEBUG
00041     std::cout << "HETriMeshOneModelMultiParts<" << typeid(T).name() << "> Constructor\n";
00042     #endif//TAPs_ENABLE_DEBUG
00043 
00044 #ifdef  TAPs_USE_CUDA
00045     // Data Members for CUDA
00046     m_cudaVertexList            = NULL;
00047     m_cudaPrevVertexList        = NULL;
00048     m_cudaHomeVertexList        = NULL;
00049     m_cudaVertexConnectionList  = NULL;
00050     m_cudaMaxConnectionSize     = 0;
00051     m_cudaID                    = 0;
00052 #endif//TAPs_USE_CUDA
00053 
00054 }

template<typename T>

HETriMeshOneModelMultiParts< T >::~HETriMeshOneModelMultiParts ( ) [inline, virtual]

Destructor.

Definition at line 58 of file TAPsHETriMeshOneModelMultiParts.cpp.

00059 {
00060     DeleteAllData();
00061     //---------------------------------------------------------------
00062     // For simulation
00063     delete m_prODESolver;
00064     //---------------------------------------------------------------
00065     #ifdef  TAPs_ENABLE_DEBUG
00066     std::cout << "HETriMeshOneModelMultiParts<" << typeid(T).name() << "> Destructor\n";
00067     #endif//TAPs_ENABLE_DEBUG
00068 }

Member Function Documentation

template<typename T>

void HETriMeshOneModelMultiParts< T >::AdvanceSimulation ( MATH::SimClock< T > & simClock ) [inline, virtual]

Advance a simulation step with a simulation clock.

Reimplemented from PhysicsSupport< T >.

Definition at line 627 of file TAPsHETriMeshOneModelMultiParts.cpp.

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

template<typename T>

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

Advance a simulation step with the predefined time step.

Definition at line 573 of file TAPsHETriMeshOneModelMultiParts.cpp.

00574 {
00575     #ifdef  TAPs_USE_CUDA
00576 
00577         //PrintDebug_ConnectionList();
00578         //PrintDebug();
00579 
00580         // Copy the (current) vertex positions of the object to memory for transfering to CUDA.
00581         CUDA_CopyVertexToMem();
00582 
00583         // Call the wrapper function for 
00584         TAPsCUDA__global__HETriMeshOneModelMultiParts_AdvSim( 
00585             m_cudaID,
00586             m_pHEVertexList->size(),    
00587             64,                         
00588             tCurrent,                   
00589             GetPredefinedTimeStep(),    
00590             GetNumSimSubSteps(),        
00591             GetKPointMass(),            
00592             GetKStiffness(),            
00593             GetKDamper(),               
00594             GetHomeKStiffness(),        
00595             GetHomeKDamper(),           
00596             m_cudaVertexList, 
00597             m_cudaPrevVertexList, 
00598             m_cudaHomeVertexList, 
00599             m_cudaVertexConnectionList, 
00600             m_cudaMaxConnectionSize 
00601         );
00602 
00603         // The new vertex positions are returned by CUDA to memory for previous vertex positions.
00604         // So the new vertex positions must be copied to the vertex positions of the object.
00605         CUDA_CopyMemToPrevVertex();
00606         // Then the previous and current vertex pointers (that point to memory for transfering to CUDA) are swapped.
00607         // So that now the previous becomes current and the current becomes previous.
00608         CUDA_SwapBuffers();
00609 
00610         //GetBVHTree()->Update();   // commented out to rely on CDR to update the collided BVNodes
00611         CalAndSetNormals();
00612 
00613     #else //TAPs_USE_CUDA
00614 
00615         for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
00616             m_Parts[i].AdvSim( tCurrent );
00617             //std::cout << "AdvanceSimulation m_Parts[" << i << "]\n";
00618         }
00619         //GetBVHTree()->Update();   // commented out to rely on CDR to update the collided BVNodes
00620         CalAndSetNormals();
00621 
00622     #endif//TAPs_USE_CUDA
00623 }

template<typename T>

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

Advance a simulation step.

Reimplemented from PhysicsSupport< T >.

Definition at line 535 of file TAPsHETriMeshOneModelMultiParts.cpp.

00536 {
00537     #ifdef  TAPs_USE_CUDA
00538 
00539     std::cout << __FILE__ << " " << __LINE__ << " -- ";
00540     std::cout << "HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( T tCurrent, T tNext ) IS NOT IMPLEMENTED YET!\n";
00541 
00542         /*
00543         CUDA_CopyVertexToMem();
00544         TAPsCUDA__global__HETriMeshOneModelMultiParts_AdvSim( 
00545             m_pHEVertexList->size(),    //!< number of vertices
00546             64,                         //!< number of threads
00547             tCurrent, tNext, 
00548             m_cudaVertexList, 
00549             m_cudaPrevVertexList, 
00550             m_cudaHomeVertexList, 
00551             m_cudaVertexConnectionList, 
00552             m_cudaMaxConnectionSize 
00553         );
00554         CUDA_CopyMemToVertex();
00555 
00556         //GetBVHTree()->Update();   // commented out to rely on CDR to update the collided BVNodes
00557         CalAndSetNormals();
00558         //*/
00559 
00560     #else //TAPs_USE_CUDA
00561 
00562         for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
00563             m_Parts[i].AdvSim( tCurrent, tNext );
00564         }
00565         //GetBVHTree()->Update();   // commented out to rely on CDR to update the collided BVNodes
00566         CalAndSetNormals();
00567 
00568     #endif//TAPs_USE_CUDA
00569 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::ApplyAndResetTransform ( ) [inline, virtual]

Apply the current transformation to the model permanently. Then reset the transformation to identity.

So that the transformation can be turned off to save the computation time that have to use when the model has the transformation on.

The side effect is that the model's original shape is permanently changed by the transformation (before the transformation is reset).

Reimplemented from HalfEdgeModel< T >.

Definition at line 500 of file TAPsHETriMeshOneModelMultiParts.cpp.

00501 {
00502     // Apply to each home position
00503     std::vector< HEVertexPtrWithExtraInfo<T> * >::iterator pos = m_pHEVertexList->begin();
00504     while ( pos != m_pHEVertexList->end() ) {
00505         (*pos)->SetHomePosition( 
00506             ( GetTransform().GetMatrixTransform() * Vector4<T>( (*pos)->GetHomePosition() ) ).GetVector3()
00507         );
00508         ++pos;
00509     }
00510 
00511     // Apply to the whole mesh of HalfEdgeModel
00512     // After this statement the transformation matrix is reset to identity
00513     HalfEdgeModel<T>::ApplyAndResetTransform();
00514 
00515     // Have to come after HalfEdgeModel<T>::ApplyAndResetTransform();
00516     for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
00517         m_Parts[p].UpdateStateToArray();
00518     }
00519 
00520     // Update Springs
00521     std::vector< SpringRef<T> * >::iterator sprPos = m_vpSpringRef.begin();
00522     while ( sprPos != m_vpSpringRef.end() ) {
00523         (*sprPos)->SetRestLengthL( (*sprPos)->GetCurrentLength() );
00524         ++sprPos;
00525     }
00526 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::ArrayToState ( T * src ) [inline, protected]

Definition at line 700 of file TAPsHETriMeshOneModelMultiParts.cpp.

00701 {
00702     //*
00703     for ( int i = 0; i < m_iStateSize; ++i ) {
00704         (*m_pHEVertexList)[i]->GetParticleRef()->SetPosition( *src, *(src+1), *(src+2) );
00705         src += 3;
00706         (*m_pHEVertexList)[i]->GetParticleRef()->SetVelocity( *src, *(src+1), *(src+2) );
00707         src += 3;
00708     }
00709     //*/
00710 }

template<typename T>

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

Definition at line 432 of file TAPsHETriMeshOneModelMultiParts.cpp.

00437 {
00438     if ( rigidity >= m_iRigidity ) return;
00439     //---------------------------------------------------------------
00440     // Keep the particle reference in particleSet
00441     // And mark it as visited
00442     particleSet.push_back( p2 );
00443     isMark[ p2 ] = true;
00444     //---------------------------------------------------------------
00445     // Traverse each edge of p1
00446     ++rigidity;
00447     int p3;
00448     for ( int i = 0; i < static_cast<int>( (*m_pHEVertexList)[p2]->GetListVertexFirstRing().size() ); ++i ) {
00449         p3 = (*m_pHEVertexList)[p2]->GetListVertexFirstRing()[i];
00450         if ( !isMark[ p3 ] ) {
00451             if ( !CheckASpringExistance( p1, p3 ) ) {
00452                 CreateASpring( Ks, Kd, p1, p3, rigidity );
00453             }
00454         }
00455     }
00456     // This makes it become Breath First Search
00457     for ( int i = 0; i < static_cast<int>( (*m_pHEVertexList)[p2]->GetListVertexFirstRing().size() ); ++i ) {
00458         p3 = (*m_pHEVertexList)[p2]->GetListVertexFirstRing()[i];
00459         BFSCreateSprings( Ks, Kd, rigidity, p1, p3, particleSet, isMark );
00460     }
00461     //---------------------------------------------------------------
00462 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::ChangeConstantDampingOfAllSprings ( T val ) [inline, protected]

Definition at line 208 of file TAPsHETriMeshOneModelMultiParts.cpp.

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

template<typename T>

void HETriMeshOneModelMultiParts< T >::ChangeConstantStiffnessOfAllSprings ( T val ) [inline, protected]

Definition at line 199 of file TAPsHETriMeshOneModelMultiParts.cpp.

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

template<typename T>

void HETriMeshOneModelMultiParts< T >::ChangeMassOfAllPoints ( T val ) [inline, protected]

Definition at line 217 of file TAPsHETriMeshOneModelMultiParts.cpp.

00218 {
00219     std::vector< HEvertexPtrWithExtraInfo<T> >::iterator pos;
00220     for ( pos = m_pHEVertexList->begin(); pos < m_pHEVertexList->end(); ++pos ) {
00221         (*pos).GetListParticleRef()->SetMass( val );
00222     }
00223 }

template<typename T>

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

Definition at line 378 of file TAPsHETriMeshOneModelMultiParts.cpp.

00379 {
00380     int size = static_cast<int>( (*m_pHEVertexList)[p1]->GetListConnectedVertices().size() );
00381     for ( int i = 0; i < size; ++i ) {
00382         if ( (*m_pHEVertexList)[p1]->GetListConnectedVertices()[i] == p2 )  return true;
00383     }
00384     return false;
00385 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::ClearAllForces ( ) [inline, protected]

Definition at line 744 of file TAPsHETriMeshOneModelMultiParts.cpp.

00745 {
00746     for ( int i = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i ) {
00747         (*m_pHEVertexList)[i]->GetParticleRef()->SetForce( 0, 0, 0 );
00748     }
00749 }

template<typename T>

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

Definition at line 388 of file TAPsHETriMeshOneModelMultiParts.cpp.

00390 {
00391     SpringRef<T> * newSpring = new SpringRef<T>( 
00392                                     *((*m_pHEVertexList)[p1]->GetParticleRef()), 
00393                                     *((*m_pHEVertexList)[p2]->GetParticleRef()), 
00394                                     Ks, Kd, 
00395                                     hops );
00396     m_vpSpringRef.push_back( newSpring );
00397     (*m_pHEVertexList)[p1]->GetListConnectedVertices().push_back( p2 );
00398     (*m_pHEVertexList)[p2]->GetListConnectedVertices().push_back( p1 );
00399     //std::cout << "# of Hops: " << hops << "\n";
00400     //std::cout << "Create Spring with " << hops << " hop(s)\n";
00401 
00402     m_Parts[ m_tmpForPuttingSpringRefIntoParts[p1] ].GetSpringList().push_back( newSpring );
00403     m_Parts[ m_tmpForPuttingSpringRefIntoParts[p2] ].GetSpringList().push_back( newSpring );
00404 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::CreateMeshSprings	(	T	mass,
		T	Ks,
		T	Kd,
		T	HKs,
		T	HKd,
		int	rigidity = `1`,
		T	predefinedTimeStep = `0.01`,
		int	numSimSubSteps = `10`,
		bool	enableColDet = `true`,
		bool	enableSimulation = `true`
	)			`[inline]`

Create mesh springs with home springs.

< mass of point

< spring stiffness

< spring damper

< home spring stiffness

< home spring damper

< number of hops for creating springs

< predefined time step in sec

< number of simulation sub-steps

< collision detection on/off status

< simulation on/off status

Parameters:

mass	mass of point
Ks	spring stiffness
Kd	spring damper
HKs	home spring stiffness
HKd	home spring damper
rigidity	number of hops for creating springs
predefinedTimeStep	predefined time step in sec
numSimSubSteps	number of simulation sub-steps
enableColDet	collision detection on/off status
enableSimulation	simulation on/off status

Definition at line 84 of file TAPsHETriMeshOneModelMultiParts.cpp.

00096 {
00097     PrepareData();
00098 
00099     //---------------------------------------------------------------
00100     // For Simulation
00101     if ( ( m_prODESolver = new MATH::ODESolverEuler<T>() ) == NULL ) {
00102     //if ( ( m_prODESolver = new MATH::ODESolverMidpoint<T>() ) == NULL ) {
00103     //if ( ( m_prODESolver = new MATH::ODESolverRungeKutta4<T>() ) == NULL ) {
00104         #ifdef TAPs_ENABLE_DEBUG
00105         std::cerr   << "ERROR => HETriMeshOneModelMultiParts Constructor:" 
00106                     << " Cannot allocate memory for an ODE solver!" 
00107                     << std::endl;
00108         #endif
00109         delete this;
00110         return;
00111     }
00112     //---------------------------------------------------------------
00113     // Create ODE Solver
00114     m_iStateSize = static_cast<int>( m_pHEVertexList->size() );
00115     m_prODESolver->SetSize( m_iStateSize * 6 );
00116     x0   = &xData_1;
00117     xEnd = &xData_2;
00118     x0->resize(   m_iStateSize * 6 );
00119     xEnd->resize( m_iStateSize * 6 );
00120     StateToArray( &(*xEnd)[0] );
00121     //---------------------------------------------------------------
00122     #ifdef  TAPs_ENABLE_DEBUG
00123     std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
00124     std::cout << "++++++++++++++ --> m_iStateSize = " << m_iStateSize << "\n";
00125     std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
00126     #endif//TAPs_ENABLE_DEBUG
00127     //---------------------------------------------------------------
00128     SetListOf1RingVertices();
00129     SetMassOfParticles( mass );
00130     //---------------------------------------------------------------
00131     // Create Multiparts
00132 
00133     // Have to come after SetListOf1RingVertices()
00134     SeparateIntoParts(
00135         mass,       
00136         Ks,         
00137         Kd,         
00138         HKs,        
00139         HKd,        
00140         rigidity,   
00141         predefinedTimeStep,     
00142         numSimSubSteps,         
00143         enableColDet,           
00144         enableSimulation        
00145     );
00146     //---------------------------------------------------------------
00147     // Create home spring of each HEVertexPtrWithExtraInfo in m_pHEVertexList
00148     for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
00149         for ( int i = 0; i < static_cast<int>( m_Parts[p].GetVertexList().size() ); ++i ) {
00150             // Create home spring from a particle
00151             //*
00152             SpringRef<T> * newSpring = new SpringRef<T>( 
00153                                             (m_Parts[ p ].GetVertexList()[i]->GetHomeParticle()), 
00154                                             *(m_Parts[ p ].GetVertexList()[i]->GetParticleRef()), 
00155                                             HKs, HKd, 
00156                                             //0, 0,
00157                                             0           // # of hops (0 means home spring)
00158             );
00159             m_vpSpringRef.push_back( newSpring );
00160             m_Parts[ p ].GetSpringList().push_back( newSpring );
00161             //*/
00162         }
00163     }
00164 
00165     //---------------------------------------------------------------
00166     CreateSprings( Ks, Kd, rigidity );  // A recursive method for creating springs on mesh
00167     //CreateSprings( 0, 0, rigidity );  // A recursive method for creating springs on mesh
00168 
00169     #ifdef  TAPs_ENABLE_DEBUG
00170     std::cout << "Spring Mesh Rigidity: " << m_iRigidity << "\n";
00171     std::cout << "The Total Number of Springs is " << static_cast<int>(m_vpSpringRef.size()) << "\n";
00172     #endif//TAPs_ENABLE_DEBUG
00173 
00174     /*
00175     // DEBUG
00176     for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
00177         std::cout << "Part# " << i << "contains " << m_Parts[i].GetVertexList().size() << " vertices\n";
00178         for ( int j = 0; j < static_cast<int>( m_Parts[i].GetVertexList().size() ); ++j ) {
00179             std::cout << *(m_Parts[i].GetVertexList()[j]);
00180         }
00181         std::cout << "\n";
00182     }
00183     //*/
00184 
00185     #ifdef  TAPs_USE_CUDA
00186     for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
00187         m_Parts[p].CUDA_Initialize();
00188     }
00189     CUDA_Initialize_All();
00190     #endif//TAPs_USE_CUDA
00191 }

template<typename T>

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

Definition at line 407 of file TAPsHETriMeshOneModelMultiParts.cpp.

00408 {
00409     m_iRigidity = rigidity;
00410     int size = static_cast<int>( m_pHEVertexList->size() );
00411     bool * isMark = new bool[size];
00412     for ( int i = 0; i < size; ++i ) {
00413         isMark[i] = false;      // prepare for spring creation
00414     }
00415     //---------------------------------------------------------------
00416     for ( int i = 0; i < size; ++i ) {
00417         std::vector<int> particleSet;       // start as empty set
00418         //std::cout << static_cast<int>(particleSet.size()) << "\n";
00419         BFSCreateSprings(   Ks, Kd, 0, 
00420                             i, i,           // particle#1, particle#2
00421                             particleSet, 
00422                             isMark );
00423         for ( int j = 0; j < static_cast<int>( particleSet.size() ); ++j ) {
00424             isMark[ particleSet[j] ] = false;
00425         }
00426     }
00427 
00428     m_tmpForPuttingSpringRefIntoParts.clear();
00429 }

template<typename T>

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

Definition at line 714 of file TAPsHETriMeshOneModelMultiParts.cpp.

00715 {
00716     //*
00717     for ( int i = 0; i < m_iStateSize; ++i ) {
00718         if ( (*m_pHEVertexList)[i]->GetParticleRef()->GetFixStatus() ) {
00719             *(xdot++) = 
00720             *(xdot++) = 
00721             *(xdot++) = 
00722             *(xdot++) = 
00723             *(xdot++) = 
00724             *(xdot++) = 0;
00725         }
00726         else {
00727             //m_prForce[i] = m_StructForce[i].gravity;
00728             //m_prVelocity[i][1] = m_prForce[i][1] * m_prVertex[i][1] * dt;
00729             //----------------------------------------
00730             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[0];
00731             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[1];
00732             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[2];
00733             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[0];
00734             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[1];
00735             *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[2];
00736         }
00737     }
00738     //*/
00739 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::DeleteAllData ( ) [inline, protected]

Definition at line 231 of file TAPsHETriMeshOneModelMultiParts.cpp.

00232 {
00233     // Clear spring references
00234     for ( int i = 0; i < static_cast<int>( m_vpSpringRef.size() ); ++i ) {
00235         delete m_vpSpringRef[i];
00236     }
00237     m_vpSpringRef.clear();
00238 
00239     // Clear vertex list
00240     for ( int i = 0; i < static_cast<int>( m_HEVertexList_1.size() ); ++i ) {
00241         delete m_HEVertexList_1[i];
00242     }
00243     m_HEVertexList_1.clear();
00244 
00245     // Clear particle references
00246     for ( int i = 0; i < static_cast<int>( m_svpParticleRef.size() ); ++i ) {
00247         delete m_svpParticleRef[i];
00248     }
00249     m_svpParticleRef.clear();
00250 
00251     // Clear multi-parts
00252     m_Parts.clear();
00253 
00254     #ifdef  TAPs_USE_CUDA
00255     CUDA_Cleanup_All();
00256     #endif//TAPs_USE_CUDA
00257 }

template<typename T>

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

Definition at line 634 of file TAPsHETriMeshOneModelMultiParts.cpp.

00635                                               : time step
00636     MATH::VectorSet<T> &    x,          // I/p: array  x = {pos, vel}
00637     MATH::VectorSet<T> &    xdot,       // O/P: array xdot = {vel, accel}
00638     void *                  userData    // O/P: array of user data
00639 )
00640 {
00641     //-----------------------------------------------------
00642     // Convert userData ptr to ModelStrand ptr
00643     HETriMeshOneModelMultiParts<T> *pThis = static_cast<HETriMeshOneModelMultiParts<T> *>( userData );
00644     assert( pThis );
00645 
00646     //*
00647     pThis->ClearAllForces();
00648     //-----------------------------------------------------
00649     for ( int i = 0; i < static_cast<int>( pThis->m_vpSpringRef.size() ); ++i ) {
00650         pThis->m_vpSpringRef[i]->CalAndSetForce();
00651         //std::cout << "Force1: " << pThis->m_vpSpringRef[i]->GetForce1() << "\n";
00652         //std::cout << "Force2: " << pThis->m_vpSpringRef[i]->GetForce2() << "\n";
00653     }
00654     /*
00655     //-----------------------------------------------------
00656     for ( int i = 0; i < pThis->m_iStateSize; ++i ) {
00657 //      pThis->(*m_pHEVertexList)[i]->GetListParticleRef()->SetVelocity( 0, 0, 0 );
00658 //      pThis->(*m_pHEVertexList)[i]->GetListParticleRef()->SetForce( 0, 0, 0 );
00659 
00660         if ( (*pThis->m_pHEVertexList)[i]->GetParticleRef()->GetFixStatus() ) {
00661             (*pThis->m_pHEVertexList)[i]->GetParticleRef()->SetVelocity( 0, 0, 0 );
00662             (*pThis->m_pHEVertexList)[i]->GetParticleRef()->SetForce( 0, 0, 0 );
00663         }
00664         else {
00665 //          (*pThis->m_pHEVertexList)[i]->GetListParticleRef()->SetForce( 0, 0, 0 );
00666 //          pThis->m_prForce[i] = pThis->m_StructForce[i].gravity;
00667 //          pThis->m_prVelocity[i][1] = pThis->m_prForce[i][1] * 
00668 //                                      pThis->m_prVertex[i][1] *
00669 //                                      dt;
00670             //Vector3<T> newForce = (*pThis->m_pHEVertexList)[i].GetParticleRef()->GetForce() / 10;
00671             //(*pThis->m_pHEVertexList)[i].GetParticleRef()->SetForce( newForce );
00672         }
00673     }
00674     //*/
00675 
00676     //-----------------------------------------------------
00677     pThis->DdtStateToArray( &xdot[0], dt );
00678     //-----------------------------------------------------
00679     return true;
00680 }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetHomeKDamper ( ) const [inline]

Get home spring damping value.

Definition at line 183 of file TAPsHETriMeshOneModelMultiParts.hpp.

00183 { return m_tHomeKDamper; }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetHomeKStiffness ( ) const [inline]

Get home spring stiffness.

Definition at line 181 of file TAPsHETriMeshOneModelMultiParts.hpp.

00181 { return m_tHomeKStiffness; }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetKDamper ( ) const [inline]

Get spring damping value.

Definition at line 179 of file TAPsHETriMeshOneModelMultiParts.hpp.

00179 { return m_tKDamper; }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetKPointMass ( ) const [inline]

Get the mass value of point.

Definition at line 175 of file TAPsHETriMeshOneModelMultiParts.hpp.

00175 { return m_tPtMass; }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetKStiffness ( ) const [inline]

Get spring stiffness.

Definition at line 177 of file TAPsHETriMeshOneModelMultiParts.hpp.

00177 { return m_tKStiffness; }

template<typename T>

std::vector< SimPropForMultiPartMeshModel_HalfEdge<T> >& HETriMeshOneModelMultiParts< T >::GetListOfParts ( ) [inline]

Get list of parts.

Definition at line 192 of file TAPsHETriMeshOneModelMultiParts.hpp.

00193     { return m_Parts; }

template<typename T>

int HETriMeshOneModelMultiParts< T >::GetNumSimSubSteps ( ) const [inline]

Get number of simulation sub-steps.

Definition at line 230 of file TAPsHETriMeshOneModelMultiParts.hpp.

00230 { return m_iNumSimSubSteps; }

template<typename T>

T HETriMeshOneModelMultiParts< T >::GetPredefinedTimeStep ( ) const [inline]

Get the predefined time step in sec.

Definition at line 225 of file TAPsHETriMeshOneModelMultiParts.hpp.

00225 { return m_tPredefinedTimeStep; }

template<typename T>

SimPropForMultiPartMeshModel_HalfEdge<T>* HETriMeshOneModelMultiParts< T >::GetPtrToPartNo ( unsigned int i ) [inline]

Get the pointer to part number.

Definition at line 196 of file TAPsHETriMeshOneModelMultiParts.hpp.

00197     {
00198         if ( i < static_cast<unsigned int>( m_Parts.size() ) )  return &m_Parts[i];
00199         else                                                    return NULL;
00200     }

template<typename T>

int HETriMeshOneModelMultiParts< T >::GetRigidity ( ) const [inline]

Get rigidity value.

Definition at line 173 of file TAPsHETriMeshOneModelMultiParts.hpp.

00173 { return m_iRigidity; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::Initialize ( ) [inline, virtual]

A virtual funciton from HalfEdgeModel ---> Model class for initialization.

Reimplemented from HalfEdgeModel< T >.

Definition at line 73 of file TAPsHETriMeshOneModelMultiParts.cpp.

00074 {
00075     HalfEdgeModel<T>::Initialize();
00076     //---------------------------------------------------------------
00077     #ifdef  TAPs_ENABLE_DEBUG
00078     std::cout << "++++++++++++++Initialize HALF-EDGE SPRING MODEL++++++++++++++\n";
00079     #endif//TAPs_ENABLE_DEBUG
00080 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::PrepareData ( ) [inline, protected]

Definition at line 294 of file TAPsHETriMeshOneModelMultiParts.cpp.

00295 {
00296     m_pHEVertexList     = &m_HEVertexList_1;
00297 
00298     // Setup pointers to HEVertex
00299     HEVertex<T> * heVertex = GetVertexList()->Head();
00300 
00301     int i = 0;
00302     while ( heVertex ) {
00303         m_svpParticleRef.push_back( new ParticleRef<T>( heVertex->GetProtectedPosition() ) );
00304 
00305         // The position in the particle reference will be set as a home position 
00306         // when HEVertexPtrWithExtraInfo constructor below is called.
00307         m_pHEVertexList->push_back( new HEVertexPtrWithExtraInfo<T>( heVertex, m_svpParticleRef[i] ) );
00308 
00309         ++i;
00310         heVertex = heVertex->Next();
00311     }
00312 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SeparateIntoParts	(	T	mass,
		T	Ks,
		T	Kd,
		T	HKs,
		T	HKd,
		int	rigidity,
		T	predefinedTimeStep,
		int	numSimSubSteps,
		bool	enableColDet,
		bool	enableSimulation
	)			`[inline, protected]`

Separate the model into parts.

Parameters:

mass	mass of point
Ks	spring stiffness
Kd	spring damper
HKs	home spring stiffness
HKd	home spring damper
rigidity	number of hops for creating springs
predefinedTimeStep	predefined time step in sec
numSimSubSteps	number of simulation sub-steps
enableColDet	collision detection on/off status
enableSimulation	simulation on/off status

Definition at line 315 of file TAPsHETriMeshOneModelMultiParts.cpp.

00327 {
00328     // Set Data Members of this object
00329     m_tPredefinedTimeStep = predefinedTimeStep;
00330     m_iNumSimSubSteps = numSimSubSteps;
00331     m_tPtMass       = mass;
00332     m_tKStiffness   = Ks;
00333     m_tKDamper      = Kd;
00334     m_tHomeKStiffness   = HKs;
00335     m_tHomeKDamper      = HKd;
00336 
00337 
00338     m_Parts.push_back( SimPropForMultiPartMeshModel_HalfEdge<T>( mass, Ks, Kd, TAPs::Enum::MODEL_DEFORM, predefinedTimeStep, numSimSubSteps, enableColDet, enableSimulation ) );
00339     m_Parts.push_back( SimPropForMultiPartMeshModel_HalfEdge<T>( mass, Ks, Kd, TAPs::Enum::MODEL_DEFORM, predefinedTimeStep, numSimSubSteps, enableColDet, enableSimulation ) );
00340 
00341     int size = static_cast<int>( m_pHEVertexList->size() );
00342 
00343     m_tmpForPuttingSpringRefIntoParts.clear();
00344 
00345     for ( int i = 0; i < size; ++i ) {
00346         if ( (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[1] > 0 ) {
00347             m_Parts[0].GetVertexList().push_back( (*m_pHEVertexList)[i] );
00348             m_tmpForPuttingSpringRefIntoParts.push_back( 0 );
00349         }
00350         else {
00351             m_Parts[1].GetVertexList().push_back( (*m_pHEVertexList)[i] );
00352             m_tmpForPuttingSpringRefIntoParts.push_back( 1 );
00353         }
00354     }
00355 
00356     for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
00357         m_Parts[i].SetODESolver( TAPs::Enum::EULER );
00358         if ( i % 2 == 0 ) {
00359             m_Parts[i].SetModelType( TAPs::Enum::MODEL_DEFORM );
00360         }
00361         else {
00362             m_Parts[i].SetModelType( TAPs::Enum::MODEL_DEFORM_ELASTIC );
00363         }
00364 
00365         std::cout << "m_Parts[" << i << "] size: " << m_Parts[i].Size() << "\n";
00366     }
00367 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetHomeKDamper ( T val ) [inline]

Definition at line 189 of file TAPsHETriMeshOneModelMultiParts.hpp.

00189 { m_tHomeKDamper = val; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetHomeKStiffness ( T val ) [inline]

Definition at line 188 of file TAPsHETriMeshOneModelMultiParts.hpp.

00188 { m_tHomeKStiffness = val; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetKDamper ( T val ) [inline]

Definition at line 187 of file TAPsHETriMeshOneModelMultiParts.hpp.

00187 { m_tKDamper = val; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetKPointMass ( T val ) [inline]

Definition at line 185 of file TAPsHETriMeshOneModelMultiParts.hpp.

00185 { m_tPtMass = val; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetKStiffness ( T val ) [inline]

Definition at line 186 of file TAPsHETriMeshOneModelMultiParts.hpp.

00186 { m_tKStiffness = val; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetListOf1RingVertices ( ) [inline, protected]

Definition at line 260 of file TAPsHETriMeshOneModelMultiParts.cpp.

00261 {
00262     HEHalfEdge<T> * firstHalfEdge, * currentHalfEdge;
00263     HEVertex<T> *   heVertex = GetVertexList()->Head();
00264     HEVertex<T> *   currentVertex;
00265 
00266     /* Doesn't Work???
00267     for ( int v = 0; v < static_cast<int>( GetVertexList()->Size() ); ++v ) {
00268         m_HEVertexList[v].CreateListVertexFirstRing( GetVertexList() );
00269 
00270         for ( int i = 0; i < static_cast<int>( m_HEVertexList[v].GetListVertexFirstRing().size() ); ++i ) {
00271             m_pviListVertexRing1[v].push_back( i );
00272         }
00273     }
00274     //*/
00275 
00276     int size = static_cast<int>( m_pHEVertexList->size() );
00277     for ( int v = 0; v < size; ++v ) {
00278         currentHalfEdge = firstHalfEdge = heVertex->IncidentHalfEdge();
00279         do {
00280             currentVertex = currentHalfEdge->Pair()->Vertex();
00281             for ( int i = 0; i < size; ++i ) {
00282                 if ( currentVertex == (*m_pHEVertexList)[i]->GetHEVertexPtr() ) {
00283                     (*m_pHEVertexList)[v]->GetListVertexFirstRing().push_back( i );
00284                     break;
00285                 }
00286             }
00287             currentHalfEdge = currentHalfEdge->Pair()->Next();
00288         } while ( firstHalfEdge != currentHalfEdge );
00289         heVertex = heVertex->Next();
00290     }
00291 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetMassOfParticles ( T mass ) [inline, protected]

Definition at line 370 of file TAPsHETriMeshOneModelMultiParts.cpp.

00371 {
00372     for ( int i = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i ) {
00373         (*m_pHEVertexList)[i]->GetParticleRef()->SetMass( mass );
00374     }
00375 }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetNumSimSubSteps ( int i ) [inline]

Set number of simulation sub-steps.

Definition at line 232 of file TAPsHETriMeshOneModelMultiParts.hpp.

00232 { m_iNumSimSubSteps = i; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::SetPredefinedTimeStep ( T ts ) [inline]

Set the predefined time step in sec.

Definition at line 227 of file TAPsHETriMeshOneModelMultiParts.hpp.

00227 { m_tPredefinedTimeStep = ts; }

template<typename T>

void HETriMeshOneModelMultiParts< T >::StateToArray ( T * dst ) [inline, protected]

Definition at line 684 of file TAPsHETriMeshOneModelMultiParts.cpp.

00685 {
00686     //*
00687     for ( int i = 0; i < m_iStateSize; ++i ) {
00688         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[0];
00689         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[1];
00690         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[2];
00691         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[0];
00692         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[1];
00693         *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[2];
00694     }
00695     //*/
00696 }

Friends And Related Function Documentation

template<typename T>

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

Definition at line 92 of file TAPsHETriMeshOneModelMultiParts.hpp.

00093     {
00094         // NOT FINISHED YET!!!
00095 
00096         output  << "\n======================\n"
00097                 <<   "TAPs::HETriMeshOneModelMultiParts<"
00098                 << typeid(T).name() << "> Class:\n"
00099                 <<   "======================\n";
00100         //-----------------------------------------------------------
00101         output << "Name: " << o.GetName() << "\n";
00102         // Vertex Nodes
00103         output  << "\n\nVertices " << o.m_listVertex->Size();
00104         /*
00105         int i;
00106         i = 0;
00107         HEVertex<T> *vertex = o.m_listVertex->Head();
00108         output << "\n{";
00109         while ( vertex ) {
00110             output << "\n  #" << ++i << "\t" << *vertex;
00111             vertex = vertex->Next();
00112         }
00113         output  << "\n}";
00114         //*/
00115         //-----------------------------------------------------------
00116         // Face Nodes
00117         output  << "\n\nFaces " << o.m_listFace->Size();
00118         /*
00119         i = 0;
00120         HEFace<T> *face = o.m_listFace->Head();
00121         output << "\n{";
00122         while ( face ) {
00123             output << "\n  #" << ++i << "\t" << *face;
00124             face = face->Next();
00125         }
00126         output  << "\n}";
00127         //*/
00128         //-----------------------------------------------------------
00129         // Hole Face Nodes
00130         output  << "\n\nHole Faces " << o.m_listHoleFace->Size();
00131         /*
00132         i = 0;
00133         face = o.m_listHoleFace->Head();
00134         output << "\n{";
00135         while ( face ) {
00136             output << "\n  #" << ++i << "\t" << *face;
00137             face = face->Next();
00138         }
00139         output  << "\n}";
00140         //*/
00141         //-----------------------------------------------------------
00142         return output;
00143     }

Member Data Documentation

template<typename T>

std::vector< HEVertexPtrWithExtraInfo<T> * > HETriMeshOneModelMultiParts< T >::m_HEVertexList_1 [protected]

vertex list (Each vertex has a pointer to a particle ref and has a particle for home position.)

Definition at line 427 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

int HETriMeshOneModelMultiParts< T >::m_iLimitStepCount [protected]

Limit step count.

Definition at line 335 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

int HETriMeshOneModelMultiParts< T >::m_iNumSimSubSteps [protected]

number of simulation sub-steps for moving from current time to next time

Definition at line 338 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

int HETriMeshOneModelMultiParts< T >::m_iRigidity [protected]

number of spring hops

Definition at line 423 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

int HETriMeshOneModelMultiParts< T >::m_iStateSize [protected]

Mass Points (mesh vertices) where 6 = 3 positions + 3 velocities (for x,y,z)

Definition at line 334 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

std::vector< SimPropForMultiPartMeshModel_HalfEdge<T> > HETriMeshOneModelMultiParts< T >::m_Parts [protected]

list of parts

Definition at line 429 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

std::vector< HEVertexPtrWithExtraInfo<T> * >* HETriMeshOneModelMultiParts< T >::m_pHEVertexList [protected]

pointer to the vertex list

Definition at line 426 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

TAPs::MATH::ODESolver<T>* HETriMeshOneModelMultiParts< T >::m_prODESolver [protected]

ODE solver.

Definition at line 329 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

std::vector< ParticleRef<T> * > HETriMeshOneModelMultiParts< T >::m_svpParticleRef [protected]

particle reference list (Its size is the same as the size of vertex list.)

Definition at line 428 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tHomeKDamper [protected]

home spring damper constant

Definition at line 421 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tHomeKStiffness [protected]

home spring stiffness constant

Definition at line 420 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tKDamper [protected]

spring damper constant

Definition at line 419 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tKStiffness [protected]

spring stiffness constant

Definition at line 418 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

std::vector<int> HETriMeshOneModelMultiParts< T >::m_tmpForPuttingSpringRefIntoParts [protected]

Definition at line 291 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tPredefinedTimeStep [protected]

predefined time step in sec

Definition at line 337 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

T HETriMeshOneModelMultiParts< T >::m_tPtMass [protected]

mass of point (vertex)

Definition at line 417 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

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

pointers to spring

Definition at line 424 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

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

Definition at line 330 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

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

Definition at line 332 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

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

Definition at line 333 of file TAPsHETriMeshOneModelMultiParts.hpp.

template<typename T>

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

Definition at line 331 of file TAPsHETriMeshOneModelMultiParts.hpp.

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

G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsHETriMeshOneModelMultiParts.hpp
G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsHETriMeshOneModelMultiParts.cpp


Public Member Functions
virtual void	AdvanceSimulation (MATH::SimClock< T > &simClock)
	Advance a simulation step with a simulation clock.
virtual void	AdvanceSimulation (T tCurrent)
	Advance a simulation step with the predefined time step.
virtual void	AdvanceSimulation (T tCurrent, T tNext)
	Advance a simulation step.
virtual void	ApplyAndResetTransform ()
	Apply the current transformation to the model permanently. Then reset the transformation to identity.
void	CreateMeshSprings (T mass, T Ks, T Kd, T HKs, T HKd, int rigidity=1, T predefinedTimeStep=0.01, int numSimSubSteps=10, bool enableColDet=true, bool enableSimulation=true)
	Create mesh springs with home springs.
T	GetHomeKDamper () const
	Get home spring damping value.
T	GetHomeKStiffness () const
	Get home spring stiffness.
T	GetKDamper () const
	Get spring damping value.
T	GetKPointMass () const
	Get the mass value of point.
T	GetKStiffness () const
	Get spring stiffness.
std::vector < SimPropForMultiPartMeshModel_HalfEdge < T > > &	GetListOfParts ()
	Get list of parts.
int	GetNumSimSubSteps () const
	Get number of simulation sub-steps.
T	GetPredefinedTimeStep () const
	Get the predefined time step in sec.
SimPropForMultiPartMeshModel_HalfEdge < T > *	GetPtrToPartNo (unsigned int i)
	Get the pointer to part number.
int	GetRigidity () const
	Get rigidity value.
	HETriMeshOneModelMultiParts ()
	Default constructor.
virtual void	Initialize ()
	A virtual funciton from HalfEdgeModel ---> Model class for initialization.
void	SetHomeKDamper (T val)
void	SetHomeKStiffness (T val)
void	SetKDamper (T val)
void	SetKPointMass (T val)
void	SetKStiffness (T val)
void	SetNumSimSubSteps (int i)
	Set number of simulation sub-steps.
void	SetPredefinedTimeStep (T ts)
	Set the predefined time step in sec.
virtual	~HETriMeshOneModelMultiParts ()
	Destructor.
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	SeparateIntoParts (T mass, T Ks, T Kd, T HKs, T HKd, int rigidity, T predefinedTimeStep, int numSimSubSteps, bool enableColDet, bool enableSimulation)
	Separate the model into parts.
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
std::vector < HEVertexPtrWithExtraInfo< T > * >	m_HEVertexList_1
	vertex list (Each vertex has a pointer to a particle ref and has a particle for home position.)
int	m_iLimitStepCount
	Limit step count.
int	m_iNumSimSubSteps
	number of simulation sub-steps for moving from current time to next time
int	m_iRigidity
	number of spring hops
int	m_iStateSize
	Mass Points (mesh vertices) where 6 = 3 positions + 3 velocities (for x,y,z)
std::vector < SimPropForMultiPartMeshModel_HalfEdge < T > >	m_Parts
	list of parts
std::vector < HEVertexPtrWithExtraInfo< T > * > *	m_pHEVertexList
	pointer to the vertex list
TAPs::MATH::ODESolver< T > *	m_prODESolver
	ODE solver.
std::vector< ParticleRef< T > * >	m_svpParticleRef
	particle reference list (Its size is the same as the size of vertex list.)
T	m_tHomeKDamper
	home spring damper constant
T	m_tHomeKStiffness
	home spring stiffness constant
T	m_tKDamper
	spring damper constant
T	m_tKStiffness
	spring stiffness constant
std::vector< int >	m_tmpForPuttingSpringRefIntoParts
T	m_tPredefinedTimeStep
	predefined time step in sec
T	m_tPtMass
	mass of point (vertex)
std::vector< SpringRef< T > * >	m_vpSpringRef
	pointers to spring
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, HETriMeshOneModelMultiParts< T > const &o)

HETriMeshOneModelMultiParts< T > Class Template Reference

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

template<typename T> class HETriMeshOneModelMultiParts< T >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename T>
class HETriMeshOneModelMultiParts< T >