NetStructureWithConstraints.h

#pragma once
 
#include <limits>
#include "CommonTypes.h"
 
// #define NetStructureWithConstraints_DO_PROFILE
 
// Includes
#include "NetBottomContactFilter.h"
#include "NetCableElementSpec.h"
#include "NetCableElementWithConstraints.h"
#include "NetElement3NWithConstraints.h"
#include "NetElementDef.h"
#include "NetPanelSetup.h"
#include "NetStructureSpec.h"
#include "NetFlowInteraction.h"
 
#include "sfh/timers/ProfilerWallclock.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fhsim_coribo/JointConstraint.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/SeafloorForcesInterface.h>
#include <memory>
#include <string>
 
 
#ifdef FH_VISUALIZATION
#   include "sfh/ogre/C3DLine.h"
#   include "sfh/ogre/NMeshGenerators.h"
#endif
 
// Class definition
class NetStructureWithConstraints : public SimObject
{
public:
   NetStructureWithConstraints(std::string simObjectName, ISimObjectCreator* creator);
   virtual ~NetStructureWithConstraints();
   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);
   void                PreOdeFcn(double T, const double* X, IStateUpdater* updater) override;
   const double* const outExternalNodeForce(const double dT, const double* const adX, int extNode);
 
#ifdef FH_VISUALIZATION
   virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
   virtual void RenderUpdate(const double dT, const double* const adX);
 
   void     CreateCapsule(Ogre::ManualObject* capsule_manual);
   C3DLine* myline;
#endif
   const virtual double* const NodePos(const double dT, const double* const adX, int extNode);
   const virtual double* const NodeVel(const double dT, const double* const adX, int extNode);
   const virtual double* const BottomContact(const double dT, const double* const adX);
   void                        SetAddedDragPerMPS(double AddedDragPerMPS);
   const virtual double* const NodeForce(const double dT, const double* const adX, int extNode) const; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
protected:
   virtual void   CalcStateDerivatives(const double* const adX, double* const adXDot) const;
   virtual void   AddExternalForces(const double dT, const double* const adX) const;
   virtual void   AddNetForces(const double dT, const double* const adX) const;
   virtual void   AddCableForces(const double dT, const double* const adX) const;
   void           AddNetAndCableForcesInParallel(double T, const double* X) const;
   void           AddNetForceRange(double T, const double* X, int begin, int end, double* nodeForce) const;
   void           AddCableForceRange(double T, const double* X, int begin, int end, double* nodeForce, bool waterFollowsElement = false) const;
   void           CableHydrodynamicForce(double T, const double* X, double force[3]) const;
   void           FlowAt(double T, int point, const double pos[3], double vel[3]) const;
   void           UpdateNodeWaveVelocities(double T, const double* X, int firstNode, int endNode) const;
   mutable std::vector<double> m_nodeWaveVelocity; 
   virtual double AddNodeBottomForce(const double* const adX, int node, double diam, double adForceInOut[3]) const;
   virtual void   AddBottomForces(const double* const adX) const;
   virtual void   AddInputPorts(ISimObjectCreator* creator);
   virtual void   CreateNetPanels(std::vector<const NetElementDef*> VNetElementDefs, ISimObjectCreator* creator);
   virtual void   CreateNetCables(std::vector<const NetCableElementSpec*> VCableElements, ISimObjectCreator* creator);
   virtual void   CreateDataStructures();
   virtual void   CreateOutputPorts(ISimObjectCreator* creator);
   VSPairStrInt   CreateExternalNodeMap(std::string tag, int* piUsed, NetStructureSpec& NetSpec, ISimObjectCreator* creator);
   void           ValidateConstraintInput(ISimObjectCreator* creator) const;
   void           PRINTALLNODEFORCES(std::string spec, double dT);
 
   void SetExternalPos(const double dT, const double* const adX) const; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   void SetExternalVel(const double dT, const double* const adX) const; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
 
   // ISignalPort **m_inExternalForces;
   /*ISignalPort **m_InConstraintsPos;                                                                  // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   ISignalPort **m_InConstraintsVel;                                                                    // NEW: added to test new approach where pos and vel for selected nodes are set by external objects*/
   ISignalPort** m_InTopConstraintsPos;
   ISignalPort** m_InTopConstraintsVel;
   int*          m_iStatePos;
   int*          m_iStateVel;
   double* m_NodeExternalForces;
   double* m_NodeConstraintsPos; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   double* m_NodeConstraintsVel; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
   int m_numNodesInputForce;
   int m_numNodesOutputPosAndVel;
   int m_numPanelsCalc;
   int m_numCablesCalc;
   int m_numNodesOriginal;
   int m_numNodesCalc;
   int m_numNodeOutputs;
 
   double* m_NodeInternalForces; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
   int (*m_hasPosAndVelStates)[2]; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
   int m_NumNodesInputPosAndVel; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   int m_NumNodesOutputForce;    // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
   VSPairStrInt m_VsNodesInputPosAndVel; // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   VSPairStrInt m_VsNodesOutputForce;    // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
   // VSPairStrInt          m_VsNodesTopConstraintsInputPos;
 
 
 
   NetBottomContactFilter m_BottomContactFilter;
   double                 m_bottomContact[6];
 
   environment::EnvironmentProvider*     m_environment;
   environment::SeafloorForcesInterface* m_seafloor;
 
 
   net_panel_setup::PanelHydrodynamics m_panelHydrodynamics; 
   net_solidity::SolidityModel         m_solidityModel = net_solidity::kDefaultSolidityModel;
 
 
   template<class> friend class NetWakePanels; 
   std::unique_ptr<NetFlowInteraction> m_flow;            
   ISimObjectLogger*                   m_logger = nullptr; 
   hydrodynamics::PanelClampLog        m_clampLog;         
 
 
   std::vector<NetCableElementWithConstraints*> m_VpCableElements;
   std::vector<NetElement3NWithConstraints*>    m_VpNetElements;
   float*                                       m_inertia;
   int*                                         m_netConn;
   int**                                        m_aaiCableConn;
   SAdaptationSpec_t                            m_SAdaptations;
   bool                                         m_foldingPointRefinementUsed;
 
 
 
   VSPairStrInt m_VsNodesOutputPosAndVel;
   VSPairStrInt m_VsNodesInputForce;
   bool         m_useTagForExternalNodes;
 
   double*                        m_nodeForce;
   double m_meanTensionTime = std::numeric_limits<double>::quiet_NaN();
 
   bool m_CageWakeEffectsActive;
 
   // CONSTRAINTS (NB LOTS OF HARD CODING HERE NOW)
   CoRiBoDynamics::ConstraintSolver* m_constraintSolver;
   struct states
   {
      int p;
      int q;
      int w;
      int v;
   };
   std::vector<states>              m_stateVector;
 
   const double* NodePositionState(const double* X, int node) const { return X + (NodeHasOwnStates(node) ? m_iStatePos[node] : DrivingElement(node).p); }
   const double* NodeVelocityState(const double* X, int node) const { return X + (NodeHasOwnStates(node) ? m_iStateVel[node] : DrivingElement(node).v); }
   bool NodeHasOwnStates(int node) const { return m_hasPosAndVelStates[node][1] == 1; }
   const states& DrivingElement(int node) const { return m_stateVector[m_hasPosAndVelStates[node][0]]; }
 
   CoRiBoDynamics::JointConstraint* m_jointConstr;
   // Coordinates for attachment of the constraints chains
   mutable double m_topPosition1[3];
   mutable double m_topVelocity1[3];
   double         m_topOrientation1[4];
   double         m_topangularVel1[3];
   mutable double m_topPosition2[3];
   mutable double m_topVelocity2[3];
   double         m_topOrientation2[4];
 
   double m_topangularVel2[3];
 
   double m_YoungsModulus;
   double m_solverFrequencyCoefficient; 
   int    m_numThreads = 1;             
   mutable std::vector<double> m_threadNodeForces; 
   int    m_numConstraintsElements;
   double m_depthOfConstraintsCable;
#ifdef FH_VISUALIZATION
   Ogre::SceneNode** m_renderNodes; 
                                    // Ogre::SceneNode*     m_renderNode2;  ///< The node to which the rendered entity is attached.
#endif
 
#ifdef NetStructureWithConstraints_DO_PROFILE
   sfh::timers::ProfilerWallclock m_Profiler;
#endif
};