CNetStructureTest.h

 
 
#ifndef CNetStructureTest_H
#define CNetStructureTest_H
 
//#define CNetStructure_DO_PROFILE
 
// Includes
#include <assert.h>
#include <string>
#include <vector>
#include <map>
 
#include <SimObject.h>
#include <CEnvironment.h>
 
#include "CNetCableElementTestSpec.h"
#include "CNetTwineElementSpec.h"
//#include "CNetMeshElementSpec.h"
 
#include "CNetCableElementTest.h"
#include "CNetTwineElement.h"
//#include "CNetMeshElement.h"
 
#include "CNetStructureTestSpec.h"
#ifdef FH_VISUALIZATION
    #include "sfh/ogre/NMeshGenerators.h"
    #include "sfh/ogre/C3DLine.h"
    #include <CTextRenderer.h>
#endif
 
 
 
//Class definition
class CNetStructureTest : public SimObject
{
public:
    CNetStructureTest(std::string sSimObjectName, ISimObjectCreator *pCreator);
    virtual ~CNetStructureTest();
    virtual void OdeFcn(const double dT, const double *const adX, double *const adXDot, const bool bIsMajorTimeStep);
    virtual void InitialConditionSetup(const double dT, const double *const adCurrentIC, double *const adUpdatedIC, ISimObjectCreator *const pCreator);
    virtual void FinalSetup(const double dT, const double *const adX, ISimObjectCreator *const pCreator);
    const double * outExternalNodeForce(const double dT, const double *const adX, int iExtNode);
 
#ifdef FH_VISUALIZATION
    // Initial specification of the simObject geometry for rendering.
    virtual void RenderInit(Ogre::Root *const pOgreRoot, ISimObjectCreator *const pCreator);
    // Updating the simObject for rendering the next frame.
    virtual void RenderUpdate(const double dT, const double *const adX);
#endif
    const virtual double * dragReduction(const double T, const double *const X);
    const virtual double * projectedArea(const double T, const double *const X);
    const virtual double * projectedVelocity(const double T, const double *const X);
    const virtual double * dragForce( const double T, const double *const X );
    const virtual double * cableForce( const double T, const double *const X );
    const virtual double * appendixForce( const double T, const double *const X );
 
 
    double m_dragReduction;
    double m_projectedArea;
    double m_projectedVelocity;
 
    const virtual double * NodePos(const double dT, const double *const adX, int iExtNode);
    const virtual double * NodeVel(const double dT, const double *const adX, int iExtNode);
protected:
    virtual void AddExternalForces(const double dT, const double *const adX);
    virtual void AddCableForces(const double dT, const double *const adX);
    virtual void AddInputPorts(ISimObjectCreator *pCreator);
    
    virtual void CreateNetCables(std::vector<CNetCableElementTestSpec*> VCableElements, ISimObjectCreator *pCreator);
    virtual void CreateNetTwines(std::vector<const CNetTwineElementSpec*>   VCableElements, ISimObjectCreator *pCreator);
    //virtual void CreateNetMeshes(std::vector<const CNetMeshElementSpec*>  VCableElements, ISimObjectCreator *pCreator);
    
    virtual void CreateDataStructures();
    virtual void CreateOutputPorts(ISimObjectCreator *pCreator);
    std::vector< std::pair<std::string,int> >   CreateExternalNodeMap( std::string sTag, int* piUsed, CNetStructureTestSpec & NetSpec, ISimObjectCreator *pCreator);
 
#ifdef FH_VISUALIZATION
    #   pragma warning (disable : 4244) 
    bool m_bLineVisualization;
    int m_colorBy;
    //C3DLine *m_LineVisualizationPressure;
    C3DLine *m_Lines;
 
    static Ogre::ColourValue mapToColor( double val )
    {
        if(val <= 0.0){
            return Ogre::ColourValue(0.0            ,0.0            ,1.0            ); // Blue
        }else if(val >= 1.0){
            return Ogre::ColourValue(1.0            ,0.0            ,0.0            ); // Red
        }else if(val >= 0.75){
            return Ogre::ColourValue(1.0            ,4.0-val/0.25   ,0.0            ); // Red -> Yellow
        }else if(val >= 0.5){
            return Ogre::ColourValue(val/0.25-2.0   ,1.0            ,0.0            ); // Yellow -> Green
        }else if(val >= 0.25){
            return Ogre::ColourValue(0.0            ,1.0            ,2.0-val/0.25   ); // Green -> BlueGreen
        }else{
            return Ogre::ColourValue(0.0            ,val/0.25       ,1.0            ); // BlueGreen -> Blue
        }
    }
#endif 
 
    //bool m_bSymplecticHack;
    double m_dSymplecticStepsize;
 
 
 
    ISignalPort **m_apInExternalForces;
    ISignalPort *m_colorLimits;
    int *m_aIStatePos;
    int *m_aIStateVel;
    double*         m_NodeExternalForces;
 
    int m_iNumNodesInputForce;
    int m_iNumNodesOutputPosAndVel;
    int m_numCables;
    //int m_iNumNodesOriginal;
    int m_iNumNodesCalc;
    //int m_iNumNodeOutputs;
 
 
    CEnvironment*           m_pEnvironment;
    double m_currentVel[3];
    const double* currentVelocity(const double dT, const double * const adX);
 
 
    std::vector<CNetCableElementTest*>  m_cableElements;
    std::vector<CNetTwineElement*>      m_VpTwineElements;
    //std::vector<CNetMeshElement*>         m_VpMeshElements;
    float*                          m_afInertia;
    //float*                            m_afInertiaReciprocal;
    int**                           m_aaiCableConn;
    bool                            m_bFoldingPointRefinementUsed;
 
 
 
    std::vector< std::pair<std::string,int> > m_VsNodesOutputPosAndVel;
    std::vector< std::pair<std::string,int> > m_VsNodesInputForce;
    bool                    m_bUseTagForExternalNodes;
 
    double*     m_adNodeForce;
    unsigned int m_iNumTwinesCalc;
 
    int **m_netsurface;
 
    sfh::linalg::sse_vec3f *omp_posa;
    sfh::linalg::sse_vec3f *omp_posb;
    sfh::linalg::sse_vec3f *omp_vela;
    sfh::linalg::sse_vec3f *omp_velb;
    sfh::linalg::sse_vec3f *omp_velf;
 
    sfh::linalg::sse_vec3f *omp_forceA;
    sfh::linalg::sse_vec3f *omp_forceB;
    double m_dragForce[3];
    double m_cableForce[3];
    double m_appendixForce[3];
};
 
 
#endif