/*
 * File: _coder_Select_Ground_Motions_api.c
 *
 * MATLAB Coder version            : 2.8
 * C/C++ source code generated on  : 08-Nov-2016 04:31:59
 */

/* Include Files */
#include "tmwtypes.h"
#include "_coder_Select_Ground_Motions_api.h"

/* Variable Definitions */
emlrtCTX emlrtRootTLSGlobal = NULL;
emlrtContext emlrtContextGlobal = { true, false, 131418U, NULL,
  "Select_Ground_Motions", NULL, false, { 2045744189U, 2170104910U, 2743257031U,
    4284093946U }, NULL };

/* Function Declarations */
static void b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId, emxArray_real_T *y);
static const mxArray *b_emlrt_marshallOut(const emxArray_real_T *u);
static void b_emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray,
  int32_T numDimensions, boolean_T doPush);
static void c_emlrt_marshallIn(const emlrtStack *sp, const mxArray *Sa_1, const
  char_T *identifier, emxArray_real_T *y);
static const mxArray *c_emlrt_marshallOut(const emxArray_real_T *u);
static void d_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId, emxArray_real_T *y);
static const mxArray *d_emlrt_marshallOut(const real_T u[501]);
static real_T e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *nGM, const
  char_T *identifier);
static const mxArray *e_emlrt_marshallOut(const real_T u);
static void emlrt_marshallIn(const emlrtStack *sp, const mxArray *idRef, const
  char_T *identifier, emxArray_real_T *y);
static const mxArray *emlrt_marshallOut(const emxArray_real_T *u);
static void emxFree_real_T(emxArray_real_T **pEmxArray);
static void emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray,
  int32_T numDimensions, boolean_T doPush);
static real_T f_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId);
static void g_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId, emxArray_real_T *ret);
static void h_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId, emxArray_real_T *ret);
static real_T i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId);

/* Function Definitions */

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *u
 *                const emlrtMsgIdentifier *parentId
 *                emxArray_real_T *y
 * Return Type  : void
 */
static void b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId, emxArray_real_T *y)
{
  g_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y);
  emlrtDestroyArray(&u);
}

/*
 * Arguments    : const emxArray_real_T *u
 * Return Type  : const mxArray *
 */
static const mxArray *b_emlrt_marshallOut(const emxArray_real_T *u)
{
  const mxArray *y;
  static const int32_T iv1[2] = { 0, 0 };

  const mxArray *m1;
  y = NULL;
  m1 = emlrtCreateNumericArray(2, iv1, mxDOUBLE_CLASS, mxREAL);
  mxSetData((mxArray *)m1, (void *)u->data);
  emlrtSetDimensions((mxArray *)m1, u->size, 2);
  emlrtAssign(&y, m1);
  return y;
}

/*
 * Arguments    : const emlrtStack *sp
 *                emxArray_real_T **pEmxArray
 *                int32_T numDimensions
 *                boolean_T doPush
 * Return Type  : void
 */
static void b_emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray,
  int32_T numDimensions, boolean_T doPush)
{
  emxArray_real_T *emxArray;
  int32_T i;
  *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  if (doPush) {
    emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
      emxFree_real_T);
  }

  emxArray = *pEmxArray;
  emxArray->data = (real_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
    * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *Sa_1
 *                const char_T *identifier
 *                emxArray_real_T *y
 * Return Type  : void
 */
static void c_emlrt_marshallIn(const emlrtStack *sp, const mxArray *Sa_1, const
  char_T *identifier, emxArray_real_T *y)
{
  emlrtMsgIdentifier thisId;
  thisId.fIdentifier = identifier;
  thisId.fParent = NULL;
  d_emlrt_marshallIn(sp, emlrtAlias(Sa_1), &thisId, y);
  emlrtDestroyArray(&Sa_1);
}

/*
 * Arguments    : const emxArray_real_T *u
 * Return Type  : const mxArray *
 */
static const mxArray *c_emlrt_marshallOut(const emxArray_real_T *u)
{
  const mxArray *y;
  static const int32_T iv2[2] = { 0, 0 };

  const mxArray *m2;
  y = NULL;
  m2 = emlrtCreateNumericArray(2, iv2, mxDOUBLE_CLASS, mxREAL);
  mxSetData((mxArray *)m2, (void *)u->data);
  emlrtSetDimensions((mxArray *)m2, u->size, 2);
  emlrtAssign(&y, m2);
  return y;
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *u
 *                const emlrtMsgIdentifier *parentId
 *                emxArray_real_T *y
 * Return Type  : void
 */
static void d_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId, emxArray_real_T *y)
{
  h_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y);
  emlrtDestroyArray(&u);
}

/*
 * Arguments    : const real_T u[501]
 * Return Type  : const mxArray *
 */
static const mxArray *d_emlrt_marshallOut(const real_T u[501])
{
  const mxArray *y;
  static const int32_T iv3[2] = { 0, 0 };

  const mxArray *m3;
  static const int32_T iv4[2] = { 1, 501 };

  y = NULL;
  m3 = emlrtCreateNumericArray(2, iv3, mxDOUBLE_CLASS, mxREAL);
  mxSetData((mxArray *)m3, (void *)u);
  emlrtSetDimensions((mxArray *)m3, iv4, 2);
  emlrtAssign(&y, m3);
  return y;
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *nGM
 *                const char_T *identifier
 * Return Type  : real_T
 */
static real_T e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *nGM, const
  char_T *identifier)
{
  real_T y;
  emlrtMsgIdentifier thisId;
  thisId.fIdentifier = identifier;
  thisId.fParent = NULL;
  y = f_emlrt_marshallIn(sp, emlrtAlias(nGM), &thisId);
  emlrtDestroyArray(&nGM);
  return y;
}

/*
 * Arguments    : const real_T u
 * Return Type  : const mxArray *
 */
static const mxArray *e_emlrt_marshallOut(const real_T u)
{
  const mxArray *y;
  const mxArray *m4;
  y = NULL;
  m4 = emlrtCreateDoubleScalar(u);
  emlrtAssign(&y, m4);
  return y;
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *idRef
 *                const char_T *identifier
 *                emxArray_real_T *y
 * Return Type  : void
 */
static void emlrt_marshallIn(const emlrtStack *sp, const mxArray *idRef, const
  char_T *identifier, emxArray_real_T *y)
{
  emlrtMsgIdentifier thisId;
  thisId.fIdentifier = identifier;
  thisId.fParent = NULL;
  b_emlrt_marshallIn(sp, emlrtAlias(idRef), &thisId, y);
  emlrtDestroyArray(&idRef);
}

/*
 * Arguments    : const emxArray_real_T *u
 * Return Type  : const mxArray *
 */
static const mxArray *emlrt_marshallOut(const emxArray_real_T *u)
{
  const mxArray *y;
  static const int32_T iv0[1] = { 0 };

  const mxArray *m0;
  y = NULL;
  m0 = emlrtCreateNumericArray(1, iv0, mxDOUBLE_CLASS, mxREAL);
  mxSetData((mxArray *)m0, (void *)u->data);
  emlrtSetDimensions((mxArray *)m0, u->size, 1);
  emlrtAssign(&y, m0);
  return y;
}

/*
 * Arguments    : emxArray_real_T **pEmxArray
 * Return Type  : void
 */
static void emxFree_real_T(emxArray_real_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_real_T *)NULL) {
    if (((*pEmxArray)->data != (real_T *)NULL) && (*pEmxArray)->canFreeData) {
      emlrtFreeMex((void *)(*pEmxArray)->data);
    }

    emlrtFreeMex((void *)(*pEmxArray)->size);
    emlrtFreeMex((void *)*pEmxArray);
    *pEmxArray = (emxArray_real_T *)NULL;
  }
}

/*
 * Arguments    : const emlrtStack *sp
 *                emxArray_real_T **pEmxArray
 *                int32_T numDimensions
 *                boolean_T doPush
 * Return Type  : void
 */
static void emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray,
  int32_T numDimensions, boolean_T doPush)
{
  emxArray_real_T *emxArray;
  int32_T i;
  *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  if (doPush) {
    emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
      emxFree_real_T);
  }

  emxArray = *pEmxArray;
  emxArray->data = (real_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
    * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *u
 *                const emlrtMsgIdentifier *parentId
 * Return Type  : real_T
 */
static real_T f_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId)
{
  real_T y;
  y = i_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  emlrtDestroyArray(&u);
  return y;
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *src
 *                const emlrtMsgIdentifier *msgId
 *                emxArray_real_T *ret
 * Return Type  : void
 */
static void g_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId, emxArray_real_T *ret)
{
  int32_T iv5[1];
  boolean_T bv0[1] = { true };

  static const int32_T iv6[1] = { -1 };

  emlrtCheckVsBuiltInR2012b(sp, msgId, src, "double", false, 1U, iv6, &bv0[0],
    iv5);
  ret->size[0] = iv5[0];
  ret->allocatedSize = ret->size[0];
  ret->data = (real_T *)mxGetData(src);
  ret->canFreeData = false;
  emlrtDestroyArray(&src);
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *src
 *                const emlrtMsgIdentifier *msgId
 *                emxArray_real_T *ret
 * Return Type  : void
 */
static void h_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId, emxArray_real_T *ret)
{
  int32_T iv7[2];
  int32_T i;
  int32_T iv8[2];
  boolean_T bv1[2] = { true, true };

  for (i = 0; i < 2; i++) {
    iv7[i] = -1;
  }

  emlrtCheckVsBuiltInR2012b(sp, msgId, src, "double", false, 2U, iv7, &bv1[0],
    iv8);
  ret->size[0] = iv8[0];
  ret->size[1] = iv8[1];
  ret->allocatedSize = ret->size[0] * ret->size[1];
  ret->data = (real_T *)mxGetData(src);
  ret->canFreeData = false;
  emlrtDestroyArray(&src);
}

/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *src
 *                const emlrtMsgIdentifier *msgId
 * Return Type  : real_T
 */
static real_T i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  emlrtMsgIdentifier *msgId)
{
  real_T ret;
  emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 0U, 0);
  ret = *(real_T *)mxGetData(src);
  emlrtDestroyArray(&src);
  return ret;
}

/*
 * Arguments    : const mxArray *prhs[20]
 *                const mxArray *plhs[18]
 * Return Type  : void
 */
void Select_Ground_Motions_api(const mxArray *prhs[20], const mxArray *plhs[18])
{
  real_T (*F4_x1)[501];
  emxArray_real_T *idRef;
  emxArray_real_T *Sa_1;
  emxArray_real_T *Sa_2;
  emxArray_real_T *sVs30;
  emxArray_real_T *finalRecords;
  emxArray_real_T *finalDirectios;
  emxArray_real_T *finalScaleFactors;
  emxArray_real_T *F_x;
  emxArray_real_T *F1_y1;
  emxArray_real_T *F1_y1a;
  emxArray_real_T *F1_y2;
  emxArray_real_T *F1_y3;
  emxArray_real_T *F1_yn;
  emxArray_real_T *F2_y1;
  emxArray_real_T *F3_y1;
  emxArray_real_T *F3_y2;
  emxArray_real_T *F4_y1;
  emxArray_real_T *F5_y1;
  emxArray_real_T *F6_y1;
  emxArray_real_T *F7_y1;
  real_T nGM;
  real_T T1;
  real_T T1dej;
  real_T ecSoilCode;
  real_T isScaled;
  real_T maxScale;
  real_T weight_mean;
  real_T weight_sd;
  real_T nLoop;
  real_T penalty;
  real_T seedValue;
  real_T M_bar;
  real_T R_bar;
  real_T eps_bar;
  real_T nX;
  real_T useVar;
  real_T errCode;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  F4_x1 = (real_T (*)[501])mxMalloc(sizeof(real_T [501]));
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &idRef, 1, true);
  b_emxInit_real_T(&st, &Sa_1, 2, true);
  b_emxInit_real_T(&st, &Sa_2, 2, true);
  emxInit_real_T(&st, &sVs30, 1, true);
  emxInit_real_T(&st, &finalRecords, 1, true);
  emxInit_real_T(&st, &finalDirectios, 1, true);
  emxInit_real_T(&st, &finalScaleFactors, 1, true);
  b_emxInit_real_T(&st, &F_x, 2, true);
  b_emxInit_real_T(&st, &F1_y1, 2, true);
  b_emxInit_real_T(&st, &F1_y1a, 2, true);
  b_emxInit_real_T(&st, &F1_y2, 2, true);
  b_emxInit_real_T(&st, &F1_y3, 2, true);
  b_emxInit_real_T(&st, &F1_yn, 2, true);
  b_emxInit_real_T(&st, &F2_y1, 2, true);
  b_emxInit_real_T(&st, &F3_y1, 2, true);
  b_emxInit_real_T(&st, &F3_y2, 2, true);
  b_emxInit_real_T(&st, &F4_y1, 2, true);
  b_emxInit_real_T(&st, &F5_y1, 2, true);
  b_emxInit_real_T(&st, &F6_y1, 2, true);
  b_emxInit_real_T(&st, &F7_y1, 2, true);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
  prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
  prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
  prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "idRef", idRef);
  c_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "Sa_1", Sa_1);
  c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "Sa_2", Sa_2);
  emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "sVs30", sVs30);
  nGM = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "nGM");
  T1 = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "T1");
  T1dej = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "T1dej");
  ecSoilCode = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "ecSoilCode");
  isScaled = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "isScaled");
  maxScale = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[9]), "maxScale");
  weight_mean = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[10]), "weight_mean");
  weight_sd = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[11]), "weight_sd");
  nLoop = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[12]), "nLoop");
  penalty = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[13]), "penalty");
  seedValue = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[14]), "seedValue");
  M_bar = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[15]), "M_bar");
  R_bar = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[16]), "R_bar");
  eps_bar = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[17]), "eps_bar");
  nX = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[18]), "nX");
  useVar = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[19]), "useVar");

  /* Invoke the target function */
  Select_Ground_Motions(idRef, Sa_1, Sa_2, sVs30, nGM, T1, T1dej, ecSoilCode,
                        isScaled, maxScale, weight_mean, weight_sd, nLoop,
                        penalty, seedValue, M_bar, R_bar, eps_bar, nX, useVar,
                        finalRecords, finalDirectios, finalScaleFactors, F_x,
                        F1_y1, F1_y1a, F1_y2, F1_y3, F1_yn, F2_y1, F3_y1, F3_y2,
                        *F4_x1, F4_y1, F5_y1, F6_y1, F7_y1, &errCode);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(finalRecords);
  plhs[1] = emlrt_marshallOut(finalDirectios);
  plhs[2] = emlrt_marshallOut(finalScaleFactors);
  plhs[3] = b_emlrt_marshallOut(F_x);
  plhs[4] = b_emlrt_marshallOut(F1_y1);
  plhs[5] = b_emlrt_marshallOut(F1_y1a);
  plhs[6] = b_emlrt_marshallOut(F1_y2);
  plhs[7] = b_emlrt_marshallOut(F1_y3);
  plhs[8] = c_emlrt_marshallOut(F1_yn);
  plhs[9] = b_emlrt_marshallOut(F2_y1);
  plhs[10] = b_emlrt_marshallOut(F3_y1);
  plhs[11] = b_emlrt_marshallOut(F3_y2);
  plhs[12] = d_emlrt_marshallOut(*F4_x1);
  plhs[13] = c_emlrt_marshallOut(F4_y1);
  plhs[14] = c_emlrt_marshallOut(F5_y1);
  plhs[15] = b_emlrt_marshallOut(F6_y1);
  plhs[16] = b_emlrt_marshallOut(F7_y1);
  plhs[17] = e_emlrt_marshallOut(errCode);
  F7_y1->canFreeData = false;
  emxFree_real_T(&F7_y1);
  F6_y1->canFreeData = false;
  emxFree_real_T(&F6_y1);
  F5_y1->canFreeData = false;
  emxFree_real_T(&F5_y1);
  F4_y1->canFreeData = false;
  emxFree_real_T(&F4_y1);
  F3_y2->canFreeData = false;
  emxFree_real_T(&F3_y2);
  F3_y1->canFreeData = false;
  emxFree_real_T(&F3_y1);
  F2_y1->canFreeData = false;
  emxFree_real_T(&F2_y1);
  F1_yn->canFreeData = false;
  emxFree_real_T(&F1_yn);
  F1_y3->canFreeData = false;
  emxFree_real_T(&F1_y3);
  F1_y2->canFreeData = false;
  emxFree_real_T(&F1_y2);
  F1_y1a->canFreeData = false;
  emxFree_real_T(&F1_y1a);
  F1_y1->canFreeData = false;
  emxFree_real_T(&F1_y1);
  F_x->canFreeData = false;
  emxFree_real_T(&F_x);
  finalScaleFactors->canFreeData = false;
  emxFree_real_T(&finalScaleFactors);
  finalDirectios->canFreeData = false;
  emxFree_real_T(&finalDirectios);
  finalRecords->canFreeData = false;
  emxFree_real_T(&finalRecords);
  sVs30->canFreeData = false;
  emxFree_real_T(&sVs30);
  Sa_2->canFreeData = false;
  emxFree_real_T(&Sa_2);
  Sa_1->canFreeData = false;
  emxFree_real_T(&Sa_1);
  idRef->canFreeData = false;
  emxFree_real_T(&idRef);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}

/*
 * Arguments    : void
 * Return Type  : void
 */
void Select_Ground_Motions_atexit(void)
{
  emlrtStack st = { NULL, NULL, NULL };

  emlrtCreateRootTLS(&emlrtRootTLSGlobal, &emlrtContextGlobal, NULL, 1);
  st.tls = emlrtRootTLSGlobal;
  emlrtEnterRtStackR2012b(&st);
  emlrtLeaveRtStackR2012b(&st);
  emlrtDestroyRootTLS(&emlrtRootTLSGlobal);
  Select_Ground_Motions_xil_terminate();
}

/*
 * Arguments    : void
 * Return Type  : void
 */
void Select_Ground_Motions_initialize(void)
{
  emlrtStack st = { NULL, NULL, NULL };

  emlrtCreateRootTLS(&emlrtRootTLSGlobal, &emlrtContextGlobal, NULL, 1);
  st.tls = emlrtRootTLSGlobal;
  emlrtClearAllocCountR2012b(&st, false, 0U, 0);
  emlrtEnterRtStackR2012b(&st);
  emlrtFirstTimeR2012b(emlrtRootTLSGlobal);
}

/*
 * Arguments    : void
 * Return Type  : void
 */
void Select_Ground_Motions_terminate(void)
{
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtLeaveRtStackR2012b(&st);
  emlrtDestroyRootTLS(&emlrtRootTLSGlobal);
}

/*
 * File trailer for _coder_Select_Ground_Motions_api.c
 *
 * [EOF]
 */