/* 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_UINT8);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
/* Output Port 1 */
outputDimsInfo.width = OUTPUT_1_WIDTH;
ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,1, OUTPUT_1_WIDTH, OUTPUT_DIMS_1_COL);
ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);
ssSetOutputPortDataType(S, 1, SS_UINT8);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
/* Output Port 2 */
outputDimsInfo.width = OUTPUT_2_WIDTH;
ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,2, OUTPUT_2_WIDTH, OUTPUT_DIMS_2_COL);
ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);
ssSetOutputPortDataType(S, 2, SS_UINT8);
ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);
/* Output Port 3 */
outputDimsInfo.width = OUTPUT_3_WIDTH;
ssSetOutputPortDimensionInfo(S, 3, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,3, OUTPUT_3_WIDTH, OUTPUT_DIMS_3_COL);
ssSetOutputPortFrameData(S, 3, OUT_3_FRAME_BASED);
ssSetOutputPortDataType(S, 3, SS_UINT16);
ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_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_WORKS_WITH_CODE_REUSE));
}
static void mdlInitializeSizes(SimStruct *S)
{
const real_T *P1 = mxGetData(PARAM_DEF3(S));
const real_T *P2 = mxGetData(PARAM_DEF2(S));
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */
#if defined(MATLAB_MEX_FILE)
if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(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;
/* Output Port 0 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,0, *P1, *P2);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_UINT8);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
/* Output Port 1 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,1, *P1, *P2);
ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);
ssSetOutputPortDataType(S, 1, SS_UINT8);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
/* Output Port 2 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,2, *P1, *P2);
ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);
ssSetOutputPortDataType(S, 2, SS_UINT8);
ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_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_WORKS_WITH_CODE_REUSE));
}
static void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port,
const DimsInfo_T *dimsInfo)
{
//TODO: for now accept the proposed size.
//If we want to change the behaviour we have to implement some callbacks
ssSetOutputPortDimensionInfo(S, port, dimsInfo);
}
static void mdlSetOutputPortDimensionInfo(SimStruct *S,
int_T port,
const DimsInfo_T *dimsInfo)
{
# ifdef DEBUG
printf(" co_udp_receiver :: Now in mdlSetOutputPortDimensionInfo.\n");
# endif
/*
* If the block has scalar parameter, the output dimensions are unknown.
* Set the input and output port to have the same dimensions.
*/
if(!ssSetOutputPortDimensionInfo(S, port, dimsInfo)) return;
/* The block only accepts 2-D signals. Check number of dimensions. */
if(dimsInfo->numDims != 1) {
ssSetErrorStatus(S, "Invalid output port dimensions. The output signal "
"must be a vector signal.");
return;
} else {
/* Set the input port dimensions */
if(!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return;
}
}
void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port,
const DimsInfo_T *dimsInfo)
{
if (port == 0) {
ssSetOutputPortDimensionInfo(S, port,dimsInfo);
ssSetInputPortDimensionInfo(S, port,dimsInfo);
}
} /* end mdlSetOutputPortDimensionInfo */
void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port,
const DimsInfo_T *dimsInfo)
{
if (port == 0) {
/* Set the size for all dynamic ports using dimsInfo */
ssSetInputPortDimensionInfo(S, port,dimsInfo);
ssSetOutputPortDimensionInfo(S, port, dimsInfo);
} else {
return;
}
} /*mdlSetInputPortDimensionInfo */
/* 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;
/* 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_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);
ssSetSimulinkVersionGeneratedIn(S, "8.7");
/* 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(inputDimsInfo);
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;
inputDimsInfo.width = INPUT_0_WIDTH;
ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo);
ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED);
ssSetInputPortDataType(S, 0, SS_UINT32);
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;
outputDimsInfo.width = OUTPUT_0_WIDTH;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_DOUBLE);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
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_WORKS_WITH_CODE_REUSE));
}
/* Function: mdlSetInputPortDimensionInfo ====================================
*/
static void mdlSetInputPortDimensionInfo(SimStruct *S,
int_T portIndex,
const DimsInfo_T *dimsInfo)
{
int outPortWidth = 0;
if(!ssSetInputPortDimensionInfo(S, portIndex, dimsInfo)) return;
outPortWidth = ssGetOutputPortWidth( S, 0 );
if ( outPortWidth == DYNAMICALLY_SIZED )
{
if(!ssSetOutputPortDimensionInfo(S, 0, dimsInfo)) return;
}
else if ( outPortWidth != dimsInfo->width )
{
ssSetErrorStatus(S,"Input port width not compatible with output port width.");
}
} /* mdlSetInputPortDimensionInfo */
/* Function: mdlInitializeSizes =========================================*/
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, 0); /* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return;
}
/* Register the number and type of states the S-Function uses */
ssSetNumContStates( S, 0); /* number of continuous states */
ssSetNumDiscStates( S, 0); /* number of discrete states */
ssAllowSignalsWithMoreThan2D(S);
/*
* Configure the input ports. First set the number of input ports.
*/
if (!ssSetNumInputPorts(S, 1)) return;
if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return;
ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED);
ssSetInputPortDirectFeedThrough(S, 0, 1);
/*
* Configure the output ports. First set the number of output ports.
*/
if (!ssSetNumOutputPorts(S, 1)) return;
if(!ssSetOutputPortDimensionInfo(S,0,DYNAMIC_DIMENSION)) return;
ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED);
ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES);
ssSetInputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOutputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);
/*
* Set size of the work vectors.
*/
ssSetNumRWork( S, 0); /* number of real work vector elements */
ssSetNumIWork( S, 0); /* number of integer work vector elements*/
ssSetNumPWork( S, 0); /* number of pointer work vector elements*/
ssSetNumModes( S, 0); /* number of mode work vector elements */
ssSetNumNonsampledZCs( S, 0); /* number of non-sampled zero crossings */
ssSetOptions(S, 0); /* general options (SS_OPTION_xx) */
} /* end mdlInitializeSizes */
void mdlSetDefaultPortDimensionInfo(SimStruct *S)
{
DECL_AND_INIT_DIMSINFO(dimsInfo);
/* Either 2nd input or 2nd output should be already known */
if (ssGetOutputPortWidth(S, 0) != DYNAMICALLY_SIZED) {
/* It is the output that is known, get the dimensions first */
dimsInfo.width = ssGetOutputPortWidth(S, 0);
dimsInfo.numDims = ssGetOutputPortNumDimensions(S, 0);
dimsInfo.dims = ssGetOutputPortDimensions(S, 0);
/*set second input, first output if unknown */
if (ssGetInputPortWidth(S, 0) == DYNAMICALLY_SIZED) {
if(!ssSetInputPortDimensionInfo(S, 0, &dimsInfo)) return;
}
return;
}
else {
if (ssGetInputPortWidth(S, 0) != DYNAMICALLY_SIZED) {
/* It is the input that is known, get the dimensions */
dimsInfo.width = ssGetInputPortWidth(S, 0);
dimsInfo.numDims = ssGetInputPortNumDimensions(S, 0);
dimsInfo.dims = ssGetInputPortDimensions(S, 0);
/*set first and second output if unknown */
if (ssGetOutputPortWidth(S, 0) == DYNAMICALLY_SIZED) {
if(!ssSetOutputPortDimensionInfo(S, 0, &dimsInfo)) return;
}
return;
}
else
{
/* Default everything to a scalar signal */
ssSetOutputPortVectorDimension(S, 0, 1);
ssSetInputPortVectorDimension(S, 0, 1);
return;
}
}
} /* end mdlSetDefaultPortDimensionInfo */
static void mdlSetDefaultPortDimensionInfo(SimStruct *S)
{
DECL_AND_INIT_DIMSINFO(portDimsInfo);
int_T dims[2] = { INPUT_0_WIDTH, 1 };
bool frameIn = ssGetInputPortFrameData(S, 0) == FRAME_YES;
/* Neither the input nor the output ports have been set */
portDimsInfo.width = INPUT_0_WIDTH;
portDimsInfo.numDims = frameIn ? 2 : 1;
portDimsInfo.dims = frameIn ? dims : &portDimsInfo.width;
if (ssGetInputPortNumDimensions(S, 0) == (-1)) {
ssSetInputPortDimensionInfo(S, 0, &portDimsInfo);
}
portDimsInfo.width = OUTPUT_0_WIDTH;
dims[0] = OUTPUT_0_WIDTH;
dims[1] = 1;
portDimsInfo.dims = frameIn ? dims : &portDimsInfo.width;
if (ssGetOutputPortNumDimensions(S, 0) == (-1)) {
ssSetOutputPortDimensionInfo(S, 0, &portDimsInfo);
}
return;
}
static void mdlSetOutputPortDimensionInfo(SimStruct *S,
int_T port,
const DimsInfo_T *dimsInfo)
{
if (!ssSetOutputPortDimensionInfo(S, port, dimsInfo)) return;
}
static void mdlInitializeSizes(SimStruct *S)
{
int_T param;
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
for( param=0; param<NPARAMS; param++ )
{
ssSetSFcnParamTunable(S,param,false);
}
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 1);
ssAllowSignalsWithMoreThan2D(S);
if (!ssSetNumInputPorts(S, 0)) return;
if (!ssSetNumOutputPorts(S, 2)) return;
{
DECL_AND_INIT_DIMSINFO(di);
int_T dims[3];
di.numDims = (intval(mxGetPr(paramPixelFormat)[0]) == 1 ? 2 : 3);
dims[0] = intval(mxGetPr(paramImageSizeXYN)[1]);
dims[1] = intval(mxGetPr(paramImageSizeXYN)[0]);
dims[2] = (intval(mxGetPr(paramPixelFormat)[0]) == 1 ? 1 : 3);
if ((mxGetNumberOfElements(paramImageSizeXYN) == 3) && (intval(mxGetPr(paramImageSizeXYN)[2])) > 1)
{
dims[1] *= intval(mxGetPr(paramImageSizeXYN)[2]);
}
di.dims = dims;
di.width = dims[0]*dims[1]*dims[2];
ssSetOutputPortDimensionInfo(S, 0, &di);
}
ssSetOutputPortDataType( S, 0, SS_UINT8 );
ssSetOutputPortComplexSignal(S, 0, 0);
ssSetOutputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_GLOBAL);
ssSetOutputPortWidth(S, 1, 1);
ssSetOutputPortDataType( S, 1, SS_UINT32 );
ssSetOutputPortComplexSignal(S, 1, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
/* Reserve place for C objects */
ssSetNumPWork(S, 1);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
/* Take care when specifying exception free code - see sfuntmpl_doc.c */
ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);
}
/* 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_T nInputPorts = 1; /* number of input ports */
int_T nOutputPorts = 1; /* number of output ports */
int_T needsInput = 1; /* direct feed through */
int_T inputPortIdx = 0;
int_T outputPortIdx = 0;
ssSetNumSFcnParams(S, 0); /* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return;
}
if (ssGetErrorStatus(S) != NULL) return;
/* Register the number and type of states the S-Function uses */
ssSetNumContStates( S, 0); /* number of continuous states */
ssSetNumDiscStates( S, 0); /* number of discrete states */
/*
* Configure the input ports. First set the number of input ports.
*/
if (!ssSetNumInputPorts(S, nInputPorts)) return;
if(!ssSetInputPortDimensionInfo(S, inputPortIdx, DYNAMIC_DIMENSION)) return;
ssSetInputPortWidth(S, inputPortIdx, DYNAMICALLY_SIZED);
ssSetInputPortRequiredContiguous(S, inputPortIdx, TRUE); /*direct input signal access*/
ssSetInputPortDataType(S, inputPortIdx,DYNAMICALLY_TYPED);
ssSetInputPortDirectFeedThrough(S, inputPortIdx,TRUE);
ssSetInputPortOverWritable(S, inputPortIdx, FALSE);
ssSetInputPortReusable(S, inputPortIdx,TRUE);
ssSetInputPortComplexSignal( S, inputPortIdx, COMPLEX_INHERITED);
/*
* Configure the output ports. First set the number of output ports.
*/
if (!ssSetNumOutputPorts(S, nOutputPorts)) return;
if(!ssSetOutputPortDimensionInfo(S,outputPortIdx,DYNAMIC_DIMENSION)) return;
ssSetOutputPortWidth(S, outputPortIdx, DYNAMICALLY_SIZED);
/* register data type
*/
ssSetOutputPortDataType( S, outputPortIdx, DYNAMICALLY_TYPED );
ssSetOutputPortReusable( S, outputPortIdx, TRUE);
ssSetOutputPortComplexSignal(S, outputPortIdx, COMPLEX_INHERITED );
ssSetNumSampleTimes( S, 1); /* number of sample times */
/*
* Set size of the work vectors.
*/
ssSetNumRWork( S, 0); /* number of real work vector elements */
ssSetNumIWork( S, 0); /* number of integer work vector elements*/
ssSetNumPWork( S, 0); /* number of pointer work vector elements*/
ssSetNumModes( S, 0); /* number of mode work vector elements */
ssSetNumNonsampledZCs( S, 0); /* number of nonsampled zero crossings */
ssSetOptions( S, 0); /* general options (SS_OPTION_xx) */
ssFxpSetU32BitRegionCompliant(S, 1);
} /* end mdlInitializeSizes */
/* Function: mdlSetOutputPortDimensionInfo ================================
* Abstract:
* This method is called with the candidate dimensions for an output port
* with unknown dimensions. If the proposed dimensions are acceptable, the
* method should go ahead and set the actual port dimensions.
* If they are unacceptable an error should be generated via
* ssSetErrorStatus.
* Note that any other input or output ports whose dimensions are
* implicitly defined by virtue of knowing the dimensions of the given
* port can also have their dimensions set.
*
*/
static void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T portIndex, const DimsInfo_T *dimsInfo)
{
/* Set output port dimension */
if(!ssSetOutputPortDimensionInfo(S, portIndex, dimsInfo)) return;
}
