NetStructureTest.h

 
#ifndef CNetStructureTest_H
#define CNetStructureTest_H
 
// #define CNetStructure_DO_PROFILE
 
// Includes
#include "NetCableElementTestSpec.h"
#include "NetTwineElementSpec.h"
 
#include <assert.h>
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <map>
#include <string>
#include <vector>
#include <utility>
// #include "CNetMeshElementSpec.h"
 
#include "NetVec3f.h"
#include "NetCableElementTest.h"
#include "NetTwineElement.h"
// #include "CNetMeshElement.h"
 
#include "NetStructureTestSpec.h"
#ifdef FH_VISUALIZATION
#   include "sfh/ogre/C3DLine.h"
#   include "sfh/ogre/NMeshGenerators.h"
#endif
 
 
// Class definition
class NetStructureTest : public SimObject
{
public:
   NetStructureTest(std::string simObjectName, ISimObjectCreator* creator);
   virtual ~NetStructureTest();
   virtual void  OdeFcn(const double dT, const double* const adX, double* const adXDot) const;
   virtual void  InitialConditionSetup(const double dT, const double* const adCurrentIC, double* const adUpdatedIC, ISimObjectCreator* const creator);
   virtual void  FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator);
   const double* outExternalNodeForce(const double dT, const double* const adX, int extNode);
 
#ifdef FH_VISUALIZATION
   // Initial specification of the simObject geometry for rendering.
   virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
   // 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 extNode);
   const virtual double* NodeVel(const double dT, const double* const adX, int extNode);
 
protected:
   virtual void AddExternalForces(const double dT, const double* const adX) const;
   virtual void AddCableForces(const double dT, const double* const adX) const;
   virtual void AddInputPorts(ISimObjectCreator* creator);
 
   virtual void CreateNetCables(std::vector<NetCableElementTestSpec*> VCableElements, ISimObjectCreator* creator);
   virtual void CreateNetTwines(std::vector<const NetTwineElementSpec*> VCableElements, ISimObjectCreator* creator);
   // virtual void CreateNetMeshes(std::vector<const CNetMeshElementSpec*>  VCableElements, ISimObjectCreator *creator);
 
   virtual void                             CreateDataStructures();
   virtual void                             CreateOutputPorts(ISimObjectCreator* creator);
   std::vector<std::pair<std::string, int>> CreateExternalNodeMap(std::string tag, int* piUsed, NetStructureTestSpec& NetSpec, ISimObjectCreator* creator);
 
#ifdef FH_VISUALIZATION
#   pragma warning(disable : 4244)
   bool m_lineVisualization;
   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_symplecticHack;
   double m_symplecticStepsize;
 
 
 
   ISignalPort** m_inExternalForces;
   ISignalPort*  m_colorLimits;
   int*          m_iStatePos;
   int*          m_iStateVel;
   double* m_NodeExternalForces;
 
   int m_numNodesInputForce;
   int m_numNodesOutputPosAndVel;
   int m_numCables;
   // int m_numNodesOriginal;
   int m_numNodesCalc;
   // int m_numNodeOutputs;
 
 
   environment::EnvironmentProvider* m_environment;
   mutable double                    m_currentVel[3];
   const double*                     currentVelocity(const double dT, const double* const adX);
   const double*                     currentVelocity(const double dT, const double* const adX) const;
 
 
   std::vector<NetCableElementTest*> m_cableElements;
   std::vector<NetTwineElement*>     m_VpTwineElements;
   // std::vector<CNetMeshElement*>         m_VpMeshElements;
   float* m_inertia;
   // float*                            m_inertiaReciprocal;
   int** m_aaiCableConn;
   bool  m_foldingPointRefinementUsed;
 
 
 
   std::vector<std::pair<std::string, int>> m_VsNodesOutputPosAndVel;
   std::vector<std::pair<std::string, int>> m_VsNodesInputForce;
   bool                                     m_useTagForExternalNodes;
 
   double*      m_nodeForce;
   unsigned int m_numTwinesCalc;
 
   int** m_netsurface;
 
   NetVec3f* omp_posa;
   NetVec3f* omp_posb;
   NetVec3f* omp_vela;
   NetVec3f* omp_velb;
   NetVec3f* omp_velf;
 
   NetVec3f* omp_forceA;
   NetVec3f* omp_forceB;
   double                  m_dragForce[3];
   double                  m_cableForce[3];
   double                  m_appendixForce[3];
};
 
 
#endif