mapinit.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 _MAPINIT_H
#define _MAPINIT_H


#include "map.h"


MAP_ERROR_CODE initialize_fortran_types(MAP_InputType_t* u_type, MAP_ParameterType_t* p_type, MAP_ContinuousStateType_t* x_type, MAP_ConstraintStateType_t* z_type, MAP_OtherStateType_t* other_type, MAP_OutputType_t* y_type, MAP_InitOutputType_t* initout_type);
MAP_ERROR_CODE allocate_outlist(Domain* data, char* map_msg, MAP_ERROR_CODE* ierr);


size_t cable_library_meter(const void* el);


size_t node_meter(const void* el);


size_t cable_line_meter(const void* el);


size_t u_list_meter(const void *el); 


void initialize_init_type_to_null(MAP_InitInputType_t* init_type);


void initialize_init_data_to_null(InitializationData* init_data);


void initialize_domain_to_null(Domain* domain);


void initialize_model_option_defaults(DomainOptions* options);


void initialize_inner_solve_data_defaults(InnerSolveAttributes* inner);


void initialize_vessel_to_null(Vessel* floater);


void initialize_outer_solve_data_defaults(OuterSolveAttributes* outer);


MAP_ERROR_CODE set_model_options_list(Domain* data, InitializationData* init, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE check_help_flag(bstring list);


MAP_ERROR_CODE check_inner_f_tol_flag(struct bstrList* list, double* ftol);


MAP_ERROR_CODE check_inner_g_tol_flag(struct bstrList* list, double* gtol);


MAP_ERROR_CODE check_inner_x_tol_flag(struct bstrList* list, double* xtol);


MAP_ERROR_CODE check_inner_max_its_flag(struct bstrList* list, int* max_its);


MAP_ERROR_CODE check_outer_max_its_flag(struct bstrList* list, int* max_its);


MAP_ERROR_CODE check_outer_tol_flag(struct bstrList* list, double* outer_tol);


MAP_ERROR_CODE check_outer_epsilon_flag(struct bstrList* list, double* epsilon);


MAP_ERROR_CODE check_outer_bd_flag(struct bstrList* list, FdType* bd);

MAP_ERROR_CODE check_outer_cd_flag(struct bstrList* list, FdType* cd);


MAP_ERROR_CODE check_outer_fd_flag(struct bstrList* list, FdType* fd);


MAP_ERROR_CODE check_pg_cooked_flag(struct bstrList* list, OuterSolveAttributes* solver);


MAP_ERROR_CODE check_powell_flag(struct bstrList* list, OuterSolveAttributes* solver);


MAP_ERROR_CODE check_integration_dt_flag(struct bstrList* list, double* dt);


MAP_ERROR_CODE check_kb_default_flag(struct bstrList* list, double* kb);


MAP_ERROR_CODE check_krylov_accelerator_flag(struct bstrList* list, OuterSolveAttributes* solver);


MAP_ERROR_CODE check_cb_default_flag(struct bstrList* list, double* cb);


MAP_ERROR_CODE check_wave_kinematics_flag(struct bstrList* list, bool* wave);


MAP_ERROR_CODE check_lm_model_flag(struct bstrList* list, bool* lm);


MAP_ERROR_CODE check_repeat_flag(struct bstrList* list, DomainOptions* options);


MAP_ERROR_CODE check_ref_position_flag(struct bstrList* list, Point* ref_position);


MAP_ERROR_CODE check_uncaught_flag(struct bstrList* list);


MAP_ERROR_CODE set_cable_library_list( Domain* domain, InitializationData* init_data, char* map_msg, MAP_ERROR_CODE* ierr );


MAP_ERROR_CODE set_library_diameter(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_mass_density(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_ea(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_cb(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_internal_damping(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_added_mass_coefficient(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_cross_flow_drag_coefficient(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE set_library_tangent_drag_coefficient(bstring word, CableLibrary* library_ptr);


MAP_ERROR_CODE reset_cable_library(CableLibrary* new_cable_library);


MAP_ERROR_CODE repeat_nodes(Domain* domain, InitializationData* init_data, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE set_node_list(const MAP_ParameterType_t* p_type,  MAP_InputType_t* u_type, MAP_ConstraintStateType_t* z_type, MAP_OtherStateType_t* other_type, MAP_OutputType_t* y_type, Domain* domain, struct bstrList* node_input_string, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE allocate_types_for_nodes(MAP_InputType_t* u_type, MAP_ConstraintStateType_t* z_type, MAP_OtherStateType_t* other_type, MAP_OutputType_t* y_type, Domain* domain, struct bstrList* node_input_string, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE reset_node(Node* node_ptr);
MAP_ERROR_CODE expand_node_number(const int n_line, bstring line); 
MAP_ERROR_CODE expand_node_type(const char* word, bstring line); 
MAP_ERROR_CODE expand_node_position_x(double* x, const char* word);
MAP_ERROR_CODE expand_node_position_y(double* y, const char* word);
MAP_ERROR_CODE expand_node_position_z(Vector* position, const double angle, const double x, const double y, const char* word, bstring line);
MAP_ERROR_CODE expand_node_mass(const char* word, bstring line); 
MAP_ERROR_CODE expand_node_buoyancy(const char* word, bstring line); 
MAP_ERROR_CODE expand_node_force_x(double* fx, const char* word); 
MAP_ERROR_CODE expand_node_force_y(double* fy, const char* word); 
MAP_ERROR_CODE expand_node_force_z(Vector* force, const double angle, const double fx, const double fy, const char* word, bstring line);


MAP_ERROR_CODE repeat_lines(Domain* domain, InitializationData* init, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE set_line_list(MAP_ConstraintStateType_t* z_type, Domain* domain, struct bstrList* line_input_string, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE reset_line(Line* line_ptr);
MAP_ERROR_CODE expand_line_number(const int n_line, bstring line); 
MAP_ERROR_CODE expand_line_property_name(const char* word, bstring line); 
MAP_ERROR_CODE expand_line_length(const char* word, bstring line); 
MAP_ERROR_CODE expand_line_anchor_number(const char* word, const int index, const int n, bstring line); 
MAP_ERROR_CODE expand_line_fairlead_number(const char* word, const int index, const int n, bstring line); 
MAP_ERROR_CODE expand_line_flag(const char* word, bstring line); 


MAP_ERROR_CODE set_vartype_ptr(const char* unit, bstring alias, const int num, VarTypePtr* type, bstring property);
MAP_ERROR_CODE set_vartype(const char* unit, bstring alias, const int num, VarType* type, bstring property );


MAP_ERROR_CODE compare_integer_length(const int a, const int b);


// MAP_ERROR_CODE set_line_vartype(Line* line_ptr, const int i); @rm
MAP_ERROR_CODE associate_line_with_cable_property(Line* line_ptr, Domain* domain, const char* word, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE associate_line_with_anchor_node(Line* line_ptr, Domain* domain, const int line_num, const char* word, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE associate_line_with_fairlead_node(Line* line_ptr, Domain* domain, const int line_num, const char* word, char* map_msg, MAP_ERROR_CODE* ierr);
MAP_ERROR_CODE set_line_option_flags(struct bstrList* word, int* index, Line* line_ptr, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE set_node_vartype(Node* node_ptr);


MAP_ERROR_CODE set_output_list(Domain* domain, MAP_InitOutputType_t* io_type, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE set_vessel(Vessel* floater, const MAP_InputType_t* u_type, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE set_vartype_float(const char* unit, const char* alias, const int num, VarType* type, const double value);


MAP_ERROR_CODE allocate_outer_solve_data(OuterSolveAttributes* ns, const int size, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE initialize_cable_library_variables(Domain* domain, MAP_ParameterType_t* p_type, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE first_solve(Domain* domain, MAP_ParameterType_t* p_type, MAP_InputType_t* u_type, MAP_ConstraintStateType_t* z_type, MAP_OtherStateType_t* other_type, MAP_OutputType_t* y_type, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE is_numeric(const char* string);


void log_initialization_information(MAP_InitInputType_t* init_type, MAP_ParameterType_t* p_type, MAP_OutputType_t* y_type, MAP_OtherStateType_t* other_type, Domain* domain, char* map_msg, MAP_ERROR_CODE* ierr);


MAP_ERROR_CODE associate_vartype_ptr(VarTypePtr* type, double* arr, int index);
void copy_target_string(char* target, unsigned char* source);
MAP_ERROR_CODE initialize_external_applied_force(char* unit, char* alias, const int num, VarType* type, char const* property);
MAP_ERROR_CODE initialize_node_sum_force_ptr(char* unit, char* alias, const int num, VarTypePtr* type);
MAP_ERROR_CODE map_get_version(MAP_InitOutputType_t* io_type);
MAP_ERROR_CODE print_help_to_screen();
size_t vartype_meter(const void* el);
size_t vartype_ptr_meter(const void *el);
const char* remove_first_character(const char* string);
void print_machine_name_to_screen();

MAP_ERROR_CODE associate_constraint_states(Domain* domain, MAP_ConstraintStateType_t* z_type);


#endif /* _INITIALIZATION_H */