File: C:\MATLAB\work\fadingchannelconstructed_grt_rtw/fadingchannelconstructed.c

    1   /*
    2    * Real-Time Workshop code generation for Simulink model "fadingchannelconstructed.mdl".
    3    *
    4    * Model Version                        : 1.39
    5    * Real-Time Workshop file version      : 5.0 $Date: 2002/05/30 19:21:33 $
    6    * Real-Time Workshop file generated on : Wed Mar 17 14:58:13 2004
    7    * TLC version                          : 5.0 (Jun 18 2002)
    8    * C source code generated on           : Wed Mar 17 14:58:13 2004
    9    */
   10   
   11   #include <math.h>
   12   #include <string.h>
   13   #include "fadingchannelconstructed.h"
   14   #include "fadingchannelconstructed_private.h"
   15   
   16   /* Block signals (auto storage) */
   17   BlockIO rtB;
   18   
   19   /* Block states (auto storage) */
   20   D_Work rtDWork;
   21   
   22   /* Parent Simstruct */
   23   static rtModel_fadingchannelconstructed model_S;
   24   rtModel_fadingchannelconstructed *const rtM_fadingchannelconstructed = &model_S;
   25   
   26   /* Initial conditions for root system: '<Root>' */
   27   void MdlInitialize(void)
   28   {
   29   
   30     /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */
   31     rtDWork.Integer_Delay_BUFF_OFFSET = 49;
   32     MWDSP_DelayCopyScalarICs( (byte_T *)&rtDWork.Integer_Delay_BUFF[0], (byte_T
   33       *)&rtP.Integer_Delay_IC, 1*51, sizeof(real_T) );
   34   
   35     /* DSP Blockset Filter Implementation (sdspfilter) - '<S5>/Direct-Form II Transpose Filter' */
   36     {
   37       real_T *statePtr = (real_T *) &rtDWork.Direct_Form_II_Tran_FILT_STATES[0];
   38       /* Scalar expansion of ICs with extra zero element per channel */
   39       int_T numElems = 100;
   40       while (numElems--) {
   41         *statePtr++ = *(const real_T *)&rtP.Direct_Form_II_Tran_ICRTP;
   42       }
   43       *statePtr = 0.0;
   44     }
   45   }
   46   
   47   /* Start for root system: '<Root>' */
   48   void MdlStart(void)
   49   {
   50   
   51     /* RandomNumber Block: <S2>/Random Number */
   52     {
   53       uint_T *RandSeed = (uint_T *) &rtDWork.Random_Number_a_IWORK.RandSeed;
   54       int_T r, t;
   55       *RandSeed = 41U;
   56       r = *RandSeed >> 16;
   57       t = *RandSeed & BIT16;
   58       *RandSeed = ((*RandSeed - (r << 16) - t) << 16) + t + r;
   59       if (*RandSeed < 1) {
   60         *RandSeed = SEED0;
   61       }
   62       if (*RandSeed > MAXSEED) {
   63         *RandSeed = MAXSEED;
   64       }
   65   
   66       rtDWork.Random_Number_a_RWORK.NextOutput =
   67         rt_NormalRand(RandSeed++) * rtP.Random_Number_a_StdDev +
   68         rtP.Random_Number_a_Mean;
   69     }
   70   
   71     /* DiscretePulseGenerator Block: <Root>/Pulse Generator */
   72     {
   73       int_T Ns;
   74       real_T tFirst = rtmGetTStart(rtM_fadingchannelconstructed);
   75       Ns = (int_T)floor(tFirst / 0.0002 + 0.5);
   76       if (Ns <= 0) {
   77         rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = Ns;
   78       } else {
   79         rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = Ns -
   80           (int_T)(rtP.Pulse_Generator_Period*floor((real_T)Ns /
   81           rtP.Pulse_Generator_Period));
   82       }
   83     }
   84   
   85     /* RandomNumber Block: <S3>/Random Number */
   86     {
   87       uint_T *RandSeed = (uint_T *) &rtDWork.Random_Number_b_IWORK.RandSeed;
   88       int_T r, t;
   89       *RandSeed = 41U;
   90       r = *RandSeed >> 16;
   91       t = *RandSeed & BIT16;
   92       *RandSeed = ((*RandSeed - (r << 16) - t) << 16) + t + r;
   93       if (*RandSeed < 1) {
   94         *RandSeed = SEED0;
   95       }
   96       if (*RandSeed > MAXSEED) {
   97         *RandSeed = MAXSEED;
   98       }
   99   
  100       rtDWork.Random_Number_b_RWORK.NextOutput =
  101         rt_NormalRand(RandSeed++) * rtP.Random_Number_b_StdDev +
  102         rtP.Random_Number_b_Mean;
  103     }
  104   
  105     /* ToWorkspace Block: <Root>/To Workspace */
  106     {
  107       static const int_T rt_ToWksWidths[] = {1};
  108       static const int_T rt_ToWksNumDimensions[] = {1};
  109       static const int_T rt_ToWksDimensions[] = {1};
  110       static const BuiltInDTypeId rt_ToWksDataTypeIds[] = {SS_DOUBLE};
  111       static const int_T rt_ToWksComplexSignals[] = {0};
  112       static const int_T rt_ToWksFrameData[] = {0};
  113       static const char_T rt_ToWksLabels[] = "";
  114       static const RTWLogSignalInfo rt_ToWksSignalInfo = {
  115         1,
  116         rt_ToWksWidths,
  117         rt_ToWksNumDimensions,
  118         rt_ToWksDimensions,
  119         rt_ToWksDataTypeIds,
  120         rt_ToWksComplexSignals,
  121         rt_ToWksFrameData,
  122         rt_ToWksLabels,
  123         NULL,
  124         NULL,
  125         NULL,
  126         NULL,
  127         NULL,
  128         NULL
  129       };
  130       static const char_T rt_ToWksBlockName[] =
  131         "fadingchannelconstructed/To Workspace";
  132   
  133       rtDWork.To_Workspace_PWORK.LoggedData =
  134         rt_CreateStructLogVar(rtM_fadingchannelconstructed->rtwLogInfo,
  135         rtM_fadingchannelconstructed->Timing.tFinal,
  136         rtM_fadingchannelconstructed->Timing.stepSize,
  137         &(rtmGetErrorStatus(rtM_fadingchannelconstructed)), "RayleighPDFOutput",
  138         0, 0, 1, 0.0002, &rt_ToWksSignalInfo, rt_ToWksBlockName);
  139   
  140       if (rtDWork.To_Workspace_PWORK.LoggedData == NULL) return;
  141     }
  142   
  143     /* ToWorkspace Block: <Root>/To Workspace1 */
  144     {
  145       static const int_T rt_ToWksWidths[] = {1};
  146       static const int_T rt_ToWksNumDimensions[] = {1};
  147       static const int_T rt_ToWksDimensions[] = {1};
  148       static const BuiltInDTypeId rt_ToWksDataTypeIds[] = {SS_DOUBLE};
  149       static const int_T rt_ToWksComplexSignals[] = {0};
  150       static const int_T rt_ToWksFrameData[] = {0};
  151       static const char_T rt_ToWksLabels[] = "";
  152       static const RTWLogSignalInfo rt_ToWksSignalInfo = {
  153         1,
  154         rt_ToWksWidths,
  155         rt_ToWksNumDimensions,
  156         rt_ToWksDimensions,
  157         rt_ToWksDataTypeIds,
  158         rt_ToWksComplexSignals,
  159         rt_ToWksFrameData,
  160         rt_ToWksLabels,
  161         NULL,
  162         NULL,
  163         NULL,
  164         NULL,
  165         NULL,
  166         NULL
  167       };
  168       static const char_T rt_ToWksBlockName[] =
  169         "fadingchannelconstructed/To Workspace1";
  170   
  171       rtDWork.To_Workspace1_PWORK.LoggedData =
  172         rt_CreateStructLogVar(rtM_fadingchannelconstructed->rtwLogInfo,
  173         rtM_fadingchannelconstructed->Timing.tFinal,
  174         rtM_fadingchannelconstructed->Timing.stepSize,
  175         &(rtmGetErrorStatus(rtM_fadingchannelconstructed)), "AWGN", 0, 0, 1,
  176         0.0002, &rt_ToWksSignalInfo, rt_ToWksBlockName);
  177   
  178       if (rtDWork.To_Workspace1_PWORK.LoggedData == NULL) return;
  179     }
  180   
  181     MdlInitialize();
  182   }
  183   
  184   /* Outputs for root system: '<Root>' */
  185   void MdlOutputs(int_T tid)
  186   {
  187     /* local block i/o variables */
  188     creal_T rtb_Join;
  189     real_T rtb_Reshape_a;
  190     real_T rtb_Complex_to_Real_Imag_o1;
  191     real_T rtb_Complex_to_Real_Imag_o2;
  192     real_T rtb_Reshape_b;
  193     real_T rtb_temp15;
  194   
  195     /* tid is required for a uniform function interface. This system
  196      * is single rate, and in this case, tid is not accessed. */
  197     UNUSED_PARAMETER(tid);
  198   
  199     /* RandomNumber: '<S2>/Random Number' */
  200     rtB.Random_Number_a = rtDWork.Random_Number_a_RWORK.NextOutput;
  201   
  202     /* DiscreteStateSpace: '<S7>/Discrete State-Space' */
  203     {
  204       rtb_temp15 = rtP.Discrete_State_Space_a_D*rtB.Random_Number_a;
  205     }
  206   
  207     /* ZeroOrderHold Block: '<S6>/zoh'
  208      *
  209      * Regarding '<S6>/zoh':
  210      *   Eliminated since input and output rates are identical
  211      */
  212   
  213     /* Sum: '<S2>/Sum' incorporates:
  214      *   Constant: '<S6>/Constant'
  215      */
  216     rtB.Sum_a = rtb_temp15 + rtP.Constant_a_Value;
  217   
  218     /* DSP Blockset Buffer/Unbuffer (sdsprebuff2) - '<S2>/Buffer' */
  219     {
  220       rtB.Buffer_a = rtB.Sum_a;
  221     }
  222   
  223     /* S-Function Block: <S2>/Reshape */
  224     rtb_Reshape_a = rtB.Buffer_a;
  225   
  226     /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */
  227   
  228     {
  229       int_T ti = rtDWork.Integer_Delay_BUFF_OFFSET;
  230   
  231       memcpy(&rtb_temp15, ((byte_T *) &rtDWork.Integer_Delay_BUFF[0] +
  232         (ti*sizeof(real_T))), sizeof(real_T));
  233     }
  234   
  235     /* DiscretePulseGenerator: '<Root>/Pulse Generator' */
  236     rtB.Pulse_Generator =
  237       (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter < rtP.Pulse_Generator_Duty
  238       &&
  239       rtDWork.Pulse_Generator_IWORK.ClockTicksCounter >= 0) ?
  240      rtP.Pulse_Generator_Amp :
  241       0.0;
  242     if (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter >=
  243      rtP.Pulse_Generator_Period-1) {
  244       rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = 0;
  245     } else {
  246       (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter)++;
  247     }
  248   
  249     /* DSP Blockset Filter Implementation (sdspfilter) - '<S5>/Direct-Form II Transpose Filter' */
  250     /* Filter algorithm: IIR Direct-Form II Transpose (double precision floating-point) */
  251     /* Complexities: input - real, num coeffs - real, den coeffs - real */
  252     /* Implementing filter algorithm */
  253     MWDSP_IIR_DF2T_DD(&rtB.Pulse_Generator, &rtB.Direct_Form_II_Tran,
  254      &rtDWork.Direct_Form_II_Tran_FILT_STATES[0], 101, 1, 1,
  255      &rtP.Direct_Form_II_Tran_RTP1COEFF[0], 100,
  256      &rtP.Direct_Form_II_Tran_RTP2COEFF, 0, 1);
  257   
  258     /* RealImagToComplex: '<S1>/Join' */
  259     rtb_Join.re = rtb_temp15;
  260     rtb_Join.im = rtB.Direct_Form_II_Tran;
  261   
  262     /* ComplexToRealImag: '<Root>/Complex to Real-Imag' */
  263     rtb_Complex_to_Real_Imag_o1 = rtb_Join.re;
  264     rtb_Complex_to_Real_Imag_o2 = rtb_Join.im;
  265   
  266     /* RandomNumber: '<S3>/Random Number' */
  267     rtB.Random_Number_b = rtDWork.Random_Number_b_RWORK.NextOutput;
  268   
  269     /* DiscreteStateSpace: '<S11>/Discrete State-Space' */
  270     {
  271       rtb_temp15 = rtP.Discrete_State_Space_b_D*rtB.Random_Number_b;
  272     }
  273   
  274     /* ZeroOrderHold Block: '<S10>/zoh'
  275      *
  276      * Regarding '<S10>/zoh':
  277      *   Eliminated since input and output rates are identical
  278      */
  279   
  280     /* Sum: '<S3>/Sum' incorporates:
  281      *   Constant: '<S10>/Constant'
  282      */
  283     rtB.Sum_b = rtb_temp15 + rtP.Constant_b_Value;
  284   
  285     /* DSP Blockset Buffer/Unbuffer (sdsprebuff2) - '<S3>/Buffer' */
  286     {
  287       rtB.Buffer_b = rtB.Sum_b;
  288     }
  289   
  290     /* S-Function Block: <S3>/Reshape */
  291     rtb_Reshape_b = rtB.Buffer_b;
  292   
  293     /* Sum: '<Root>/Sum' incorporates:
  294      *   Product: '<Root>/Product1'
  295      *   Product: '<Root>/Product2'
  296      */
  297     rtb_temp15 = (rtb_Reshape_a * rtb_Complex_to_Real_Imag_o1)
  298       + (rtb_Complex_to_Real_Imag_o2 * rtb_Reshape_b);
  299   
  300     /* ToWorkspace: '<Root>/To Workspace' */
  301   
  302     rt_UpdateStructLogVar(rtDWork.To_Workspace_PWORK.LoggedData, NULL,
  303      &rtb_temp15);
  304   
  305     /* ToWorkspace: '<Root>/To Workspace1' */
  306   
  307     rt_UpdateStructLogVar(rtDWork.To_Workspace1_PWORK.LoggedData, NULL,
  308      &rtb_Reshape_b);
  309   }
  310   
  311   /* Update for root system: '<Root>' */
  312   void MdlUpdate(int_T tid)
  313   {
  314   
  315     /* tid is required for a uniform function interface. This system
  316      * is single rate, and in this case, tid is not accessed. */
  317     UNUSED_PARAMETER(tid);
  318   
  319     /* RandomNumber Block: <S2>/Random Number */
  320     rtDWork.Random_Number_a_RWORK.NextOutput = rt_NormalRand((uint_T
  321       *)&rtDWork.Random_Number_a_IWORK.RandSeed)*rtP.Random_Number_a_StdDev+rtP.Random_Number_a_Mean;
  322   
  323     /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */
  324     {
  325       const int_T bytesPerElem = sizeof(real_T);
  326       int_T bufferStart;
  327   
  328       /* Scalar input */
  329       bufferStart = rtDWork.Integer_Delay_BUFF_OFFSET;
  330       memcpy(((byte_T *) &rtDWork.Integer_Delay_BUFF[0]) +
  331        (bufferStart*bytesPerElem), &rtB.Pulse_Generator, bytesPerElem);
  332       rtDWork.Integer_Delay_BUFF_OFFSET += 1;
  333       while (rtDWork.Integer_Delay_BUFF_OFFSET >= rtP.Integer_Delay_Delays)
  334       rtDWork.Integer_Delay_BUFF_OFFSET -= rtP.Integer_Delay_Delays;
  335     }
  336   
  337     /* RandomNumber Block: <S3>/Random Number */
  338     rtDWork.Random_Number_b_RWORK.NextOutput = rt_NormalRand((uint_T
  339       *)&rtDWork.Random_Number_b_IWORK.RandSeed)*rtP.Random_Number_b_StdDev+rtP.Random_Number_b_Mean;
  340   }
  341   
  342   /* Terminate for root system: '<Root>' */
  343   void MdlTerminate(void)
  344   {
  345     if(rtM_fadingchannelconstructed != NULL) {
  346     }
  347   }
  348   
  349   /* Function to initialize sizes */
  350   void MdlInitializeSizes(void)
  351   {
  352     rtM_fadingchannelconstructed->Sizes.numContStates = (0); /* Number of continuous states */
  353     rtM_fadingchannelconstructed->Sizes.numY = (0); /* Number of model outputs */
  354     rtM_fadingchannelconstructed->Sizes.numU = (0); /* Number of model inputs */
  355     rtM_fadingchannelconstructed->Sizes.sysDirFeedThru = (0); /* The model is not direct feedthrough */
  356     rtM_fadingchannelconstructed->Sizes.numSampTimes = (1); /* Number of sample times */
  357     rtM_fadingchannelconstructed->Sizes.numBlocks = (22); /* Number of blocks */
  358     rtM_fadingchannelconstructed->Sizes.numBlockIO = (8); /* Number of block outputs */
  359     rtM_fadingchannelconstructed->Sizes.numBlockPrms = (124); /* Sum of parameter "widths" */
  360   }
  361   
  362   /* Function to initialize sample times */
  363   void MdlInitializeSampleTimes(void)
  364   {
  365     /* task periods */
  366     rtM_fadingchannelconstructed->Timing.sampleTimes[0] = (0.0002);
  367   
  368     /* task offsets */
  369     rtM_fadingchannelconstructed->Timing.offsetTimes[0] = (0.0);
  370   }
  371   
  372   /* Function to register the model */
  373   rtModel_fadingchannelconstructed *fadingchannelconstructed(void)
  374   {
  375     (void)memset((char *)rtM_fadingchannelconstructed, 0,
  376      sizeof(rtModel_fadingchannelconstructed));
  377   
  378     {
  379       /* Setup solver object */
  380       static RTWSolverInfo rt_SolverInfo;
  381       rtM_fadingchannelconstructed->solverInfo = (&rt_SolverInfo);
  382   
  383       rtsiSetSimTimeStepPtr(rtM_fadingchannelconstructed->solverInfo,
  384        &rtM_fadingchannelconstructed->Timing.simTimeStep);
  385       rtsiSetTPtr(rtM_fadingchannelconstructed->solverInfo,
  386        &rtmGetTPtr(rtM_fadingchannelconstructed));
  387       rtsiSetStepSizePtr(rtM_fadingchannelconstructed->solverInfo,
  388        &rtM_fadingchannelconstructed->Timing.stepSize);
  389       rtsiSetdXPtr(rtM_fadingchannelconstructed->solverInfo,
  390        &rtM_fadingchannelconstructed->ModelData.derivs);
  391       rtsiSetContStatesPtr(rtM_fadingchannelconstructed->solverInfo,
  392        &rtM_fadingchannelconstructed->ModelData.contStates);
  393       rtsiSetNumContStatesPtr(rtM_fadingchannelconstructed->solverInfo,
  394        &rtM_fadingchannelconstructed->Sizes.numContStates);
  395       rtsiSetErrorStatusPtr(rtM_fadingchannelconstructed->solverInfo,
  396        &rtmGetErrorStatus(rtM_fadingchannelconstructed));
  397   
  398       rtsiSetRTModelPtr(rtM_fadingchannelconstructed->solverInfo,
  399        rtM_fadingchannelconstructed);
  400     }
  401   
  402     /* timing info */
  403     {
  404       static time_T mdlPeriod[NSAMPLE_TIMES];
  405       static time_T mdlOffset[NSAMPLE_TIMES];
  406       static time_T mdlTaskTimes[NSAMPLE_TIMES];
  407       static int_T mdlTsMap[NSAMPLE_TIMES];
  408       static int_T mdlSampleHits[NSAMPLE_TIMES];
  409   
  410       {
  411         int_T i;
  412   
  413         for(i = 0; i < NSAMPLE_TIMES; i++) {
  414           mdlPeriod[i] = 0.0;
  415           mdlOffset[i] = 0.0;
  416           mdlTaskTimes[i] = 0.0;
  417         }
  418       }
  419       (void)memset((char_T *)&mdlTsMap[0], 0, 1 * sizeof(int_T));
  420       (void)memset((char_T *)&mdlSampleHits[0], 0, 1 * sizeof(int_T));
  421   
  422       rtM_fadingchannelconstructed->Timing.sampleTimes = (&mdlPeriod[0]);
  423       rtM_fadingchannelconstructed->Timing.offsetTimes = (&mdlOffset[0]);
  424       rtM_fadingchannelconstructed->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
  425       rtmSetTPtr(rtM_fadingchannelconstructed, &mdlTaskTimes[0]);
  426       rtM_fadingchannelconstructed->Timing.sampleHits = (&mdlSampleHits[0]);
  427     }
  428     rtsiSetSolverMode(rtM_fadingchannelconstructed->solverInfo,
  429      SOLVER_MODE_SINGLETASKING);
  430   
  431     /*
  432      * initialize model vectors and cache them in SimStruct
  433      */
  434   
  435     /* block I/O */
  436     {
  437       void *b = (void *) &rtB;
  438       rtM_fadingchannelconstructed->ModelData.blockIO = (b);
  439   
  440       {
  441         int_T i;
  442   
  443         b =&rtB.Random_Number_a;
  444         for (i = 0; i < 8; i++) {
  445           ((real_T*)b)[i] = 0.0;
  446         }
  447       }
  448     }
  449   
  450     /* parameters */
  451     rtM_fadingchannelconstructed->ModelData.defaultParam = ((real_T *) &rtP);
  452   
  453     /* data type work */
  454     {
  455       void *dwork = (void *) &rtDWork;
  456       rtM_fadingchannelconstructed->Work.dwork = (dwork);
  457       (void)memset((char_T *) dwork, 0, sizeof(D_Work));
  458       {
  459         int_T i;
  460         real_T *dwork_ptr = (real_T *) &rtDWork.Integer_Delay_BUFF[0];
  461   
  462         for (i = 0; i < 154; i++) {
  463           dwork_ptr[i] = 0.0;
  464         }
  465       }
  466     }
  467   
  468     /* Model specific registration */
  469   
  470     rtM_fadingchannelconstructed->modelName = ("fadingchannelconstructed");
  471     rtM_fadingchannelconstructed->path = ("fadingchannelconstructed");
  472   
  473     rtmSetTStart(rtM_fadingchannelconstructed, 0.0);
  474     rtM_fadingchannelconstructed->Timing.tFinal = (10.0);
  475     rtM_fadingchannelconstructed->Timing.stepSize = (0.0002);
  476     rtsiSetFixedStepSize(rtM_fadingchannelconstructed->solverInfo, 0.0002);
  477     /* Setup for data logging */
  478     {
  479       static RTWLogInfo rt_DataLoggingInfo;
  480   
  481       rtM_fadingchannelconstructed->rtwLogInfo = (&rt_DataLoggingInfo);
  482   
  483       rtliSetLogFormat(rtM_fadingchannelconstructed->rtwLogInfo, 0);
  484   
  485       rtliSetLogMaxRows(rtM_fadingchannelconstructed->rtwLogInfo, 1000);
  486   
  487       rtliSetLogDecimation(rtM_fadingchannelconstructed->rtwLogInfo, 1);
  488   
  489       rtliSetLogVarNameModifier(rtM_fadingchannelconstructed->rtwLogInfo, "none");
  490   
  491       rtliSetLogT(rtM_fadingchannelconstructed->rtwLogInfo, "tout");
  492   
  493       rtliSetLogX(rtM_fadingchannelconstructed->rtwLogInfo, "");
  494   
  495       rtliSetLogXFinal(rtM_fadingchannelconstructed->rtwLogInfo, "");
  496   
  497       rtliSetLogXSignalInfo(rtM_fadingchannelconstructed->rtwLogInfo, NULL);
  498   
  499       rtliSetLogXSignalPtrs(rtM_fadingchannelconstructed->rtwLogInfo, NULL);
  500   
  501       rtliSetLogY(rtM_fadingchannelconstructed->rtwLogInfo, "");
  502   
  503       rtliSetLogYSignalInfo(rtM_fadingchannelconstructed->rtwLogInfo, NULL);
  504   
  505       rtliSetLogYSignalPtrs(rtM_fadingchannelconstructed->rtwLogInfo, NULL);
  506     }
  507   
  508     rtM_fadingchannelconstructed->Sizes.checksums[0] = (4095649789U);
  509     rtM_fadingchannelconstructed->Sizes.checksums[1] = (2440085475U);
  510     rtM_fadingchannelconstructed->Sizes.checksums[2] = (3216992539U);
  511     rtM_fadingchannelconstructed->Sizes.checksums[3] = (240693362U);
  512   
  513     return rtM_fadingchannelconstructed;
  514   }
  515