static void mdlSetWorkWidths_c20_adcs_v15_integral_Power_nom(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { int_T chartIsInlinable = (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power_nom", "adcs_v15_integral_Power_nom",20); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power_nom", "adcs_v15_integral_Power_nom",20,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop( "adcs_v15_integral_Power_nom","adcs_v15_integral_Power_nom",20, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power_nom", "adcs_v15_integral_Power_nom",20,2); sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power_nom", "adcs_v15_integral_Power_nom",20,1); } sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power_nom", "adcs_v15_integral_Power_nom",20); ssSetHasSubFunctions(S,!(chartIsInlinable)); ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); } else { sf_set_sfun_dwork_info(S); } ssSetChecksum0(S,(1438108338U)); ssSetChecksum1(S,(2004638737U)); ssSetChecksum2(S,(2564207442U)); ssSetChecksum3(S,(1506645853U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED ); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_NONVOLATILE | SS_OPTION_WORKS_WITH_CODE_REUSE)); ssSupportsMultipleExecInstances(S, true); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 3); /* Number of expected parameters */ // Parameter mismatch will be reported by Simulink if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } ssSetSFcnParamTunable(S, 0, 0); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; // ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetNumSampleTimes(S, 1); ssSetNumPWork(S, 2); // reserve element in the pointers vector ssSetNumModes(S, 0); // to store a C++ object ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE); ssSetOptions(S, 0); }
static void mdlInitializeSizes(SimStruct * S) { ssSetNumSFcnParams(S, NUMBER_OF_ARGS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { sprintf(msg, "Wrong number of input arguments passed.\n" "%d arguments are expected\n", NUMBER_OF_ARGS); ssSetErrorStatus(S, msg); return; } if ( mxGetM(NO_BYTES_ARG)!=1 | mxGetN(NO_BYTES_ARG)!=1 ) { sprintf(msg,"Output port width argument must be a scalar\n"); ssSetErrorStatus(S,msg); return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumOutputPorts(S, 2); ssSetOutputPortWidth(S, 0, PORT_WIDTH); ssSetOutputPortDataType(S, 0, SS_UINT8); ssSetOutputPortWidth(S, 1, 1); /* received flag */ ssSetNumInputPorts(S, 0); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, NO_R_WORKS); ssSetNumIWork(S, NO_I_WORKS); ssSetNumPWork(S, NO_P_WORKS); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_PLACE_ASAP); }
static void mdlSetWorkWidths_c25_BuckBoost1(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_BuckBoost1_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 25); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,25,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,25, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,25,2); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,25,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,25); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(4024182556U)); ssSetChecksum1(S,(1214747070U)); ssSetChecksum2(S,(4268353638U)); ssSetChecksum3(S,(1673958578U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); ssSupportsMultipleExecInstances(S,1); }
static void mdlSetWorkWidths_c23_ArregloSeisPorSeis(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_ArregloSeisPorSeis_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 23); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,23,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,23, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,23,3); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,23,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,23); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(2281720516U)); ssSetChecksum1(S,(4132229721U)); ssSetChecksum2(S,(175296108U)); ssSetChecksum3(S,(991465833U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { DECL_AND_INIT_DIMSINFO(inputDimsInfo); DECL_AND_INIT_DIMSINFO(outputDimsInfo); ssSetNumSFcnParams(S, NPARAMS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, NUM_CONT_STATES); ssSetNumDiscStates(S, NUM_DISC_STATES); if (!ssSetNumInputPorts(S, NUM_INPUTS)) return; /*Input Port 0 */ inputDimsInfo.width = INPUT_0_WIDTH; ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,0, INPUT_0_WIDTH, INPUT_DIMS_0_COL); ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED); ssSetInputPortDataType(S, 0, SS_DOUBLE); ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX); ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
static void mdlSetWorkWidths_c31_adcs_v15_integral_Power_dist(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { int_T chartIsInlinable = (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power_dist", "adcs_v15_integral_Power_dist",31); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power_dist", "adcs_v15_integral_Power_dist",31,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop( "adcs_v15_integral_Power_dist","adcs_v15_integral_Power_dist",31, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power_dist", "adcs_v15_integral_Power_dist",31,2); sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power_dist", "adcs_v15_integral_Power_dist",31,1); } sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power_dist", "adcs_v15_integral_Power_dist",31); ssSetHasSubFunctions(S,!(chartIsInlinable)); ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); } else { sf_set_sfun_dwork_info(S); } ssSetChecksum0(S,(879351951U)); ssSetChecksum1(S,(3790118364U)); ssSetChecksum2(S,(4250711417U)); ssSetChecksum3(S,(1688137038U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
static void mdlInitializeSizes(SimStruct *S) { int i; ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } for (i = 0; i < NPARAMS; i++) ssSetSFcnParamTunable(S, i, 0); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortWidth(S, 0, 7); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortWidth(S, 1, DYNAMICALLY_SIZED); ssSetInputPortRequiredContiguous(S, 1, true); ssSetInputPortDirectFeedThrough(S, 1, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 12); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 5); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { int idx; /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, P_NPARMS); /* Number of expected parameters */ // No parameters will be tunable for(idx=0; idx<P_NPARMS; idx++){ ssSetSFcnParamNotTunable(S,idx); } if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumInputPorts(S,0); ssSetNumOutputPorts(S,2); ssSetOutputPortWidth(S,0,1); ssSetOutputPortWidth(S,1,8); ssSetOutputPortDataType(S,1,SS_UINT8); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, 0); }
static void mdlSetWorkWidths_c1_QPSK_Transmit_v5_w_FIFO(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_QPSK_Transmit_v5_w_FIFO_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 1); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,1,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,1, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,1,1); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,1,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,1); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(1382727465U)); ssSetChecksum1(S,(1826769868U)); ssSetChecksum2(S,(2925688491U)); ssSetChecksum3(S,(2188971603U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); ssSupportsMultipleExecInstances(S,1); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUM_PARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) return; } else{ return; /* Simulink will report a parameter mismatch error */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, mxGetScalar(NUMREG(S))); ssSetInputPortDirectFeedThrough(S, 0, 1); /* this is s static fcn: y = f(u) */ ssSetInputPortRequiredContiguous(S, 0, 1); /* there is only one scalar output */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); /* Preemptively clear user data pointer so we don't try to free it */ ssSetUserData(S, NULL); }
static void mdlSetWorkWidths_c19_adcs_v15_integral_Power(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { int_T chartIsInlinable = (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power", "adcs_v15_integral_Power",19); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power", "adcs_v15_integral_Power",19,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power", "adcs_v15_integral_Power",19,"gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power", "adcs_v15_integral_Power",19,2); sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power", "adcs_v15_integral_Power",19,4); } sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power","adcs_v15_integral_Power", 19); ssSetHasSubFunctions(S,!(chartIsInlinable)); ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); } else { sf_set_sfun_dwork_info(S); } ssSetChecksum0(S,(2325183243U)); ssSetChecksum1(S,(1124782313U)); ssSetChecksum2(S,(3778958781U)); ssSetChecksum3(S,(3844299426U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 1); // Number of expected parameters if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; // Parameter mismatch will be reported by Simulink } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 1); // Usado para actualizar las entradas if (!ssSetNumInputPorts(S,1)) return; ssSetInputPortWidth( S, 0, NENTRADAS ); ssSetInputPortRequiredContiguous( S, 0, 1 ); //for( k=0; k<NENTRADAS; k++ ) //{ // ssSetInputPortWidth(S,k,1); // ssSetInputPortDirectFeedThrough(S,k,1); // Existen llamadas de la entrada en la funcion mdlOutputs // ssSetInputPortRequiredContiguous(S,k,1); // sacado del ejemplo (?) //} if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth( S, 0, NSALIDAS ); //for( k=0; k<NSALIDAS; k++ ) //{ // ssSetOutputPortWidth(S, k, 1); //} ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); // reserve element in the float vector ssSetNumIWork(S, 0); // reserve element in the int vector ssSetNumPWork(S, 1); // reserve element in the pointers vector ssSetNumModes(S, 0); // to store a C++ object ssSetNumNonsampledZCs(S, 0); // number of states for which a block detects zero crossings ssSetOptions(S, 0); // set the simulation options that this block implements }
static void mdlSetWorkWidths_c8_WorkstationModel(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_WorkstationModel_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 8); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,8,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,8, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,8,2); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,8,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,8); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(357763525U)); ssSetChecksum1(S,(3399102434U)); ssSetChecksum2(S,(2626699010U)); ssSetChecksum3(S,(3249110271U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
static void mdlSetWorkWidths_c14_test(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_test_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 14); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,14,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,14, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,14,1); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,14,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,14); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(3719952874U)); ssSetChecksum1(S,(3080967292U)); ssSetChecksum2(S,(1156275868U)); ssSetChecksum3(S,(83615345U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); ssSupportsMultipleExecInstances(S,1); }
static void mdlInitializeSizes(SimStruct *S) { int i; ssSetNumSFcnParams(S, 4); /* B,x0,U,P Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return; else { if (CheckPar(S)) return; } ssSetNumContStates(S, (int) B(S,"CStates")); ssSetNumDiscStates(S, (int) B(S,"DStates")); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, (int) (U(S,"Number")+B(S,"Setpoints"))); ssSetInputPortDirectFeedThrough(S, 0, (int) B(S,"Direct")); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth(S, 0, (int) (U(S,"Number")+B(S,"Measurements")) ); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { DECL_AND_INIT_DIMSINFO(outputDimsInfo); ssSetNumSFcnParams(S, NPARAMS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, NUM_CONT_STATES); ssSetNumDiscStates(S, NUM_DISC_STATES); if (!ssSetNumInputPorts(S, NUM_INPUTS)) return; if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; /* Output Port 0 */ outputDimsInfo.width = OUTPUT_0_WIDTH; ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo); ssSetOutputPortMatrixDimensions( S ,0, OUTPUT_0_WIDTH, OUTPUT_DIMS_0_COL); ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED); ssSetOutputPortDataType(S, 0, SS_INT32); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); //ssSetSimulinkVersionGeneratedIn(S, "8.3"); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { DECL_AND_INIT_DIMSINFO(outputDimsInfo); ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif ssSetNumContStates(S, NUM_CONT_STATES); ssSetNumDiscStates(S, NUM_DISC_STATES); if (!ssSetNumInputPorts(S, NUM_INPUTS)) return; if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH); ssSetOutputPortDataType(S, 0, SS_DOUBLE); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 3); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 0, 0); //ssSetInputPortDataType(S,0,SS_DOUBLE); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 3); ssSetNumSampleTimes(S, 1); ssSetNumDWork(S, 2); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); //Pointer SHM_IN ssSetDWorkWidth(S, DVECSHMIN, 1); ssSetDWorkDataType(S, DVECSHMIN, SS_POINTER); //Pointer SHM_OUT ssSetDWorkWidth(S, DVECSHMOUT, 1); ssSetDWorkDataType(S, DVECSHMOUT, SS_POINTER); ssSetOptions(S, 0); }
static void mdlSetWorkWidths_c3_ErdMond(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_ErdMond_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 3); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,3,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,3, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,3,1); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,3,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,3); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(3937887197U)); ssSetChecksum1(S,(3357586017U)); ssSetChecksum2(S,(2777667438U)); ssSetChecksum3(S,(527445158U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S,NUMSFCNPARAMS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S,NUMCONTSTATES); ssSetNumDiscStates(S,NUMDISCSTATES); if (!ssSetNumInputPorts(S,NUMINPUTPORTS)) return; ssSetInputPortWidth(S,0,INPUTPORT0WIDTH); ssSetInputPortDirectFeedThrough(S,0,FEEDTHROUGHPORT0); if (!ssSetNumOutputPorts(S,NUMOUTPUTPORTS)) return; ssSetOutputPortWidth(S,0,OUTPUTPORT0WIDTH); ssSetNumSampleTimes(S,1); ssSetNumRWork(S,0); ssSetNumIWork(S,0); ssSetNumPWork(S,0); ssSetNumModes(S,0); ssSetNumNonsampledZCs(S,0); ssSetOptions(S,0); }
static void mdlSetWorkWidths_c10_dynamics_kinematics(SimStruct *S) { if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_dynamics_kinematics_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 10); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,10,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,10, "gatewayCannotBeInlinedMultipleTimes")); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,10,1); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,10,1); } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,10); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(3513034449U)); ssSetChecksum1(S,(1851740193U)); ssSetChecksum2(S,(3113117094U)); ssSetChecksum3(S,(3357094068U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); }
P_6 * ( ( BlockIO_main * ) _ssGetBlockIO ( S ) ) -> B_0_16_0 ; } } static void mdlInitializeSizes ( SimStruct * S ) { ssSetChecksumVal ( S , 0 , 3089498090U ) ; ssSetChecksumVal ( S , 1 , 49919693U ) ; ssSetChecksumVal ( S , 2 , 412083875U ) ; ssSetChecksumVal ( S , 3 , 3370502334U ) ; { mxArray * slVerStructMat = NULL ; mxArray * slStrMat = mxCreateString ( "simulink" ) ; char slVerChar [ 10 ] ; int status = mexCallMATLAB ( 1 , & slVerStructMat , 1 , & slStrMat , "ver" ) ; if ( status == 0 ) { mxArray * slVerMat = mxGetField ( slVerStructMat , 0 , "Version" ) ; if ( slVerMat == NULL ) { status = 1 ; } else { status = mxGetString ( slVerMat , slVerChar , 10 ) ; } } mxDestroyArray ( slStrMat ) ; mxDestroyArray ( slVerStructMat ) ; if ( ( status == 1 ) || ( strcmp ( slVerChar , "8.0" ) != 0 ) ) { return ; } } ssSetOptions ( S , SS_OPTION_EXCEPTION_FREE_CODE ) ; if ( ssGetSizeofDWork ( S ) != sizeof ( D_Work_main ) ) { ssSetErrorStatus ( S , "Unexpected error: Internal DWork sizes do " "not match for accelerator mex file." ) ; } if ( ssGetSizeofGlobalBlockIO ( S ) != sizeof ( BlockIO_main ) ) { ssSetErrorStatus ( S , "Unexpected error: Internal BlockIO sizes do " "not match for accelerator mex file." ) ; } { int ssSizeofParams ; ssGetSizeofParams ( S , & ssSizeofParams ) ; if ( ssSizeofParams != sizeof ( Parameters_main ) ) { static char msg [ 256 ] ; sprintf ( msg , "Unexpected error: Internal Parameters sizes do " "not match for accelerator mex file." ) ; } } _ssSetDefaultParam ( S , ( real_T * ) & main_rtDefaultParameters ) ; rt_InitInfAndNaN ( sizeof ( real_T ) ) ; } static void mdlInitializeSampleTimes ( SimStruct * S ) { } static
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetNumSampleTimes(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUMBER_OF_ARGS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; // ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. */ ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 0)) return; // ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, NO_I_WORKS); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } ssSetNumContStates(S, 2); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 2); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 1); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Call mdlCheckParameters to verify that the parameters are okay, * then setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { int_T intervalSize; ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif { int iParam = 0; int nParam = ssGetNumSFcnParams(S); for ( iParam = 0; iParam < nParam; iParam++ ) { ssSetSFcnParamTunable( S, iParam, SS_PRM_SIM_ONLY_TUNABLE ); } } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; /* * If the quantization interval is a vector, set the width * of the input and the output to be the same size as it. * Otherwise, set the widths to be DYNAMICALLY_SIZED. */ intervalSize = (mxGetM(QUANTIZATION_PARAM(S)) * mxGetN(QUANTIZATION_PARAM(S))); if (intervalSize > 1) { ssSetInputPortWidth (S, 0, intervalSize); ssSetOutputPortWidth(S, 0, intervalSize); } else { ssSetInputPortWidth (S, 0, DYNAMICALLY_SIZED); ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); } ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); }
static void mdlSetWorkWidths_c25_CusakisME4901arcs2(SimStruct *S) { /* Actual parameters from chart: m mb mt */ const char_T *rtParamNames[] = { "m", "mb", "mt" }; ssSetNumRunTimeParams(S,ssGetSFcnParamsCount(S)); /* registration for m*/ ssRegDlgParamAsRunTimeParam(S, 0, 0, rtParamNames[0], SS_DOUBLE); /* registration for mb*/ ssRegDlgParamAsRunTimeParam(S, 1, 1, rtParamNames[1], SS_DOUBLE); /* registration for mt*/ ssRegDlgParamAsRunTimeParam(S, 2, 2, rtParamNames[2], SS_DOUBLE); if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_CusakisME4901arcs2_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct, 25); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(), infoStruct,25,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S, sf_get_instance_specialization(),infoStruct,25, "gatewayCannotBeInlinedMultipleTimes")); sf_update_buildInfo(S,sf_get_instance_specialization(),infoStruct,25); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,25,1); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,25,1); } { unsigned int outPortIdx; for (outPortIdx=1; outPortIdx<=1; ++outPortIdx) { ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U); } } { unsigned int inPortIdx; for (inPortIdx=0; inPortIdx < 1; ++inPortIdx) { ssSetInputPortOptimizeInIR(S, inPortIdx, 1U); } } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,25); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(2702245221U)); ssSetChecksum1(S,(3247048464U)); ssSetChecksum2(S,(4066746145U)); ssSetChecksum3(S,(3712905929U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); ssSupportsMultipleExecInstances(S,1); }
static void mdlSetWorkWidths_c10_experiment_lib2(SimStruct *S) { /* Actual parameters from chart: a */ const char_T *rtParamNames[] = { "a" }; ssSetNumRunTimeParams(S,ssGetSFcnParamsCount(S)); /* registration for a*/ ssRegDlgParamAsRunTimeParam(S, 0, 0, rtParamNames[0], SS_DOUBLE); if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { mxArray *infoStruct = load_experiment_lib2_optimization_info(); int_T chartIsInlinable = (int_T)sf_is_chart_inlinable(sf_get_instance_specialization(),infoStruct, 10); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetRTWCG(S,sf_rtw_info_uint_prop(sf_get_instance_specialization(), infoStruct,10,"RTWCG")); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop (sf_get_instance_specialization(),infoStruct,10, "gatewayCannotBeInlinedMultipleTimes")); sf_update_buildInfo(sf_get_instance_specialization(),infoStruct,10); if (chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(), infoStruct,10,2); sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(), infoStruct,10,1); } { unsigned int outPortIdx; for (outPortIdx=1; outPortIdx<=1; ++outPortIdx) { ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U); } } { unsigned int inPortIdx; for (inPortIdx=0; inPortIdx < 2; ++inPortIdx) { ssSetInputPortOptimizeInIR(S, inPortIdx, 1U); } } sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,10); ssSetHasSubFunctions(S,!(chartIsInlinable)); } else { } ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); ssSetChecksum0(S,(324921852U)); ssSetChecksum1(S,(3643253733U)); ssSetChecksum2(S,(2128199589U)); ssSetChecksum3(S,(3048879468U)); ssSetmdlDerivatives(S, NULL); ssSetExplicitFCSSCtrl(S,1); ssSupportsMultipleExecInstances(S,1); }