map.h

/****************************************************************
 *   Copyright (C) 2014 mdm                                     *
 *   map[dot]plus[dot]plus[dot]help[at]gmail                    *
 *                                                              *
 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you under the Apache License, Version 2.0 (the            *
 * "License"); you may not use this file except in compliance   *
 * with the License.  You may obtain a copy of the License at   *
 *                                                              *
 *   http://www.apache.org/licenses/LICENSE-2.0                 *
 *                                                              *
 * Unless required by applicable law or agreed to in writing,   *
 * software distributed under the License is distributed on an  *
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
 * KIND, either express or implied.  See the License for the    *
 * specific language governing permissions and limitations      *      
 * under the License.                                           *  
 ****************************************************************/


#ifndef _MAP_H
#define _MAP_H


#include "mapsys.h"

#include "simclist/simclist.h"

#include "bstring/bstrlib.h"

#include "cminpack/cminpack.h"
#include "cminpack/cminpackP.h"
#include "cminpack/minpack.h"

#include "MAP_Types.h"
#include "maperror.h"
#include "lmroutines.hpp"

#ifdef WITH_LAPACK
#  include "lapack/lapacke.h"
#endif // WITH_LAPACK

typedef enum NodeType_enum {
  NONE,     
  FIX,      
  CONNECT,  
  VESSEL    
} NodeType;


typedef enum FdType_enum {
  BACKWARD_DIFFERENCE, 
  CENTRAL_DIFFERENCE,  
  FORWARD_DIFFERENCE   
} FdType;


typedef enum SolveType_enum {  
  MONOLITHIC,   
  PARTITIONED,  
  LUMPED_MASS   
} SolveType;


struct Fd_t {
  double* fx;
  double* fy;
  double* fz;
  double* mx;
  double* my;
  double* mz;
}; typedef struct Fd_t Fd;


struct VarType_t {
  bstring units;    
  bstring name;     
  double value;     
  bool is_fixed;    
  bool user_initial_guess; 
  int ref_counter;  
  int id;           
}; typedef struct VarType_t VarType;


struct VarTypePtr_t {
  bstring units;    
  bstring name;     
  double* value;   
  bool is_fixed;    
  int ref_counter;  
  int id;           
}; typedef struct VarTypePtr_t VarTypePtr;


struct Vector_t {
  double x;
  double y;
  double z;
}; typedef struct Vector_t Vector;
  

struct Point_t {
  VarType x;
  VarType y;
  VarType z;  
}; typedef struct Point_t Point;


struct PointPtr_t {
  VarTypePtr x;
  VarTypePtr y;
  VarTypePtr z;  
}; typedef struct PointPtr_t PointPtr;


struct EulerAngle_t {
  VarType phi;
  VarType the;
  VarType psi;  
}; typedef struct EulerAngle_t EulerAngle;


struct Force_t {
  VarType fx;
  VarType fy;
  VarType fz;  
}; typedef struct Force_t Force;


struct ForcePtr_t {
  VarTypePtr fx;
  VarTypePtr fy;
  VarTypePtr fz;  
}; typedef struct ForcePtr_t ForcePtr;


struct ReferencePoint_t {
  VarTypePtr* x;
  VarTypePtr* y;
  VarTypePtr* z;
}; typedef struct ReferencePoint_t ReferencePoint;


struct Vessel_t {
  EulerAngle orientation; 
  double* xi;             
  double* yi;             
  double* zi;             
  Point displacement;     
  Point ref_origin;       
  Force line_sum_force;   
}; typedef struct Vessel_t Vessel;



struct OutputList_t{
  list_t out_list;     
  list_t out_list_ptr; 
}; typedef struct OutputList_t OutputList;


typedef struct {
  bool gx_pos_flag;
  bool gy_pos_flag;
  bool gz_pos_flag;
  bool gx_anchor_pos_flag;
  bool gy_anchor_pos_flag;
  bool gz_anchor_pos_flag;
  bool gx_force_flag;
  bool gy_force_flag;
  bool gz_force_flag;
  bool H_flag; 
  bool V_flag;
  bool V_anchor_flag;
  bool H_anchor_flag;
  bool fairlead_tension_flag;
  bool anchor_tension_flag;
  bool horizontal_excursion_flag;
  bool vertical_excursion_flag;
  bool azimuth_flag;
  bool altitude_flag;
  bool altitude_anchor_flag;
  bool line_tension_flag;
  bool omit_contact;
  bool lay_length_flag;
  bool damage_time_flag;
  bool diagnostics_flag;
  bool linear_spring;                  
} LineOptions; 


struct CableLibrary_t {
  double diam;         
  double mass_density; 
  double EA;           
  double omega;        
  double a;            
  double cb;           
  double cd_i;         
  double ca;           
  double cd_n;         
  double cd_t;         
  bstring label;        
}; typedef struct CableLibrary_t CableLibrary;


struct Node_t {
  PointPtr acceleration;        
  PointPtr velocity;            
  PointPtr position_ptr;        
  NodeType type;
  ForcePtr sum_force_ptr;       
  VarType M_applied;
  VarType B_applied;
  Force external_force;    
}; typedef struct Node_t Node;


// struct LMAttributes {
//   void* lm_container; /**< container struct in lmroutines.hpp */
//   double* FlineS;     /**< retains last solution for when this is called with dT = 0 */   // 
//   double** rFairtS;   /**< fairlead locations ON TURBINE */                               // <--------- will be mapped to a Node_t list 
//   double** rFairRel;  /**< fairlead locations relative to platform center */              // <--------- will be mapped to a Node_t list 
//   double** rFairi;    /**< inertial Fairlead Locations  */                                // <--------- will be mapped to a Node_t list    
//   double** rdFairi;   /**< inertial Fairlead Velocities */                                // <--------- will be mapped to a Node_t list  
// 
//   // static vectors to hold line and connection objects!
//   // vector< LineProps > LinePropList; // to hold line library types   <--------- Moved to the Line_t struct
//   // vector< Line > LineList;          //  global and persistent?      <--------- Moved to a container struct in lmroutines.hpp to isolate c++ and c
//   // vector< Connection > ConnectList;                                 <--------- Moved to a container struct in lmroutines.hpp to isolate c++ and c
//   int nConnects; 
//   int nLines;
//   
//   // state vector and stuff
//   double* states;     /**< pointer to array comprising global state vector */
//   double* newstates;
//   int Nx;             /**< size of state vector array */
// 
//   // more state vector things for rk4 integration 
//   double* f0;
//   double* f1;
//   double* f2;
//   double* f3;
//   double* xt; 
// 
//   int* lineStateIs; /** vector of line starting indices in "states" array */ // vector< int > LineStateIs;  
//   int closed; // initialize to 0
//   double dt;  // FAST time step, @rm
//   double dts; /**< mooring line time step */
// }; typedef struct LMAttributes_t LMAttributes;


struct Line_t {
  CableLibrary* line_property; 
  // LMAttributes* lm_attributes; /**< Preserves information of the LM model from previous time steps */
  LineOptions options;         
  VarTypePtr H;                
  VarTypePtr V;                
  VarType Lu;                  
  bstring label;               
  double* line_tension;        
  double psi;                  
  double alpha;                
  double alpha_at_anchor;      
  double l;                    
  double Lb;                   
  double h;                    
  double H_at_anchor;          
  double V_at_anchor;          
  double T;                    
  double T_at_anchor;          
  double damage_time;          
  double residual_norm;       
  double fx_fairlead;
  double fy_fairlead;
  double fz_fairlead;
  double fx_anchor;
  double fy_anchor;
  double fz_anchor;
  list_t elements;             
  Node* anchor;                
  Node* fairlead;              
  int segment_size;
  int diagnostic_type;         
  int evals;                   
  int njac_evals;              
  int converge_reason;         /*   - info=0 : improper input parameters.
                                *   - info=1 : both actual and predicted relative reductions in the sum of squares are at most ftol.
                                *   - info=2 : relative error between two consecutive iterates is at most xtol.
                                *   - info=3 : conditions for info = 1 and info = 2 both hold.
                                *   - info=4 : the cosine of the angle between fvec and any column of the Jacobian is at most gtol in absolute value.
                                *   - info=5 : number of calls to fcn has reached or exceeded maxfev.
                                *   - info=6 : ftol is too small. No further reduction in the sum of squares is possible.
                                *   - info=7 : xtol is too small. No further improvement in the approximate solution x is possible.
                                *   - info=8 : gtol is too small. fvec is orthogonal to the columns of the Jacobian to machine precision.
                                */ 
}; typedef struct Line_t Line;


struct Element_t {
  double l;  
  Node* r1;  
  Node* r2;  
}; typedef struct Element_t Element;


struct InnerSolveAttributes_t {
  double** node_jac;
  double f_tol; 
  double g_tol; 
  double x_tol; 
  double x[2];               
  double fvec[2];            
  double fjac[4];            
  double wa1[2];             
  double wa2[2];             
  double wa3[2];             
  double wa4[2];             
  double diag[2];            
  double qtf[2];             
  double factor;             
  int max_its;   
  int ldfjac;                 
  int mode;             
  int nprint;           
  int info;             
  int ipvt[2];
  int m;                      
  int n;                      
}; typedef struct InnerSolveAttributes_t InnerSolveAttributes;



struct OuterSolveAttributes_t {
  FdType fd;
  double** AV;        
  double** V;         
  double* av;         
  double** jac;
  double** l;         
  double** u;         
  double* b;          
  double* C;          
  double* w;          
  double* q;          
  double* x;
  double* y;
  double ds;
  double d;
  double epsilon;
  double norm_error;
  double tol;
  double coef;
  bool pg;
  bool krylov_accelerator;
  bool powell;
  int max_krylov_its;
  int max_its;
  int iteration_count;
}; typedef struct OuterSolveAttributes_t OuterSolveAttributes;


struct DomainOptions_t {
  double* repeat_angle;
  double integration_dt;  
  double kb_lm;           
  double cb_lm;           
  bool wave_kinematics;   
  bool lm_model;          
  int repeat_angle_size;
}; typedef struct DomainOptions_t DomainOptions;


struct Domain_t {
  InnerSolveAttributes inner_loop; 
  OuterSolveAttributes outer_loop; 
  DomainOptions model_options;     
  OutputList* y_list;              
  SolveType MAP_SOLVE_TYPE;        
  Vessel vessel;                   
  list_t library;                  
  list_t line;                     
  list_t node;                     
  list_t u_update_list;            
  void* HEAD_U_TYPE;               
}; typedef struct Domain_t Domain;


struct InitializationData_t {
  struct bstrList* library_input_string;          
  struct bstrList* node_input_string;             
  struct bstrList* line_input_string;          
  struct bstrList* solver_options_string;         
  struct bstrList* expanded_node_input_string;    
  struct bstrList* expanded_line_input_string; 
  bstring summary_file_name;                      
}; typedef struct InitializationData_t InitializationData;


#endif /* _MAP_H */