CableBranched.h

#pragma once
 
#include "cable/subroutines/InternalCableWithBottomContact.h"
 
#include "sfh/timers/StopWatch.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/SeafloorForcesInterface.h>
#include <mutex>
#include <string>
 
#ifdef FH_VISUALIZATION
#   ifdef USE_BILLBOARD_LABELS
#      include "CMovableText.h"
#   endif
#endif
 
// Class definition
class CableBranched : public SimObject
{
public:
   CableBranched(std::string simObjectName, ISimObjectCreator* creator);
   CableBranched(std::string simObjectName)
       : SimObject(simObjectName)
   { }
   virtual void aFunction(std::string simObjectName, ISimObjectCreator* creator);
   ~CableBranched();
 
   // Member functions
   virtual void OdeFcn(const double dT, const double* const adX, double* const adXDot) const;
   void         PreOdeFcn(double T, const double* X, IStateUpdater* updater) override;
   bool         HasJacobians() const override;
   void         OdeJacobian(double T, const double* X, double* J, int nStates) override;
   int          GetJacobianSparsity(int nStates, int* rowPtr, int* colIdx) override;
   void         FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator);
   void         InitialConditionSetup(const double dT, const double* const adCurrentIC, double* const adUpdatedIC, ISimObjectCreator* const creator);
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
 
   void RenderUpdate(const double dT, const double* const adX);
#endif
 
protected:
   virtual void CreateStates(ISimObjectCreator* creator);
   void         CalcOutput(const double dT, const double* const adX) const;
   void         UpdateSectionLength(int element, double dT, const double* adX) const;
   virtual void PrepareSections(double /*dT*/, const double* /*adX*/) const { }
   void         OutputExternalConnForces(double dT, const double* adX);
   void         GetPosAndVelPointer(
         int                  node,
         double               dT,
         const double* const  adX,
         const double** const padPos,
         const double** const padVel) const;
 
   const double* GetPosPointer(
         int                 node,
         double              dT,
         const double* const adX) const;
 
 
   virtual void AddBottomForces(double dT, const double* const adX) const;
   virtual void CreateDataStructures();
   virtual void CreateInputports(ISimObjectCreator* creator);
   virtual void CreateOutputports(ISimObjectCreator* creator);
 
 
   void CheckNodeNumber(int nodeNumber, std::string nodeDescription, ISimObjectCreator* creator);
 
   ISignalPort**       m_inVel;      
   ISignalPort**       m_inPos;      
   ISignalPort**       m_inLength;   
   ICommonComputation* m_commonCalc; 
   const double*       ExternalForce(const double dT, const double* const adX, int i);
   const double*       ExternalTension(const double dT, const double* const adX, int i);
   const double*       SectionLength(const double dT, const double* const adX, int i);
   int*                m_iStatePos;        
   int*                m_iStateVel;        
   int*                m_iStateCable;      
   int                 m_iStateBase = 0;   
   mutable bool        m_inBottomContact = false; 
 
   int                 LocalIndex(int globalStateIndex) const { return globalStateIndex - m_iStateBase; }
   int                 m_numElements;      
   int                 m_numNodesCalc;     
   int                 m_numCableSections; 
   int                 m_numNodesGlobal;   
   int                 m_numExternalConn;  
   int*                m_nodeConnections;  
   int                 m_cableFaces;       
 
   // int*          m_numAEndsToExt;        ///< The number of elements with the A node connected to each external node.
   // int*          m_numBEndsToExt;        ///< The number of elements with the B node connected to each external node.
   // int**     m_aaiAEndsToExt;        ///< The elements with the A node connected to each external node.
   // int**     m_aaiBEndsToExt;        ///< The elements with the B node connected to each external node.
 
   // int*              m_numElementsPerSection;
   double  m_stepSafetyFactor;     
   double  m_eAdaptationPeriod;    
   double  m_numericalDamping;     
   double  m_maxStep;              
   double* m_meanTension;          
   double* m_stiffness;            
   double* m_relaxedLength;        
   double* m_relaxedLength_d;      
   double  m_maxLengthChangeSpeed; 
   double* m_dampingRatio;         
   double* m_density;              
   double* m_dE;                   
   double* m_diameter;             
   double* m_maxTension;           
   double* m_nodeInertia;          
   // double*               m_inertiaA;         ///< The inertia of the connected end A of each eleemnt.
   // double*               m_inertiaB;         ///< The inertia of the connected end B of each eleemnt.
   double* m_nodeForce; 
   double* m_outNodeForce   = nullptr; 
   double* m_outNodeInertia = nullptr; 
 
   mutable std::mutex m_sectionMutex;
   // double*               m_forceA;           ///< The force on the A nodes.
   // double*               m_forceB;           ///< The force on the B nodes.
   double*         m_lengths;      
   double*         m_outLengths = nullptr; 
   std::string     m_materialName; 
   double          m_drawScale;    
   double*         m_externalTensions;
   InternalCable** m_cableSections; 
 
   const double*                         m_padVelWater;
   environment::EnvironmentProvider*     m_environment;
   environment::SeafloorForcesInterface* m_seafloor;
   // bool              m_outputFcnCalled;
#ifdef FH_VISUALIZATION
#   ifdef USE_BILLBOARD_LABELS
   Ogre::SceneNode**    m_renderNode;
   Ogre::CMovableText** m_bBTxt;
   double               m_txtSize;
#   endif
#endif
};