static void sf_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear (SFc2_MigrationOWBG_Proto4_1DLinear2DNonLinearInstanceStruct *chartInstance) { real_T c2_hoistedGlobal; real_T c2_b_hoistedGlobal; real_T c2_x; real_T c2_y; uint32_T c2_debug_family_var_map[5]; real_T c2_nargin = 2.0; real_T c2_nargout = 1.0; real_T c2_z; real_T c2_b_x; real_T c2_c_x; real_T *c2_d_x; real_T *c2_b_y; real_T *c2_b_z; c2_b_z = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1); c2_b_y = (real_T *)ssGetInputPortSignal(chartInstance->S, 1); c2_d_x = (real_T *)ssGetInputPortSignal(chartInstance->S, 0); _sfTime_ = (real_T)ssGetT(chartInstance->S); _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c2_sfEvent); _SFD_DATA_RANGE_CHECK(*c2_d_x, 0U); _SFD_DATA_RANGE_CHECK(*c2_b_y, 1U); _SFD_DATA_RANGE_CHECK(*c2_b_z, 2U); chartInstance->c2_sfEvent = CALL_EVENT; _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent); c2_hoistedGlobal = *c2_d_x; c2_b_hoistedGlobal = *c2_b_y; c2_x = c2_hoistedGlobal; c2_y = c2_b_hoistedGlobal; _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 5U, 5U, c2_debug_family_names, c2_debug_family_var_map); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargin, 0U, c2_sf_marshallOut, c2_sf_marshallIn); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargout, 1U, c2_sf_marshallOut, c2_sf_marshallIn); _SFD_SYMBOL_SCOPE_ADD_EML(&c2_x, 2U, c2_sf_marshallOut); _SFD_SYMBOL_SCOPE_ADD_EML(&c2_y, 3U, c2_sf_marshallOut); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_z, 4U, c2_sf_marshallOut, c2_sf_marshallIn); CV_EML_FCN(0, 0); _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 3); c2_b_x = (45.96 - c2_mpower(chartInstance, c2_y)) - c2_mpower(chartInstance, c2_x); c2_z = c2_b_x; if (c2_z < 0.0) { c2_eml_error(chartInstance); } c2_c_x = c2_z; c2_z = c2_c_x; c2_z = muDoubleScalarSqrt(c2_z); _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -3); _SFD_SYMBOL_SCOPE_POP(); *c2_b_z = c2_z; _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent); _SFD_CHECK_FOR_STATE_INCONSISTENCY (_MigrationOWBG_Proto4_1DLinear2DNonLinearMachineNumber_, chartInstance->chartNumber, chartInstance->instanceNumber); }
static real_T c3_norm(SFc3_ErdMondInstanceStruct *chartInstance, real_T c3_x[2]) { real_T c3_y; real_T c3_scale; int32_T c3_k; int32_T c3_b_k; real_T c3_b_x; real_T c3_c_x; real_T c3_absxk; real_T c3_t; c3_y = 0.0; c3_scale = 2.2250738585072014E-308; c3_eml_int_forloop_overflow_check(chartInstance); for (c3_k = 1; c3_k < 3; c3_k++) { c3_b_k = c3_k; c3_b_x = c3_x[_SFD_EML_ARRAY_BOUNDS_CHECK("", (int32_T)_SFD_INTEGER_CHECK("", (real_T)c3_b_k), 1, 2, 1, 0) - 1]; c3_c_x = c3_b_x; c3_absxk = muDoubleScalarAbs(c3_c_x); if (c3_absxk > c3_scale) { c3_t = c3_scale / c3_absxk; c3_y = 1.0 + c3_y * c3_t * c3_t; c3_scale = c3_absxk; } else { c3_t = c3_absxk / c3_scale; c3_y += c3_t * c3_t; } } return c3_scale * muDoubleScalarSqrt(c3_y); }
void c_sqrt(const emlrtStack *sp, real_T *x) { emlrtStack st; st.prev = sp; st.tls = sp->tls; if (*x < 0.0) { st.site = &f_emlrtRSI; eml_error(&st); } *x = muDoubleScalarSqrt(*x); }
void b_sqrt(real_T x[1000000]) { int32_T k; for (k = 0; k < 1000000; k++) { if (x[k] < 0.0) { emlrtPushRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal); eml_error(); emlrtPopRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal); } } for (k = 0; k < 1000000; k++) { x[k] = muDoubleScalarSqrt(x[k]); } }
void c_sqrt(const emlrtStack *sp, emxArray_real_T *x) { boolean_T p; int32_T nx; int32_T k; emlrtStack st; emlrtStack b_st; emlrtStack c_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; p = false; nx = x->size[0] * x->size[1]; for (k = 0; k < nx; k++) { if (p || (x->data[k] < 0.0)) { p = true; } else { p = false; } } if (p) { st.site = &h_emlrtRSI; error(&st); } st.site = &i_emlrtRSI; nx = x->size[0] * x->size[1]; b_st.site = &j_emlrtRSI; if ((!(1 > nx)) && (nx > 2147483646)) { c_st.site = &k_emlrtRSI; check_forloop_overflow_error(&c_st); } for (k = 0; k + 1 <= nx; k++) { x->data[k] = muDoubleScalarSqrt(x->data[k]); } }
/* Function Definitions */ real_T norm(const real_T x[3]) { real_T y; real_T scale; int32_T k; real_T absxk; real_T t; y = 0.0; scale = 3.3121686421112381E-170; for (k = 0; k < 3; k++) { absxk = muDoubleScalarAbs(x[k]); if (absxk > scale) { t = scale / absxk; y = 1.0 + y * t * t; scale = absxk; } else { t = absxk / scale; y += t * t; } } return scale * muDoubleScalarSqrt(y); }
/* Function Definitions */ real_T norm(const real_T x[4]) { real_T y; real_T scale; int32_T k; real_T absxk; real_T t; y = 0.0; scale = 2.2250738585072014E-308; for (k = 0; k < 4; k++) { absxk = muDoubleScalarAbs(x[k]); if (absxk > scale) { t = scale / absxk; y = 1.0 + y * t * t; scale = absxk; } else { t = absxk / scale; y += t * t; } } return scale * muDoubleScalarSqrt(y); }
/* Function Definitions */ void MechanicalPointForce(const emlrtStack *sp, const emxArray_real_T *particlePosition, const emxArray_real_T *pointSourcePosition, real_T forceDirection, real_T forceMagnitude, real_T cutoff, emxArray_real_T *force) { uint32_T sz[2]; int32_T ix; emxArray_real_T *forceTemp; int32_T loop_ub; emxArray_real_T *forceMag; int32_T vlen; int32_T sIdx; emxArray_real_T *forceDir; emxArray_real_T *distToSource; emxArray_int32_T *r0; emxArray_boolean_T *r1; emxArray_int32_T *r2; emxArray_real_T *x; emxArray_real_T *b_x; emxArray_real_T *r3; emxArray_real_T *r4; emxArray_real_T *b_pointSourcePosition; emxArray_real_T *b_forceDir; emxArray_real_T *c_forceDir; int32_T k; int32_T vstride; int32_T iy; int32_T ixstart; boolean_T overflow; real_T s; boolean_T b0; uint32_T varargin_2[2]; boolean_T p; boolean_T exitg1; int32_T iv0[1]; int32_T iv1[2]; int32_T b_force[2]; int32_T iv2[1]; int32_T b_iy; int32_T c_iy; int32_T b_forceTemp[2]; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; d_st.prev = &c_st; d_st.tls = c_st.tls; e_st.prev = &d_st; e_st.tls = d_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); /* apply mechanical (push or pull) force on particles */ /* mechanicalForce is a logical flag */ /* particlPosition is a N by 3 vector of particle position */ /* pointSourcePosition is the position of force sources */ /* forceDirection is either -1 for 'in' or 1 for 'out' */ /* forceMagnitude is a positive number between 0 and 1 */ /* cutoff is the maximal direction the force operates on particle relative */ /* to the pointSourcePosition */ /* the output is a vector of N by 3 of delta position to th */ for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)particlePosition->size[ix]; } emxInit_real_T(sp, &forceTemp, 2, &c_emlrtRTEI, true); ix = forceTemp->size[0] * forceTemp->size[1]; forceTemp->size[0] = (int32_T)sz[0]; emxEnsureCapacity(sp, (emxArray__common *)forceTemp, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceTemp->size[0] * forceTemp->size[1]; forceTemp->size[1] = (int32_T)sz[1]; emxEnsureCapacity(sp, (emxArray__common *)forceTemp, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0] * (int32_T)sz[1]; for (ix = 0; ix < loop_ub; ix++) { forceTemp->data[ix] = 0.0; } for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)particlePosition->size[ix]; } ix = force->size[0] * force->size[1]; force->size[0] = (int32_T)sz[0]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); ix = force->size[0] * force->size[1]; force->size[1] = (int32_T)sz[1]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0] * (int32_T)sz[1]; for (ix = 0; ix < loop_ub; ix++) { force->data[ix] = 0.0; } emxInit_real_T(sp, &forceMag, 2, &d_emlrtRTEI, true); vlen = particlePosition->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof(real_T), &emlrtRTEI); vlen = particlePosition->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = particlePosition->size[0] * particlePosition->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = 0.0; } sIdx = 0; emxInit_real_T(sp, &forceDir, 2, &e_emlrtRTEI, true); b_emxInit_real_T(sp, &distToSource, 1, &f_emlrtRTEI, true); emxInit_int32_T(sp, &r0, 1, &emlrtRTEI, true); emxInit_boolean_T(sp, &r1, 2, &emlrtRTEI, true); emxInit_int32_T(sp, &r2, 1, &emlrtRTEI, true); emxInit_real_T(sp, &x, 2, &emlrtRTEI, true); b_emxInit_real_T(sp, &b_x, 1, &emlrtRTEI, true); b_emxInit_real_T(sp, &r3, 1, &emlrtRTEI, true); b_emxInit_real_T(sp, &r4, 1, &emlrtRTEI, true); emxInit_real_T(sp, &b_pointSourcePosition, 2, &emlrtRTEI, true); b_emxInit_real_T(sp, &b_forceDir, 1, &emlrtRTEI, true); emxInit_real_T(sp, &c_forceDir, 2, &emlrtRTEI, true); while (sIdx <= pointSourcePosition->size[0] - 1) { loop_ub = pointSourcePosition->size[1]; ix = pointSourcePosition->size[0]; if ((sIdx + 1 >= 1) && (sIdx + 1 < ix)) { vlen = sIdx + 1; } else { vlen = emlrtDynamicBoundsCheckR2012b(sIdx + 1, 1, ix, (emlrtBCInfo *) &e_emlrtBCI, sp); } ix = b_pointSourcePosition->size[0] * b_pointSourcePosition->size[1]; b_pointSourcePosition->size[0] = 1; b_pointSourcePosition->size[1] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)b_pointSourcePosition, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { b_pointSourcePosition->data[b_pointSourcePosition->size[0] * ix] = pointSourcePosition->data[(vlen + pointSourcePosition->size[0] * ix) - 1]; } st.site = &emlrtRSI; bsxfun(&st, particlePosition, b_pointSourcePosition, forceDir); /* Find the distance between the particles and the source */ st.site = &b_emlrtRSI; b_st.site = &h_emlrtRSI; c_st.site = &i_emlrtRSI; d_st.site = &j_emlrtRSI; for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)forceDir->size[ix]; } ix = x->size[0] * x->size[1]; x->size[0] = (int32_T)sz[0]; x->size[1] = (int32_T)sz[1]; emxEnsureCapacity(&d_st, (emxArray__common *)x, ix, (int32_T)sizeof(real_T), &b_emlrtRTEI); if (dimagree(x, forceDir)) { } else { emlrtErrorWithMessageIdR2012b(&d_st, &b_emlrtRTEI, "MATLAB:dimagree", 0); } ix = (int32_T)sz[0] * (int32_T)sz[1]; for (k = 0; k < ix; k++) { x->data[k] = forceDir->data[k] * forceDir->data[k]; } st.site = &b_emlrtRSI; b_st.site = &k_emlrtRSI; c_st.site = &l_emlrtRSI; for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)x->size[ix]; } ix = b_x->size[0]; b_x->size[0] = (int32_T)sz[0]; emxEnsureCapacity(&c_st, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); if ((x->size[0] == 0) || (x->size[1] == 0)) { ix = b_x->size[0]; b_x->size[0] = (int32_T)sz[0]; emxEnsureCapacity(&c_st, (emxArray__common *)b_x, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0]; for (ix = 0; ix < loop_ub; ix++) { b_x->data[ix] = 0.0; } } else { vlen = x->size[1]; vstride = x->size[0]; iy = -1; ixstart = -1; d_st.site = &m_emlrtRSI; overflow = (x->size[0] > 2147483646); if (overflow) { e_st.site = &g_emlrtRSI; check_forloop_overflow_error(&e_st); } for (loop_ub = 1; loop_ub <= vstride; loop_ub++) { ixstart++; ix = ixstart; s = x->data[ixstart]; d_st.site = &n_emlrtRSI; if (2 > vlen) { b0 = false; } else { b0 = (vlen > 2147483646); } if (b0) { e_st.site = &g_emlrtRSI; check_forloop_overflow_error(&e_st); } for (k = 2; k <= vlen; k++) { ix += vstride; s += x->data[ix]; } iy++; b_x->data[iy] = s; } } st.site = &b_emlrtRSI; ix = distToSource->size[0]; distToSource->size[0] = b_x->size[0]; emxEnsureCapacity(&st, (emxArray__common *)distToSource, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { distToSource->data[ix] = b_x->data[ix]; } for (k = 0; k < b_x->size[0]; k++) { if (b_x->data[k] < 0.0) { b_st.site = &o_emlrtRSI; eml_error(&b_st); } } for (k = 0; k < b_x->size[0]; k++) { distToSource->data[k] = muDoubleScalarSqrt(distToSource->data[k]); } /* Normalize the forceDirection */ iy = 0; while (iy < 3) { loop_ub = forceDir->size[0]; ix = r2->size[0]; r2->size[0] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { r2->data[ix] = ix; } ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&c_emlrtBCI, sp); st.site = &c_emlrtRSI; ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&d_emlrtBCI, &st); ix = forceDir->size[0]; sz[0] = (uint32_T)ix; sz[1] = 1U; varargin_2[0] = (uint32_T)distToSource->size[0]; varargin_2[1] = 1U; overflow = false; p = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (!((int32_T)sz[k] == (int32_T)varargin_2[k])) { p = false; exitg1 = true; } else { k++; } } if (!p) { } else { overflow = true; } if (overflow) { } else { emlrtErrorWithMessageIdR2012b(&st, &l_emlrtRTEI, "MATLAB:dimagree", 0); } loop_ub = forceDir->size[0]; ix = b_x->size[0]; b_x->size[0] = loop_ub; emxEnsureCapacity(&st, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { b_x->data[ix] = forceDir->data[ix + forceDir->size[0] * iy] / distToSource->data[ix]; } iv0[0] = r2->size[0]; emlrtSubAssignSizeCheckR2012b(iv0, 1, *(int32_T (*)[1])b_x->size, 1, (emlrtECInfo *)&d_emlrtECI, sp); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceDir->data[r2->data[ix] + forceDir->size[0] * iy] = b_x->data[ix]; } /* bsxfun(@rdivide,forceDir,distToSource); */ iy++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } /* Multiply the */ if (forceDirection == -1.0) { ix = r4->size[0]; r4->size[0] = distToSource->size[0]; emxEnsureCapacity(sp, (emxArray__common *)r4, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = distToSource->size[0]; for (ix = 0; ix < loop_ub; ix++) { r4->data[ix] = 1.0 + distToSource->data[ix]; } rdivide(sp, forceMagnitude, r4, b_x); vlen = b_x->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = 1.0 - b_x->data[ix]; } } else { if (forceDirection == 1.0) { ix = r3->size[0]; r3->size[0] = distToSource->size[0]; emxEnsureCapacity(sp, (emxArray__common *)r3, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = distToSource->size[0]; for (ix = 0; ix < loop_ub; ix++) { r3->data[ix] = 1.0 + distToSource->data[ix]; } rdivide(sp, forceMagnitude, r3, b_x); vlen = b_x->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = b_x->data[ix]; } } } iy = 0; while (iy < 3) { ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&b_emlrtBCI, sp); ix = forceDir->size[0]; iv1[0] = ix; iv1[1] = 1; for (ix = 0; ix < 2; ix++) { b_force[ix] = forceMag->size[ix]; } if ((iv1[0] != b_force[0]) || (1 != b_force[1])) { emlrtSizeEqCheckNDR2012b(iv1, b_force, (emlrtECInfo *)&c_emlrtECI, sp); } loop_ub = forceTemp->size[0]; ix = r2->size[0]; r2->size[0] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { r2->data[ix] = ix; } ix = forceTemp->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&emlrtBCI, sp); loop_ub = forceDir->size[0]; vlen = forceDir->size[0]; vstride = forceDir->size[0]; ix = b_forceDir->size[0]; b_forceDir->size[0] = vstride; emxEnsureCapacity(sp, (emxArray__common *)b_forceDir, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < vstride; ix++) { b_forceDir->data[ix] = forceDir->data[ix + forceDir->size[0] * iy]; } ix = c_forceDir->size[0] * c_forceDir->size[1]; c_forceDir->size[0] = loop_ub; c_forceDir->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)c_forceDir, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { c_forceDir->data[ix] = b_forceDir->data[ix]; } ix = b_x->size[0]; b_x->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < vlen; ix++) { b_x->data[ix] = c_forceDir->data[ix] * forceMag->data[ix]; } iv2[0] = r2->size[0]; emlrtSubAssignSizeCheckR2012b(iv2, 1, *(int32_T (*)[1])b_x->size, 1, (emlrtECInfo *)&b_emlrtECI, sp); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceTemp->data[r2->data[ix] + forceTemp->size[0] * iy] = b_x->data[ix]; } /* bsxfun(@times,forceDir,forceTemp); */ iy++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } iy = distToSource->size[0] - 1; vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (distToSource->data[vstride] > cutoff) { vlen++; } } ix = r2->size[0]; r2->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (distToSource->data[vstride] > cutoff) { r2->data[vlen] = vstride + 1; vlen++; } } loop_ub = forceTemp->size[1]; vstride = forceTemp->size[0]; vlen = r2->size[0]; for (ix = 0; ix < loop_ub; ix++) { for (ixstart = 0; ixstart < vlen; ixstart++) { iy = r2->data[ixstart]; if ((iy >= 1) && (iy < vstride)) { b_iy = iy; } else { b_iy = emlrtDynamicBoundsCheckR2012b(iy, 1, vstride, (emlrtBCInfo *) &f_emlrtBCI, sp); } forceTemp->data[(b_iy + forceTemp->size[0] * ix) - 1] = 0.0; } } ix = r1->size[0] * r1->size[1]; r1->size[0] = forceTemp->size[0]; r1->size[1] = forceTemp->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r1, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); loop_ub = forceTemp->size[0] * forceTemp->size[1]; for (ix = 0; ix < loop_ub; ix++) { r1->data[ix] = muDoubleScalarIsNaN(forceTemp->data[ix]); } iy = r1->size[0] * r1->size[1] - 1; vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (r1->data[vstride]) { vlen++; } } ix = r0->size[0]; r0->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)r0, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (r1->data[vstride]) { r0->data[vlen] = vstride + 1; vlen++; } } vstride = forceTemp->size[0]; vlen = forceTemp->size[1]; loop_ub = r0->size[0]; for (ix = 0; ix < loop_ub; ix++) { ixstart = vstride * vlen; iy = r0->data[ix]; if ((iy >= 1) && (iy < ixstart)) { c_iy = iy; } else { c_iy = emlrtDynamicBoundsCheckR2012b(iy, 1, ixstart, (emlrtBCInfo *) &g_emlrtBCI, sp); } forceTemp->data[c_iy - 1] = 0.0; } for (ix = 0; ix < 2; ix++) { b_force[ix] = force->size[ix]; } for (ix = 0; ix < 2; ix++) { b_forceTemp[ix] = forceTemp->size[ix]; } if ((b_force[0] != b_forceTemp[0]) || (b_force[1] != b_forceTemp[1])) { emlrtSizeEqCheckNDR2012b(b_force, b_forceTemp, (emlrtECInfo *)&emlrtECI, sp); } ix = force->size[0] * force->size[1]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); vlen = force->size[0]; vstride = force->size[1]; loop_ub = vlen * vstride; for (ix = 0; ix < loop_ub; ix++) { force->data[ix] += forceTemp->data[ix]; } sIdx++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_real_T(&c_forceDir); emxFree_real_T(&b_forceDir); emxFree_real_T(&b_pointSourcePosition); emxFree_real_T(&r4); emxFree_real_T(&r3); emxFree_real_T(&b_x); emxFree_real_T(&x); emxFree_int32_T(&r2); emxFree_boolean_T(&r1); emxFree_int32_T(&r0); emxFree_real_T(&distToSource); emxFree_real_T(&forceDir); emxFree_real_T(&forceMag); emxFree_real_T(&forceTemp); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
static void sf_c7_adcs_v15_integral_Power(void) { int32_T c7_i3; int32_T c7_i4; int32_T c7_previousEvent; int32_T c7_i5; real_T c7_x[7]; real_T c7_nargout = 1.0; real_T c7_nargin = 1.0; real_T c7_q[4]; real_T c7_xN[7]; int32_T c7_i6; int32_T c7_i7; real_T c7_A[4]; int32_T c7_i8; real_T c7_a[4]; int32_T c7_i9; real_T c7_b[4]; int32_T c7_i10; real_T c7_b_a[4]; int32_T c7_i11; real_T c7_b_b[4]; int32_T c7_i12; real_T c7_b_x[4]; int32_T c7_i13; real_T c7_y[4]; int32_T c7_i14; real_T c7_c_x[4]; int32_T c7_i15; real_T c7_b_y[4]; int32_T c7_i16; real_T c7_d_x[4]; int32_T c7_i17; real_T c7_c_y[4]; int32_T c7_i18; real_T c7_e_x[4]; int32_T c7_i19; real_T c7_d_y[4]; real_T c7_f_x; real_T c7_B; real_T c7_g_x; int32_T c7_i20; real_T c7_h_x[4]; real_T c7_e_y; int32_T c7_i21; real_T c7_i_x[4]; real_T c7_f_y; int32_T c7_i22; real_T c7_j_x[4]; real_T c7_g_y; int32_T c7_i23; int32_T c7_i24; int32_T c7_i25; int32_T c7_i26; real_T (*c7_b_xN)[7]; real_T (*c7_k_x)[7]; c7_b_xN = (real_T (*)[7])ssGetOutputPortSignal(chartInstance.S, 1); c7_k_x = (real_T (*)[7])ssGetInputPortSignal(chartInstance.S, 0); _sfTime_ = (real_T)ssGetT(chartInstance.S); _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG,5); for (c7_i3 = 0; c7_i3 < 7; c7_i3 = c7_i3 + 1) { _SFD_DATA_RANGE_CHECK((*c7_k_x)[c7_i3], 0U); } for (c7_i4 = 0; c7_i4 < 7; c7_i4 = c7_i4 + 1) { _SFD_DATA_RANGE_CHECK((*c7_b_xN)[c7_i4], 1U); } c7_previousEvent = _sfEvent_; _sfEvent_ = CALL_EVENT; _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,5); for (c7_i5 = 0; c7_i5 < 7; c7_i5 = c7_i5 + 1) { c7_x[c7_i5] = (*c7_k_x)[c7_i5]; } sf_debug_symbol_scope_push(5U, 0U); sf_debug_symbol_scope_add("nargout", &c7_nargout, c7_c_sf_marshall); sf_debug_symbol_scope_add("nargin", &c7_nargin, c7_c_sf_marshall); sf_debug_symbol_scope_add("q", &c7_q, c7_b_sf_marshall); sf_debug_symbol_scope_add("xN", &c7_xN, c7_sf_marshall); sf_debug_symbol_scope_add("x", &c7_x, c7_sf_marshall); CV_EML_FCN(0, 0); /* This block gives DCM for converting from ECI to ORBIT frames */ /* inputs: state vector in ECI */ /* output: DCM */ _SFD_EML_CALL(0,6); for (c7_i6 = 0; c7_i6 < 4; c7_i6 = c7_i6 + 1) { c7_q[c7_i6] = c7_x[c7_i6]; } _SFD_EML_CALL(0,7); for (c7_i7 = 0; c7_i7 < 4; c7_i7 = c7_i7 + 1) { c7_A[c7_i7] = c7_q[c7_i7]; } for (c7_i8 = 0; c7_i8 < 4; c7_i8 = c7_i8 + 1) { c7_a[c7_i8] = c7_q[c7_i8]; } for (c7_i9 = 0; c7_i9 < 4; c7_i9 = c7_i9 + 1) { c7_b[c7_i9] = c7_q[c7_i9]; } c7_eml_scalar_eg(); for (c7_i10 = 0; c7_i10 < 4; c7_i10 = c7_i10 + 1) { c7_b_a[c7_i10] = c7_a[c7_i10]; } for (c7_i11 = 0; c7_i11 < 4; c7_i11 = c7_i11 + 1) { c7_b_b[c7_i11] = c7_b[c7_i11]; } for (c7_i12 = 0; c7_i12 < 4; c7_i12 = c7_i12 + 1) { c7_b_x[c7_i12] = c7_b_a[c7_i12]; } for (c7_i13 = 0; c7_i13 < 4; c7_i13 = c7_i13 + 1) { c7_y[c7_i13] = c7_b_b[c7_i13]; } for (c7_i14 = 0; c7_i14 < 4; c7_i14 = c7_i14 + 1) { c7_c_x[c7_i14] = c7_b_x[c7_i14]; } for (c7_i15 = 0; c7_i15 < 4; c7_i15 = c7_i15 + 1) { c7_b_y[c7_i15] = c7_y[c7_i15]; } for (c7_i16 = 0; c7_i16 < 4; c7_i16 = c7_i16 + 1) { c7_d_x[c7_i16] = c7_c_x[c7_i16]; } for (c7_i17 = 0; c7_i17 < 4; c7_i17 = c7_i17 + 1) { c7_c_y[c7_i17] = c7_b_y[c7_i17]; } for (c7_i18 = 0; c7_i18 < 4; c7_i18 = c7_i18 + 1) { c7_e_x[c7_i18] = c7_d_x[c7_i18]; } for (c7_i19 = 0; c7_i19 < 4; c7_i19 = c7_i19 + 1) { c7_d_y[c7_i19] = c7_c_y[c7_i19]; } c7_f_x = c7_ceval_xdot(4, c7_e_x, 1, 1, c7_d_y, 1, 1); c7_B = c7_f_x; if (c7_B < 0.0) { c7_eml_error(); } c7_g_x = c7_B; c7_B = c7_g_x; c7_B = muDoubleScalarSqrt(c7_B); for (c7_i20 = 0; c7_i20 < 4; c7_i20 = c7_i20 + 1) { c7_h_x[c7_i20] = c7_A[c7_i20]; } c7_e_y = c7_B; if (c7_e_y == 0.0) { c7_eml_warning(); } for (c7_i21 = 0; c7_i21 < 4; c7_i21 = c7_i21 + 1) { c7_i_x[c7_i21] = c7_h_x[c7_i21]; } c7_f_y = c7_e_y; for (c7_i22 = 0; c7_i22 < 4; c7_i22 = c7_i22 + 1) { c7_j_x[c7_i22] = c7_i_x[c7_i22]; } c7_g_y = c7_f_y; for (c7_i23 = 0; c7_i23 < 4; c7_i23 = c7_i23 + 1) { c7_q[c7_i23] = c7_j_x[c7_i23] / c7_g_y; } _SFD_EML_CALL(0,8); for (c7_i24 = 0; c7_i24 < 4; c7_i24 = c7_i24 + 1) { c7_xN[c7_i24] = c7_q[c7_i24]; } for (c7_i25 = 0; c7_i25 < 3; c7_i25 = c7_i25 + 1) { c7_xN[c7_i25 + 4] = c7_x[c7_i25 + 4]; } _SFD_EML_CALL(0,-8); sf_debug_symbol_scope_pop(); for (c7_i26 = 0; c7_i26 < 7; c7_i26 = c7_i26 + 1) { (*c7_b_xN)[c7_i26] = c7_xN[c7_i26]; } _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,5); _sfEvent_ = c7_previousEvent; sf_debug_check_for_state_inconsistency(_adcs_v15_integral_PowerMachineNumber_, chartInstance.chartNumber, chartInstance. instanceNumber); }
static void sf_c4_MigrationBGOW_Proto6_MultiSwarm (SFc4_MigrationBGOW_Proto6_MultiSwarmInstanceStruct *chartInstance) { real_T c4_hoistedGlobal; real_T c4_b_hoistedGlobal; real_T c4_x; real_T c4_y; uint32_T c4_debug_family_var_map[5]; real_T c4_nargin = 2.0; real_T c4_nargout = 1.0; real_T c4_z; real_T c4_b_x; real_T c4_c_x; real_T *c4_d_x; real_T *c4_b_y; real_T *c4_b_z; c4_b_z = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1); c4_b_y = (real_T *)ssGetInputPortSignal(chartInstance->S, 1); c4_d_x = (real_T *)ssGetInputPortSignal(chartInstance->S, 0); _sfTime_ = (real_T)ssGetT(chartInstance->S); _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 3U, chartInstance->c4_sfEvent); _SFD_DATA_RANGE_CHECK(*c4_d_x, 0U); _SFD_DATA_RANGE_CHECK(*c4_b_y, 1U); _SFD_DATA_RANGE_CHECK(*c4_b_z, 2U); chartInstance->c4_sfEvent = CALL_EVENT; _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 3U, chartInstance->c4_sfEvent); c4_hoistedGlobal = *c4_d_x; c4_b_hoistedGlobal = *c4_b_y; c4_x = c4_hoistedGlobal; c4_y = c4_b_hoistedGlobal; _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 5U, 5U, c4_debug_family_names, c4_debug_family_var_map); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c4_nargin, 0U, c4_sf_marshallOut, c4_sf_marshallIn); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c4_nargout, 1U, c4_sf_marshallOut, c4_sf_marshallIn); _SFD_SYMBOL_SCOPE_ADD_EML(&c4_x, 2U, c4_sf_marshallOut); _SFD_SYMBOL_SCOPE_ADD_EML(&c4_y, 3U, c4_sf_marshallOut); _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c4_z, 4U, c4_sf_marshallOut, c4_sf_marshallIn); CV_EML_FCN(0, 0); _SFD_EML_CALL(0U, chartInstance->c4_sfEvent, 3); c4_b_x = (26.4196 - c4_mpower(chartInstance, c4_x - 1.44)) - c4_mpower (chartInstance, c4_y - 0.3677); c4_z = c4_b_x; if (c4_z < 0.0) { c4_eml_error(chartInstance); } c4_c_x = c4_z; c4_z = c4_c_x; c4_z = muDoubleScalarSqrt(c4_z); _SFD_EML_CALL(0U, chartInstance->c4_sfEvent, 4); c4_z += 1.6; _SFD_EML_CALL(0U, chartInstance->c4_sfEvent, -4); _SFD_SYMBOL_SCOPE_POP(); *c4_b_z = c4_z; _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 3U, chartInstance->c4_sfEvent); _SFD_CHECK_FOR_STATE_INCONSISTENCY (_MigrationBGOW_Proto6_MultiSwarmMachineNumber_, chartInstance->chartNumber, chartInstance->instanceNumber); }
static void sf_c1_my_demo_ref(SFc1_my_demo_refInstanceStruct *chartInstance) { int32_T c1_i0; real_T c1_hoistedGlobal; real_T c1_b_hoistedGlobal; real_T c1_x; real_T c1_y; int32_T c1_i1; real_T c1_fpath[170]; uint32_T c1_debug_family_var_map[13]; real_T c1_dmin; real_T c1_xx[85]; real_T c1_yy[85]; real_T c1_d; real_T c1_nargin = 3.0; real_T c1_nargout = 3.0; real_T c1_x_g; real_T c1_y_g; real_T c1_stop; int32_T c1_i2; int32_T c1_i3; real_T c1_c_hoistedGlobal; real_T c1_d_hoistedGlobal; real_T c1_b_x; real_T c1_c_x; real_T *c1_b_x_g; real_T *c1_b_y_g; real_T *c1_d_x; real_T *c1_b_y; real_T *c1_b_stop; real_T (*c1_b_fpath)[170]; boolean_T guard1 = FALSE; boolean_T guard2 = FALSE; c1_b_stop = (real_T *)ssGetOutputPortSignal(chartInstance->S, 3); c1_b_fpath = (real_T (*)[170])ssGetInputPortSignal(chartInstance->S, 2); c1_b_y = (real_T *)ssGetInputPortSignal(chartInstance->S, 1); c1_d_x = (real_T *)ssGetInputPortSignal(chartInstance->S, 0); c1_b_y_g = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2); c1_b_x_g = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1); _sfTime_ = (real_T)ssGetT(chartInstance->S); _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent); _SFD_DATA_RANGE_CHECK(*c1_b_x_g, 0U); _SFD_DATA_RANGE_CHECK(*c1_b_y_g, 1U); _SFD_DATA_RANGE_CHECK(*c1_d_x, 2U); _SFD_DATA_RANGE_CHECK(*c1_b_y, 3U); for (c1_i0 = 0; c1_i0 < 170; c1_i0++) { _SFD_DATA_RANGE_CHECK((*c1_b_fpath)[c1_i0], 4U); } _SFD_DATA_RANGE_CHECK(*c1_b_stop, 5U); chartInstance->c1_sfEvent = CALL_EVENT; _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent); c1_hoistedGlobal = *c1_d_x; c1_b_hoistedGlobal = *c1_b_y; c1_x = c1_hoistedGlobal; c1_y = c1_b_hoistedGlobal; for (c1_i1 = 0; c1_i1 < 170; c1_i1++) { c1_fpath[c1_i1] = (*c1_b_fpath)[c1_i1]; } sf_debug_symbol_scope_push_eml(0U, 13U, 13U, c1_debug_family_names, c1_debug_family_var_map); sf_debug_symbol_scope_add_eml_importable(&c1_dmin, 0U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(c1_xx, 1U, c1_d_sf_marshallOut, c1_c_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(c1_yy, 2U, c1_d_sf_marshallOut, c1_c_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&c1_d, 3U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&c1_nargin, 4U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&c1_nargout, 5U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml(&c1_x, 6U, c1_b_sf_marshallOut); sf_debug_symbol_scope_add_eml(&c1_y, 7U, c1_b_sf_marshallOut); sf_debug_symbol_scope_add_eml(c1_fpath, 8U, c1_c_sf_marshallOut); sf_debug_symbol_scope_add_eml_importable(&c1_x_g, 9U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&c1_y_g, 10U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&c1_stop, 11U, c1_b_sf_marshallOut, c1_b_sf_marshallIn); sf_debug_symbol_scope_add_eml_importable(&chartInstance->c1_i, 12U, c1_sf_marshallOut, c1_sf_marshallIn); CV_EML_FCN(0, 0); _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 6); _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 7); if (CV_EML_IF(0, 1, 0, !chartInstance->c1_i_not_empty)) { _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 8); chartInstance->c1_i = 1.0; chartInstance->c1_i_not_empty = TRUE; } _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 12); c1_stop = 0.0; _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 13); c1_dmin = 0.1; _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 26); for (c1_i2 = 0; c1_i2 < 85; c1_i2++) { c1_xx[c1_i2] = c1_fpath[c1_i2]; } _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 27); for (c1_i3 = 0; c1_i3 < 85; c1_i3++) { c1_yy[c1_i3] = c1_fpath[c1_i3 + 85]; } _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 29); c1_c_hoistedGlobal = chartInstance->c1_i; c1_d_hoistedGlobal = chartInstance->c1_i; c1_b_x = c1_mpower(chartInstance, c1_x - c1_xx[_SFD_EML_ARRAY_BOUNDS_CHECK( "xx", (int32_T)_SFD_INTEGER_CHECK("i", c1_c_hoistedGlobal), 1, 85, 1, 0) - 1]) + c1_mpower(chartInstance, c1_y - c1_yy[_SFD_EML_ARRAY_BOUNDS_CHECK("yy", (int32_T)_SFD_INTEGER_CHECK("i", c1_d_hoistedGlobal), 1, 85, 1, 0) - 1]); c1_d = c1_b_x; if (c1_d < 0.0) { c1_eml_error(chartInstance); } c1_c_x = c1_d; c1_d = c1_c_x; c1_d = muDoubleScalarSqrt(c1_d); _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 31); guard2 = FALSE; if (CV_EML_COND(0, 1, 0, c1_d < c1_dmin)) { if (CV_EML_COND(0, 1, 1, chartInstance->c1_i < 85.0)) { CV_EML_MCDC(0, 1, 0, TRUE); CV_EML_IF(0, 1, 1, TRUE); _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 32); chartInstance->c1_i++; } else { guard2 = TRUE; } } else { guard2 = TRUE; } if (guard2 == TRUE) { CV_EML_MCDC(0, 1, 0, FALSE); CV_EML_IF(0, 1, 1, FALSE); } _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 36); c1_x_g = c1_xx[_SFD_EML_ARRAY_BOUNDS_CHECK("xx", (int32_T)_SFD_INTEGER_CHECK( "i", chartInstance->c1_i), 1, 85, 1, 0) - 1]; _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 37); c1_y_g = c1_yy[_SFD_EML_ARRAY_BOUNDS_CHECK("yy", (int32_T)_SFD_INTEGER_CHECK( "i", chartInstance->c1_i), 1, 85, 1, 0) - 1]; _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 40); guard1 = FALSE; if (CV_EML_COND(0, 1, 2, c1_d < c1_dmin)) { if (CV_EML_COND(0, 1, 3, chartInstance->c1_i == 85.0)) { CV_EML_MCDC(0, 1, 1, TRUE); CV_EML_IF(0, 1, 2, TRUE); _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 41); c1_stop = 1.0; } else { guard1 = TRUE; } } else { guard1 = TRUE; } if (guard1 == TRUE) { CV_EML_MCDC(0, 1, 1, FALSE); CV_EML_IF(0, 1, 2, FALSE); } _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -41); sf_debug_symbol_scope_pop(); *c1_b_x_g = c1_x_g; *c1_b_y_g = c1_y_g; *c1_b_stop = c1_stop; _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent); sf_debug_check_for_state_inconsistency(_my_demo_refMachineNumber_, chartInstance->chartNumber, chartInstance->instanceNumber); }
void b_Acoeff(const emlrtStack *sp, real_T ksi, real_T j, const emxArray_real_T * x, real_T t, const emxArray_real_T *gridT, emxArray_real_T *vals) { emxArray_real_T *b; emxArray_real_T *r8; int32_T b_x; int32_T i; emxArray_boolean_T *b_t; real_T c_x; emxArray_boolean_T *c_t; emxArray_real_T *z0; emxArray_real_T *d_x; emxArray_real_T *e_x; emxArray_real_T *r9; int32_T b_b[2]; int32_T f_x[2]; emxArray_real_T *g_x; emxArray_real_T *r10; const mxArray *y; static const int32_T iv16[2] = { 1, 45 }; const mxArray *m6; char_T cv18[45]; static const char_T cv19[45] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o', 'l', 'b', 'o', 'x', ':', 'm', 't', 'i', 'm', 'e', 's', '_', 'n', 'o', 'D', 'y', 'n', 'a', 'm', 'i', 'c', 'S', 'c', 'a', 'l', 'a', 'r', 'E', 'x', 'p', 'a', 'n', 's', 'i', 'o', 'n' }; const mxArray *b_y; static const int32_T iv17[2] = { 1, 21 }; char_T cv20[21]; static const char_T cv21[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T', 'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' }; emxArray_boolean_T *d_t; real_T h_x; emxArray_boolean_T *e_t; emxArray_real_T *i_x; emxArray_real_T *r11; emxArray_real_T *j_x; emxArray_real_T *r12; emxArray_real_T *z1; int32_T b_z0[2]; emxArray_real_T *c_z0; emxArray_real_T *k_x; const mxArray *c_y; static const int32_T iv18[2] = { 1, 45 }; const mxArray *d_y; static const int32_T iv19[2] = { 1, 21 }; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; d_st.prev = &b_st; d_st.tls = b_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); emxInit_real_T(sp, &b, 2, &bb_emlrtRTEI, true); emxInit_real_T(sp, &r8, 2, &bb_emlrtRTEI, true); /* evaluate the coefficient A at the boundary ksi=0 or ksi=1; */ /* for the index j which describes the time steps timePoints_j, at time t and space */ /* point x */ /* timePoints is a vector describing the time descritized domain */ b_x = gridT->size[1]; i = (int32_T)emlrtIntegerCheckFastR2012b(j, &emlrtDCI, sp); if (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &d_emlrtBCI, sp) - 1]) { b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof(real_T), &bb_emlrtRTEI); vals->data[0] = 0.0; } else { emxInit_boolean_T(sp, &b_t, 2, &bb_emlrtRTEI, true); b_x = b_t->size[0] * b_t->size[1]; b_t->size[0] = 1; b_t->size[1] = 2 + x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)b_t, b_x, (int32_T)sizeof (boolean_T), &bb_emlrtRTEI); b_x = gridT->size[1]; i = (int32_T)j; b_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &e_emlrtBCI, sp) - 1]); b_x = gridT->size[1]; i = (int32_T)((uint32_T)j + 1U); b_t->data[b_t->size[0]] = (t <= gridT-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &f_emlrtBCI, sp) - 1]); i = x->size[1]; for (b_x = 0; b_x < i; b_x++) { b_t->data[b_t->size[0] * (b_x + 2)] = (x->data[x->size[0] * b_x] == ksi); } st.site = &pe_emlrtRSI; if (all(&st, b_t)) { b_x = gridT->size[1]; i = (int32_T)j; emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &c_emlrtBCI, sp); c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931; st.site = &emlrtRSI; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); vals->data[0] = muDoubleScalarSqrt(c_x); } else { emxInit_boolean_T(sp, &c_t, 2, &bb_emlrtRTEI, true); b_x = c_t->size[0] * c_t->size[1]; c_t->size[0] = 1; c_t->size[1] = 2 + x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)c_t, b_x, (int32_T)sizeof (boolean_T), &bb_emlrtRTEI); b_x = gridT->size[1]; i = (int32_T)j; c_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &g_emlrtBCI, sp) - 1]); b_x = gridT->size[1]; i = (int32_T)((uint32_T)j + 1U); c_t->data[c_t->size[0]] = (t <= gridT-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &h_emlrtBCI, sp) - 1]); i = x->size[1]; for (b_x = 0; b_x < i; b_x++) { c_t->data[c_t->size[0] * (b_x + 2)] = (x->data[x->size[0] * b_x] != ksi); } emxInit_real_T(sp, &z0, 2, &cb_emlrtRTEI, true); emxInit_real_T(sp, &d_x, 2, &bb_emlrtRTEI, true); st.site = &qe_emlrtRSI; if (all(&st, c_t)) { st.site = &b_emlrtRSI; b_x = gridT->size[1]; i = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &m_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } emxInit_real_T(&st, &e_x, 2, &bb_emlrtRTEI, true); b_x = e_x->size[0] * e_x->size[1]; e_x->size[0] = 1; e_x->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)e_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = x->size[0] * x->size[1]; for (b_x = 0; b_x < i; b_x++) { e_x->data[b_x] = x->data[b_x] - ksi; } emxInit_real_T(sp, &r9, 2, &bb_emlrtRTEI, true); b_abs(sp, e_x, r9); b_x = r8->size[0] * r8->size[1]; r8->size[0] = 1; r8->size[1] = r9->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = r9->size[0] * r9->size[1]; emxFree_real_T(&e_x); for (b_x = 0; b_x < i; b_x++) { r8->data[b_x] = r9->data[b_x]; } emxFree_real_T(&r9); rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z0); st.site = &re_emlrtRSI; mpower(&st, z0, d_x); b_x = d_x->size[0] * d_x->size[1]; d_x->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0]; b_x = d_x->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { d_x->data[b_x] = -d_x->data[b_x]; } b_x = b->size[0] * b->size[1]; b->size[0] = 1; b->size[1] = d_x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)b, b_x, (int32_T)sizeof(real_T), &bb_emlrtRTEI); i = d_x->size[0] * d_x->size[1]; for (b_x = 0; b_x < i; b_x++) { b->data[b_x] = d_x->data[b_x]; } for (i = 0; i < d_x->size[1]; i++) { b->data[i] = muDoubleScalarExp(b->data[i]); } st.site = &re_emlrtRSI; b_mrdivide(&st, b, z0); for (b_x = 0; b_x < 2; b_x++) { i = d_x->size[0] * d_x->size[1]; d_x->size[b_x] = z0->size[b_x]; emxEnsureCapacity(sp, (emxArray__common *)d_x, i, (int32_T)sizeof (real_T), &ab_emlrtRTEI); } for (i = 0; i < z0->size[1]; i++) { d_x->data[i] = scalar_erf(z0->data[i]); } b_x = d_x->size[0] * d_x->size[1]; d_x->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0]; b_x = d_x->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { d_x->data[b_x] *= 1.7724538509055159; } for (b_x = 0; b_x < 2; b_x++) { b_b[b_x] = b->size[b_x]; } for (b_x = 0; b_x < 2; b_x++) { f_x[b_x] = d_x->size[b_x]; } emxInit_real_T(sp, &g_x, 2, &bb_emlrtRTEI, true); emlrtSizeEqCheck2DFastR2012b(b_b, f_x, &o_emlrtECI, sp); b_x = g_x->size[0] * g_x->size[1]; g_x->size[0] = 1; g_x->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)g_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = x->size[0] * x->size[1]; for (b_x = 0; b_x < i; b_x++) { g_x->data[b_x] = x->data[b_x] - ksi; } emxInit_real_T(sp, &r10, 2, &bb_emlrtRTEI, true); b_abs(sp, g_x, r10); b_x = r8->size[0] * r8->size[1]; r8->size[0] = 1; r8->size[1] = r10->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = r10->size[0] * r10->size[1]; emxFree_real_T(&g_x); for (b_x = 0; b_x < i; b_x++) { r8->data[b_x] = r10->data[b_x]; } emxFree_real_T(&r10); rdivide(sp, r8, 3.5449077018110318, vals); st.site = &re_emlrtRSI; b_x = b->size[0] * b->size[1]; b->size[0] = 1; emxEnsureCapacity(&st, (emxArray__common *)b, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = b->size[0]; b_x = b->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { b->data[b_x] -= d_x->data[b_x]; } b_st.site = &he_emlrtRSI; if (!(vals->size[1] == 1)) { if ((vals->size[1] == 1) || (b->size[1] == 1)) { y = NULL; m6 = emlrtCreateCharArray(2, iv16); for (i = 0; i < 45; i++) { cv18[i] = cv19[i]; } emlrtInitCharArrayR2013a(&b_st, 45, m6, cv18); emlrtAssign(&y, m6); c_st.site = &fh_emlrtRSI; d_st.site = &vg_emlrtRSI; b_error(&c_st, message(&d_st, y, &j_emlrtMCI), &k_emlrtMCI); } else { b_y = NULL; m6 = emlrtCreateCharArray(2, iv17); for (i = 0; i < 21; i++) { cv20[i] = cv21[i]; } emlrtInitCharArrayR2013a(&b_st, 21, m6, cv20); emlrtAssign(&b_y, m6); c_st.site = &gh_emlrtRSI; d_st.site = &wg_emlrtRSI; b_error(&c_st, message(&d_st, b_y, &l_emlrtMCI), &m_emlrtMCI); } } c_x = vals->data[0]; b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = b->size[1]; emxEnsureCapacity(&st, (emxArray__common *)vals, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = b->size[1]; for (b_x = 0; b_x < i; b_x++) { vals->data[vals->size[0] * b_x] = c_x * b->data[b->size[0] * b_x]; } } else { emxInit_boolean_T(sp, &d_t, 2, &bb_emlrtRTEI, true); b_x = d_t->size[0] * d_t->size[1]; d_t->size[0] = 1; d_t->size[1] = 1 + x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)d_t, b_x, (int32_T)sizeof (boolean_T), &bb_emlrtRTEI); b_x = gridT->size[1]; i = (int32_T)((uint32_T)j + 1U); d_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &i_emlrtBCI, sp) - 1]); i = x->size[1]; for (b_x = 0; b_x < i; b_x++) { d_t->data[d_t->size[0] * (b_x + 1)] = (x->data[x->size[0] * b_x] == ksi); } st.site = &se_emlrtRSI; if (all(&st, d_t)) { b_x = gridT->size[1]; i = (int32_T)j; emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &b_emlrtBCI, sp); c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931; b_x = gridT->size[1]; i = (int32_T)(j + 1.0); emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &emlrtBCI, sp); h_x = (t - gridT->data[(int32_T)(j + 1.0) - 1]) / 3.1415926535897931; st.site = &c_emlrtRSI; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } st.site = &c_emlrtRSI; if (h_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); vals->data[0] = muDoubleScalarSqrt(c_x) - muDoubleScalarSqrt(h_x); } else { emxInit_boolean_T(sp, &e_t, 2, &bb_emlrtRTEI, true); b_x = e_t->size[0] * e_t->size[1]; e_t->size[0] = 1; e_t->size[1] = 1 + x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)e_t, b_x, (int32_T)sizeof (boolean_T), &bb_emlrtRTEI); b_x = gridT->size[1]; i = (int32_T)((uint32_T)j + 1U); e_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &j_emlrtBCI, sp) - 1]); i = x->size[1]; for (b_x = 0; b_x < i; b_x++) { e_t->data[e_t->size[0] * (b_x + 1)] = (x->data[x->size[0] * b_x] != ksi); } st.site = &te_emlrtRSI; if (all(&st, e_t)) { st.site = &d_emlrtRSI; b_x = gridT->size[1]; i = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &k_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } emxInit_real_T(&st, &i_x, 2, &bb_emlrtRTEI, true); b_x = i_x->size[0] * i_x->size[1]; i_x->size[0] = 1; i_x->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)i_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = x->size[0] * x->size[1]; for (b_x = 0; b_x < i; b_x++) { i_x->data[b_x] = x->data[b_x] - ksi; } emxInit_real_T(sp, &r11, 2, &bb_emlrtRTEI, true); b_abs(sp, i_x, r11); b_x = r8->size[0] * r8->size[1]; r8->size[0] = 1; r8->size[1] = r11->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = r11->size[0] * r11->size[1]; emxFree_real_T(&i_x); for (b_x = 0; b_x < i; b_x++) { r8->data[b_x] = r11->data[b_x]; } emxFree_real_T(&r11); rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z0); st.site = &e_emlrtRSI; b_x = gridT->size[1]; i = (int32_T)((uint32_T)j + 1U); c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &l_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } emxInit_real_T(&st, &j_x, 2, &bb_emlrtRTEI, true); b_x = j_x->size[0] * j_x->size[1]; j_x->size[0] = 1; j_x->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)j_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = x->size[0] * x->size[1]; for (b_x = 0; b_x < i; b_x++) { j_x->data[b_x] = x->data[b_x] - ksi; } emxInit_real_T(sp, &r12, 2, &bb_emlrtRTEI, true); b_abs(sp, j_x, r12); b_x = r8->size[0] * r8->size[1]; r8->size[0] = 1; r8->size[1] = r12->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = r12->size[0] * r12->size[1]; emxFree_real_T(&j_x); for (b_x = 0; b_x < i; b_x++) { r8->data[b_x] = r12->data[b_x]; } emxFree_real_T(&r12); emxInit_real_T(sp, &z1, 2, &db_emlrtRTEI, true); rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z1); st.site = &ue_emlrtRSI; mpower(&st, z0, d_x); b_x = d_x->size[0] * d_x->size[1]; d_x->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0]; b_x = d_x->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { d_x->data[b_x] = -d_x->data[b_x]; } b_x = b->size[0] * b->size[1]; b->size[0] = 1; b->size[1] = d_x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)b, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0] * d_x->size[1]; for (b_x = 0; b_x < i; b_x++) { b->data[b_x] = d_x->data[b_x]; } for (i = 0; i < d_x->size[1]; i++) { b->data[i] = muDoubleScalarExp(b->data[i]); } st.site = &ue_emlrtRSI; b_mrdivide(&st, b, z0); st.site = &ue_emlrtRSI; mpower(&st, z1, d_x); b_x = d_x->size[0] * d_x->size[1]; d_x->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0]; b_x = d_x->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { d_x->data[b_x] = -d_x->data[b_x]; } b_x = r8->size[0] * r8->size[1]; r8->size[0] = 1; r8->size[1] = d_x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = d_x->size[0] * d_x->size[1]; for (b_x = 0; b_x < i; b_x++) { r8->data[b_x] = d_x->data[b_x]; } for (i = 0; i < d_x->size[1]; i++) { r8->data[i] = muDoubleScalarExp(r8->data[i]); } st.site = &ue_emlrtRSI; b_mrdivide(&st, r8, z1); for (b_x = 0; b_x < 2; b_x++) { b_b[b_x] = b->size[b_x]; } for (b_x = 0; b_x < 2; b_x++) { b_z0[b_x] = r8->size[b_x]; } emxInit_real_T(sp, &c_z0, 2, &bb_emlrtRTEI, true); emlrtSizeEqCheck2DFastR2012b(b_b, b_z0, &m_emlrtECI, sp); b_x = c_z0->size[0] * c_z0->size[1]; c_z0->size[0] = 1; c_z0->size[1] = z0->size[1]; emxEnsureCapacity(sp, (emxArray__common *)c_z0, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = z0->size[0] * z0->size[1]; for (b_x = 0; b_x < i; b_x++) { c_z0->data[b_x] = z0->data[b_x]; } b_erf(sp, c_z0, z0); b_erf(sp, z1, d_x); emxFree_real_T(&c_z0); emxFree_real_T(&z1); for (b_x = 0; b_x < 2; b_x++) { b_z0[b_x] = z0->size[b_x]; } for (b_x = 0; b_x < 2; b_x++) { f_x[b_x] = d_x->size[b_x]; } emlrtSizeEqCheck2DFastR2012b(b_z0, f_x, &n_emlrtECI, sp); b_x = z0->size[0] * z0->size[1]; z0->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)z0, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = z0->size[0]; b_x = z0->size[1]; i *= b_x; for (b_x = 0; b_x < i; b_x++) { z0->data[b_x] = 1.7724538509055159 * (z0->data[b_x] - d_x-> data[b_x]); } for (b_x = 0; b_x < 2; b_x++) { b_b[b_x] = b->size[b_x]; } for (b_x = 0; b_x < 2; b_x++) { b_z0[b_x] = z0->size[b_x]; } emxInit_real_T(sp, &k_x, 2, &bb_emlrtRTEI, true); emlrtSizeEqCheck2DFastR2012b(b_b, b_z0, &m_emlrtECI, sp); b_x = k_x->size[0] * k_x->size[1]; k_x->size[0] = 1; k_x->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)k_x, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = x->size[0] * x->size[1]; for (b_x = 0; b_x < i; b_x++) { k_x->data[b_x] = x->data[b_x] - ksi; } b_abs(sp, k_x, d_x); rdivide(sp, d_x, 3.5449077018110318, vals); st.site = &ue_emlrtRSI; b_x = b->size[0] * b->size[1]; b->size[0] = 1; emxEnsureCapacity(&st, (emxArray__common *)b, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); i = b->size[0]; b_x = b->size[1]; i *= b_x; emxFree_real_T(&k_x); for (b_x = 0; b_x < i; b_x++) { b->data[b_x] = (b->data[b_x] - r8->data[b_x]) + z0->data[b_x]; } b_st.site = &he_emlrtRSI; if (!(vals->size[1] == 1)) { if ((vals->size[1] == 1) || (b->size[1] == 1)) { c_y = NULL; m6 = emlrtCreateCharArray(2, iv18); for (i = 0; i < 45; i++) { cv18[i] = cv19[i]; } emlrtInitCharArrayR2013a(&b_st, 45, m6, cv18); emlrtAssign(&c_y, m6); c_st.site = &fh_emlrtRSI; d_st.site = &vg_emlrtRSI; b_error(&c_st, message(&d_st, c_y, &j_emlrtMCI), &k_emlrtMCI); } else { d_y = NULL; m6 = emlrtCreateCharArray(2, iv19); for (i = 0; i < 21; i++) { cv20[i] = cv21[i]; } emlrtInitCharArrayR2013a(&b_st, 21, m6, cv20); emlrtAssign(&d_y, m6); c_st.site = &gh_emlrtRSI; d_st.site = &wg_emlrtRSI; b_error(&c_st, message(&d_st, d_y, &l_emlrtMCI), &m_emlrtMCI); } } c_x = vals->data[0]; b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = b->size[1]; emxEnsureCapacity(&st, (emxArray__common *)vals, b_x, (int32_T) sizeof(real_T), &bb_emlrtRTEI); i = b->size[1]; for (b_x = 0; b_x < i; b_x++) { vals->data[vals->size[0] * b_x] = c_x * b->data[b->size[0] * b_x]; } } else { b_x = vals->size[0] * vals->size[1]; vals->size[0] = 1; vals->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof (real_T), &bb_emlrtRTEI); vals->data[0] = 0.0; } emxFree_boolean_T(&e_t); } emxFree_boolean_T(&d_t); } emxFree_boolean_T(&c_t); emxFree_real_T(&d_x); emxFree_real_T(&z0); } emxFree_boolean_T(&b_t); } emxFree_real_T(&r8); emxFree_real_T(&b); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
/* Function Definitions */ real_T Bcoeff(const emlrtStack *sp, real_T ksi, real_T j, real_T x, real_T t, const emxArray_real_T *gridT) { real_T vals; int32_T k; int32_T i1; boolean_T b_x[3]; boolean_T y; boolean_T exitg2; boolean_T exitg1; real_T c_x; real_T d_x; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* evaluate the coefficient B at the boundary ksi=0 or ksi=1; */ /* for the index j which describes the time steps timePoints_j, at time t and space */ /* point x */ /* timePoints is a vector describing the time descritized domain */ k = gridT->size[1]; i1 = (int32_T)emlrtIntegerCheckFastR2012b(j, &b_emlrtDCI, sp); if (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &n_emlrtBCI, sp) - 1]) { vals = 0.0; } else { k = gridT->size[1]; i1 = (int32_T)j; b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &o_emlrtBCI, sp) - 1]); k = gridT->size[1]; i1 = (int32_T)((uint32_T)j + 1U); b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &p_emlrtBCI, sp) - 1]); b_x[2] = (x == ksi); y = true; k = 0; exitg2 = false; while ((!exitg2) && (k < 3)) { if (b_x[k] == 0) { y = false; exitg2 = true; } else { k++; } } if (y) { vals = 0.0; } else { k = gridT->size[1]; i1 = (int32_T)j; b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &q_emlrtBCI, sp) - 1]); k = gridT->size[1]; i1 = (int32_T)((uint32_T)j + 1U); b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &r_emlrtBCI, sp) - 1]); b_x[2] = (x != ksi); y = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 3)) { if (b_x[k] == 0) { y = false; exitg1 = true; } else { k++; } } if (y) { st.site = &g_emlrtRSI; k = gridT->size[1]; i1 = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &v_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } vals = -scalar_erf(muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(c_x))) / 2.0; } else { k = gridT->size[1]; i1 = (int32_T)((uint32_T)j + 1U); if (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &s_emlrtBCI, sp) - 1]) { st.site = &h_emlrtRSI; k = gridT->size[1]; i1 = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &t_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } st.site = &i_emlrtRSI; k = gridT->size[1]; i1 = (int32_T)((uint32_T)j + 1U); d_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &u_emlrtBCI, &st) - 1]; if (d_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } vals = (b_scalar_erf(muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(c_x))) - b_scalar_erf(muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(d_x)))) / 2.0; } else { vals = 0.0; } } } } return vals; }
/* Function Definitions */ void clcPMP_olyHyb_tmp(const emlrtStack *sp, real_T engKinPre, real_T engKinAct, real_T gea, real_T slp, real_T batEng, real_T psiBatEng, real_T psiTim, real_T batPwrAux, real_T batEngStp, real_T wayStp, const struct0_T *par, real_T *cosHamMin, real_T *batFrcOut, real_T *fulFrcOut) { real_T mtmp; real_T vehVel; real_T b_engKinPre[2]; real_T crsSpdVec[2]; int32_T i18; int32_T k; boolean_T y; boolean_T exitg3; boolean_T exitg2; real_T crsSpd; real_T whlTrq; real_T crsTrq; real_T iceTrqMax; real_T iceTrqMin; real_T b_par[100]; real_T emoTrqMaxPos; real_T emoTrqMinPos; real_T emoTrqMax; real_T emoTrqMin; real_T batPwrMax; real_T batPwrMin; real_T batOcv; real_T batEngDltMin; real_T batEngDltMax; real_T batEngDltMinInx; real_T batEngDltMaxInx; real_T batEngDlt; real_T fulFrc; real_T batFrc; real_T b_batFrc; real_T batPwr; real_T emoTrq; real_T iceTrq; real_T fulPwr; int32_T ixstart; int32_T itmp; int32_T ix; boolean_T exitg1; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* CLCPMP Minimizing Hamiltonian: Co-States for soc and time */ /* Erstellungsdatum der ersten Version 19.08.2015 - Stephan Uebel */ /* */ /* Batterieleistungsgrenzen hinzugefügt am 13.12.2015 */ /* ^^added battery power limit */ /* */ /* Massenaufschlag durch Trägheitsmoment herausgenommen */ /* ^^Mass increment removed by inertia */ /* */ /* % Inputdefinition */ /* */ /* engKinPre - Double(1,1) - kinetische Energie am Intervallanfang in J */ /* ^^ kinetic energy at start of interval (J) */ /* engKinAct - Double(1,1) - kinetische Energie am Intervallende in J */ /* ^^ kinetic energe at end of interval (J) */ /* gea - Double(1,1) - Gang */ /* ^^ gear */ /* slp - Double(1,1) - Steigung in rad */ /* ^^ slope in radians */ /* iceFlg - Boolean(1,1) - Flag für Motorzustand */ /* ^^ flag for motor condition */ /* batEng - Double(1,1) - Batterieenergie in J */ /* ^^ battery energy (J) */ /* psibatEng - Double(1,1) - Costate für Batterieenergie ohne Einheit */ /* ^^ costate for battery energy w/o unity */ /* psiTim - Double(1,1) - Costate für die Zeit ohne Einheit */ /* ^^ costate for time without unity */ /* batPwrAux - Double(1,1) - elektr. Nebenverbraucherleistung in W */ /* ^^ electric auxiliary power consumed (W) */ /* batEngStp - Double(1,1) - Drehmomentschritt */ /* ^^ torque step <- no, it's a battery step */ /* wayStp - Double(1,1) - Intervallschrittweite in m */ /* ^^ interval step distance (m) */ /* par - Struct(1,1) - Modelldaten */ /* ^^ model data */ /* % Initialisieren der Ausgabe der Funktion */ /* initializing function output */ /* Ausgabewert des Minimums der Hamiltonfunktion */ /* output for minimizing the hamiltonian */ *cosHamMin = rtInf; /* Batterieladungsänderung im Wegschritt beir minimaler Hamiltonfunktion */ /* battery change in path_idx step with the minial hamiltonian */ *batFrcOut = rtInf; /* Kraftstoffkraftänderung im Wegschritt bei minimaler Hamiltonfunktion */ /* fuel change in path_idx step with the minimal hamiltonian */ *fulFrcOut = 0.0; /* % Initialisieren der persistent Größen */ /* initialize the persistance variables */ /* Diese werden die nur einmal für die Funktion berechnet */ /* only calculated once for the function */ if (!crsSpdHybMax_not_empty) { /* maximale Drehzahl Elektrommotor */ /* maximum electric motor rotational speed */ /* maximale Drehzahl der Kurbelwelle */ /* maximum crankshaft rotational speed */ crsSpdHybMax = muDoubleScalarMin(par->iceSpdMgd[14850], par->emoSpdMgd[14850]); crsSpdHybMax_not_empty = true; /* minimale Drehzahl der Kurbelwelle */ /* minimum crankshaft rotational speed */ crsSpdHybMin = par->iceSpdMgd[0]; } /* % Initialisieren der allgemein benötigten Kenngrößen */ /* initializing the commonly required parameters */ /* mittlere kinetische Energie im Wegschritt berechnen */ /* define the average kinetic energy at path_idx step - is just previous KE */ /* mittlere Geschwindigkeit im Wegschritt berechnen */ /* define the average speed at path_idx step */ mtmp = 2.0 * engKinPre / par->vehMas; st.site = &g_emlrtRSI; if (mtmp < 0.0) { b_st.site = &h_emlrtRSI; eml_error(&b_st); } vehVel = muDoubleScalarSqrt(mtmp); /* % vorzeitiger Funktionsabbruch? */ /* premature function termination? */ /* Drehzahl der Kurbelwelle und Grenzen */ /* crankshaft speed and limits */ /* Aus den kinetischen Energien des Fahrzeugs wird über die Raddrehzahl */ /* und die übersetzung vom Getriebe die Kurbelwellendrehzahl berechnet. */ /* Zeilenrichtung entspricht den Gängen. (Zeilenvektor) */ /* from the vehicle's kinetic energy, the crankshaft speed is calculated */ /* by the speed and gearbox translation. Line direction corresponding to */ /* the aisles (row rector). EQUATION 1 */ b_engKinPre[0] = engKinPre; b_engKinPre[1] = engKinAct; for (i18 = 0; i18 < 2; i18++) { crsSpdVec[i18] = 2.0 * b_engKinPre[i18] / par->vehMas; } st.site = &f_emlrtRSI; for (k = 0; k < 2; k++) { if (crsSpdVec[k] < 0.0) { b_st.site = &h_emlrtRSI; eml_error(&b_st); } } for (k = 0; k < 2; k++) { crsSpdVec[k] = muDoubleScalarSqrt(crsSpdVec[k]); } i18 = par->geaRat->size[1]; k = (int32_T)gea; emlrtDynamicBoundsCheckR2012b(k, 1, i18, &mb_emlrtBCI, sp); mtmp = par->geaRat->data[(int32_T)gea - 1]; for (i18 = 0; i18 < 2; i18++) { crsSpdVec[i18] = mtmp * crsSpdVec[i18] / par->whlDrr; } /* Abbruch, wenn die Drehzahlen der Kurbelwelle zu hoch im hybridischen */ /* Modus */ /* stop if the crankshaft rotatoinal speed is too high in hybrid mode */ y = false; k = 0; exitg3 = false; while ((!exitg3) && (k < 2)) { if (!!(crsSpdVec[k] > crsSpdHybMax)) { y = true; exitg3 = true; } else { k++; } } if (y) { } else { /* Falls die Drehzahl des Verbrennungsmotors niedriger als die */ /* Leerlaufdrehzahl ist, */ /* stop if crankhaft rotional speed is lower than the idling speed */ y = false; k = 0; exitg2 = false; while ((!exitg2) && (k < 2)) { if (!!(crsSpdVec[k] < crsSpdHybMin)) { y = true; exitg2 = true; } else { k++; } } if (y) { } else { /* Prüfen, ob die Drehzahlgrenze des Elektromotors eingehalten wird */ /* check if electric motor speed limit is maintained */ /* mittlere Kurbelwellendrehzahlen berechnen */ /* calculate average crankshaft rotational speed */ /* - really just selecting the previous path_idx KE crankshaft speed */ crsSpd = crsSpdVec[0]; /* % Längsdynamik berechnen */ /* calculate longitundinal dynamics */ /* Es wird eine konstante Beschleunigung angenommen, die im Wegschritt */ /* wayStp das Fahrzeug von velPre auf velAct beschleunigt. */ /* constant acceleration assumed when transitioning from velPre to velAct */ /* for the selected wayStp path_idx step distance */ /* Berechnen der konstanten Beschleunigung */ /* calculate the constant acceleration */ /* Aus der mittleren kinetischen Energie im Intervall, der mittleren */ /* Steigung und dem Gang lässt sich über die Fahrwiderstandsgleichung */ /* die nötige Fahrwiderstandskraft berechnen, die aufgebracht werden */ /* muss, um diese zu realisieren. */ /* from the (avg) kinetic energy in the interval, the (avg) slope and */ /* transition can calculate the necessary traction force on the driving */ /* resistance equation (PART OF EQUATION 5) */ /* Steigungskraft aus der mittleren Steigung berechnen (Skalar) */ /* gradiant force from the calculated (average) gradient */ /* Rollreibungskraft berechnen (Skalar) */ /* calculated rolling friction force - not included in EQ 5??? */ /* Luftwiderstandskraft berechnen (2*c_a/m * E_kin) (Skalar) */ /* calculated air resistance force */ /* % Berechnung der minimalen kosten der Hamiltonfunktion */ /* Calculating the minimum cost of the Hamiltonian */ /* % Berechnen der Kraft am Rad für Antriebsstrangmodus */ /* calculate the force on the wheel for the drivetrain mode */ /* % dynamische Fahrzeugmasse bei Fahrzeugmotor an berechnen. Das */ /* % heißt es werden Trägheitsmoment von Verbrennungsmotor, */ /* % Elektromotor und Rädern mit einbezogen. */ /* calculate dynamic vehicle mass with the vehicle engine (with the moment */ /* of intertia of the ICE, electric motor, and wheels) */ /* vehMasDyn = (par.iceMoi_geaRat(gea) +... */ /* par.emoGeaMoi_geaRat(gea) + par.whlMoi)/par.whlDrr^2 ... */ /* + par.vehMas; */ /* Radkraft berechnen (Beschleunigungskraft + Steigungskraft + */ /* Rollwiderstandskraft + Luftwiderstandskraft) */ /* caluclating wheel forces (accerlation force + gradient force + rolling */ /* resistance + air resistance) EQUATION 5 */ /* % Getriebeübersetzung und -verlust */ /* gear ratio and loss */ /* Das Drehmoment des Rades ergibt sich über den Radhalbmesser aus */ /* der Fahrwiderstandskraft. */ /* the weel torque is obtained from the wheel radius of the rolling */ /* resistance force (torque = force * distance (in this case, radius) */ whlTrq = ((((engKinAct - engKinPre) / (par->vehMas * wayStp) * par->vehMas + par->vehMas * 9.81 * muDoubleScalarSin(slp)) + par->whlRolResCof * par->vehMas * 9.81 * muDoubleScalarCos(slp)) + 2.0 * par->drgCof / par->vehMas * engKinPre) * par->whlDrr; /* Berechnung des Kurbelwellenmoments */ /* Hier muss unterschieden werden, ob das Radmoment positiv oder */ /* negativ ist, da nur ein einfacher Wirkungsgrad für das Getriebe */ /* genutzt wird */ /* it's important to determine sign of crankshaft torque (positive or */ /* negative), since only a simple efficiency is used for the transmission */ /* PART OF EQ4 <- perhaps reversed? not too sure */ if (whlTrq < 0.0) { i18 = par->geaRat->size[1]; k = (int32_T)gea; emlrtDynamicBoundsCheckR2012b(k, 1, i18, &nb_emlrtBCI, sp); crsTrq = whlTrq / par->geaRat->data[(int32_T)gea - 1] * par->geaEfy; } else { i18 = par->geaRat->size[1]; k = (int32_T)gea; emlrtDynamicBoundsCheckR2012b(k, 1, i18, &ob_emlrtBCI, sp); crsTrq = whlTrq / par->geaRat->data[(int32_T)gea - 1] / par->geaEfy; } /* % Verbrennungsmotor */ /* internal combustion engine */ /* maximales Moment des Verbrennungsmotors berechnen */ /* calculate max torque of the engine (quadratic based on rotation speed) */ iceTrqMax = (par->iceTrqMaxCof[0] * (crsSpdVec[0] * crsSpdVec[0]) + par->iceTrqMaxCof[1] * crsSpdVec[0]) + par->iceTrqMaxCof[2]; /* minimales Moment des Verbrennungsmotors berechnen */ /* calculating mimimum ICE moment */ iceTrqMin = (par->iceTrqMinCof[0] * (crsSpdVec[0] * crsSpdVec[0]) + par->iceTrqMinCof[1] * crsSpdVec[0]) + par->iceTrqMinCof[2]; /* % Elektromotor */ /* electric motor */ /* maximales Moment, dass die E-Maschine liefern kann */ /* max torque that the electric motor can provide - from interpolation */ /* emoTrqMaxPos = ... */ /* lininterp1(par.emoSpdMgd(1,:)',par.emoTrqMax_emoSpd,crsSpd); */ for (i18 = 0; i18 < 100; i18++) { b_par[i18] = par->emoSpdMgd[150 * i18]; } emoTrqMaxPos = interp1q(b_par, par->emoTrqMax_emoSpd, crsSpdVec[0]); /* Die gültigen Kurbelwellenmomente müssen kleiner sein als das */ /* Gesamtmoment von E-Motor und Verbrennungsmotor */ /* The valid crankshaft moments must be less than the total moment of the */ /* electric motor and the ICE.Otherwise, leave the function */ if (crsTrq > iceTrqMax + emoTrqMaxPos) { } else { /* % %% Optimaler Momentensplit - Minimierung der Hamiltonfunktion */ /* optimum torque split - minimizing the Hamiltonian */ /* Die Vorgehensweise ist ähnlich wie bei der ECMS. Es wird ein Vektor der */ /* möglichen Batterieenergieänderungen aufgestellt. Aus diesen lässt sich */ /* eine Batterieklemmleistung berechnen. Aus der über das */ /* Kurbelwellenmoment, ein Elektromotormoment berechnet werden kann. */ /* Über das geforderte Kurbelwellenmoment, kann für jedes Moment des */ /* Elektromotors ein Moment des Verbrennungsmotors gefunden werden. Für */ /* jedes Momentenpaar kann die Hamiltonfunktion berechnet werden. */ /* Ausgegeben wird der minimale Wert der Hamiltonfunktion und die */ /* durch das dabei verwendete Elektromotormoment verursachte */ /* Batterieladungsänderung. */ /* The procedure is similar to ECMS. It's based on a vector of possible */ /* battery energy changes, from which a battery terminal power can be */ /* calculated. */ /* From the crankshaft torque, an electric motor torque can be */ /* calculated, and an engine torque can be found for every electric motor */ /* moment. */ /* For every moment-pair the Hamiltonian can be calculated. It */ /* outputs the minimum Hamilotnian value and the battery charge change */ /* caused by the electric motor torque used. */ /* % Elektromotor - Aufstellen des Batterienergievektors */ /* electric motor - positioning the battery energy vectors */ if (batEngStp > 0.0) { /* Skalar - änderung der minimalen Batterieenergieänderung */ /* Skalar - änderung der maximalen Batterieenergieänderung */ /* FUNCTION CALL */ /* Skalar - Wegschrittweite */ /* Skalar - mittlere Geschwindigkeit im Intervall */ /* Skalar - Nebenverbraucherlast */ /* Skalar - Batterieenergie */ /* struct - Fahrzeugparameter */ /* Skalar - crankshaft rotational speed */ /* Skalar - crankshaft torque */ /* Skalar - min ICE torque allowed */ /* Skalar - max ICE torque allowed */ /* Skalar - max EM torque possible */ st.site = &e_emlrtRSI; /* Skalar - änderung der minimalen Batterieenergieänderung */ /* Skalar - änderung der maximalen Batterieenergieänderung */ /* Skalar - Wegschrittweite */ /* Skalar - Geschwindigkeit im Intervall */ /* Skalar - Nebenverbraucherlast */ /* Skalar - Batterieenergie */ /* struct - Fahrzeugparameter */ /* Skalar - crankshaft rotational speed */ /* Skalar - crankshaft torque */ /* Skalar - min ICE torque allowed */ /* Skalar - max ICE torque */ /* Skalar - max EM torque possible */ /* BatEngDltClc Calculates the change in battery energy */ /* */ /* Erstellungsdatum der ersten Version 17.11.2015 - Stephan Uebel */ /* Berechnung der Verluste des Elektromotors bei voller rein elektrischer */ /* Fahrt (voller Lastpunktabsenkung) und bei voller Lastpunktanhebung */ /* Calculations of loss of electric motor at purely full electric */ /* Driving (full load point lowering) and at full load point raising */ /* */ /* Version vom 17.02.2016: Keine Einbeziehung von Rotationsmassen */ /* ^^ No inclusion of rotational masses */ /* */ /* Version vom 25.05.2016: Zero-Order-Hold (keine mittlere Geschwindigkeit) */ /* ^^ Zero-Order-Hold (no average velocities) */ /* % Initialisieren der Ausgabe der Funktion */ /* initializing the function output (delta battery_energy min and max) */ /* % Elektromotor */ /* minimales Moment, dass die E-Maschine liefern kann */ /* minimum moment that the EM can provide (max is an input to function) */ /* emoTrqMinPos = ... */ /* lininterp1(par.emoSpdMgd(1,:)',par.emoTrqMin_emoSpd,crsSpd); */ for (i18 = 0; i18 < 100; i18++) { b_par[i18] = par->emoSpdMgd[150 * i18]; } emoTrqMinPos = interp1q(b_par, par->emoTrqMin_emoSpd, crsSpdVec[0]); /* % Verbrennungsmotor berechnen */ /* Durch EM zu lieferndes Kurbelwellenmoment */ /* crankshaft torque to be delivered by the electric motor (min and max) */ emoTrqMax = crsTrq - iceTrqMin; emoTrqMin = crsTrq - iceTrqMax; /* % Elektromotor berechnen */ /* calculate the electric motor */ if (emoTrqMaxPos < emoTrqMax) { /* Moment des Elektromotors bei maximaler Entladung der Batterie */ /* EM torque at max battery discharge */ emoTrqMax = emoTrqMaxPos; } if (emoTrqMaxPos < emoTrqMin) { /* Moment des Elektromotors bei minimaler Entladung der Batterie */ /* EM torque at min battery discharge */ emoTrqMin = emoTrqMaxPos; } emoTrqMax = muDoubleScalarMax(emoTrqMinPos, emoTrqMax); emoTrqMin = muDoubleScalarMax(emoTrqMinPos, emoTrqMin); /* % Berechnung der änderung der Batterieladung */ /* calculating the change in battery charge */ /* Interpolation der benötigten Batterieklemmleistung für das */ /* EM-Moment. Stellen die nicht definiert sind, werden mit inf */ /* ausgegeben. Positive Werte entsprechen entladen der Batterie. */ /* interpolating the required battery terminal power for the EM torque. */ /* Assign undefined values to inf. Positive values coresspond with battery */ /* discharge. */ /* batPwrMax = lininterp2(par.emoSpdMgd(1,:),par.emoTrqMgd(:,1),... */ /* par.emoPwr_emoSpd_emoTrq',crsSpd,emoTrqMax) + batPwrAux; */ /* */ /* batPwrMin = lininterp2(par.emoSpdMgd(1,:),par.emoTrqMgd(:,1),... */ /* par.emoPwr_emoSpd_emoTrq',crsSpd,emoTrqMin) + batPwrAux; */ b_st.site = &i_emlrtRSI; batPwrMax = codegen_interp2(&b_st, par->emoSpdMgd, par->emoTrqMgd, par->emoPwr_emoSpd_emoTrq, crsSpdVec[0], emoTrqMax) + batPwrAux; b_st.site = &j_emlrtRSI; batPwrMin = codegen_interp2(&b_st, par->emoSpdMgd, par->emoTrqMgd, par->emoPwr_emoSpd_emoTrq, crsSpdVec[0], emoTrqMin) + batPwrAux; /* überprüfen, ob Batterieleistung möglich */ /* make sure that current battery max power is not above bat max bounds */ if (batPwrMax > par->batPwrMax) { batPwrMax = par->batPwrMax; } /* überprüfen, ob Batterieleistung möglich */ /* make sure that current battery min power is not below bat min bounds */ if (batPwrMin > par->batPwrMax) { batPwrMin = par->batPwrMax; } /* Es kann vorkommen, dass mehr Leistung gespeist werden soll, als */ /* möglich ist. */ /* double check that the max and min still remain within the other bounds */ if (batPwrMax < par->batPwrMin) { batPwrMax = par->batPwrMin; } if (batPwrMin < par->batPwrMin) { batPwrMin = par->batPwrMin; } /* Batteriespannung aus Kennkurve berechnen */ /* calculating battery voltage of characteristic curve - eq?-------------- */ batOcv = batEng * par->batOcvCof_batEng[0] + par->batOcvCof_batEng[1]; /* FUNCTION CALL - min delta bat.energy */ /* Skalar - Batterieklemmleistung */ /* Skalar - mittlere Geschwindigkeit im Intervall */ /* Skalar - Entladewiderstand */ /* Skalar - Ladewiderstand */ /* Skalar - battery open-circuit voltage */ batEngDltMin = batFrcClc_tmp(batPwrMax, vehVel, par->batRstDch, par->batRstChr, batOcv) * wayStp; /* <-multiply by delta_S */ /* FUNCTION CALL - max delta bat.energy */ /* Skalar - Batterieklemmleistung */ /* Skalar - mittlere Geschwindigkeit im Intervall */ /* Skalar - Entladewiderstand */ /* Skalar - Ladewiderstand */ /* Skalar - battery open-circuit voltage */ batEngDltMax = batFrcClc_tmp(batPwrMin, vehVel, par->batRstDch, par->batRstChr, batOcv) * wayStp; /* Es werden 2 Fälle unterschieden: */ /* there are 2 different cases */ if ((batEngDltMin > 0.0) && (batEngDltMax > 0.0)) { /* %% konventionelles Bremsen + Rekuperieren */ /* conventional brakes + recuperation */ /* */ /* set change in energy to discretized integer values w/ ceil and */ /* floor. This also helps for easy looping */ /* Konventionelles Bremsen wird ebenfalls untersucht. */ /* Hier liegt eventuell noch Beschleunigungspotential, da diese */ /* Zustandswechsel u.U. ausgeschlossen werden können. */ /* NOTE: u.U. = unter Ümständen = circumstances permitting */ /* convetional breaks also investigated. An accelerating potential */ /* is still possible, as these states can be excluded */ /* (circumstances permitting) <- ??? not sure what above means */ /* */ /* so if both min and max changes in battery energy are */ /* increasing, then set the delta min to zero */ batEngDltMinInx = 0.0; batEngDltMaxInx = muDoubleScalarFloor(batEngDltMax / batEngStp); } else { batEngDltMinInx = muDoubleScalarCeil(batEngDltMin / batEngStp); batEngDltMaxInx = muDoubleScalarFloor(batEngDltMax / batEngStp); } } else { batEngDltMinInx = 0.0; batEngDltMaxInx = 0.0; } /* you got a larger min chnage and a max change, you're out of bounds. Leave */ /* the function */ if (batEngDltMaxInx < batEngDltMinInx) { } else { /* % Schleife über alle Elektromotormomente */ /* now loop through all the electric-motor torques */ i18 = (int32_T)(batEngDltMaxInx + (1.0 - batEngDltMinInx)); emlrtForLoopVectorCheckR2012b(batEngDltMinInx, 1.0, batEngDltMaxInx, mxDOUBLE_CLASS, i18, &o_emlrtRTEI, sp); k = 0; while (k <= i18 - 1) { batEngDlt = (batEngDltMinInx + (real_T)k) * batEngStp; /* open circuit voltage over each iteration */ batOcv = (batEng + batEngDlt) * par->batOcvCof_batEng[0] + par->batOcvCof_batEng[1]; /* Skalar für die Batterieleistung in W */ /* Skalar Krafstoffkraft in N */ /* FUNCTION CALL */ /* Skalar für die Wegschrittweite in m, */ /* Skalar - vehicular velocity */ /* Nebenverbraucherlast */ /* Skalar - battery open circuit voltage */ /* Skalar - Batterieenergie�nderung, */ /* Skalar - crankshaft speed at given path_idx */ /* Skalar - crankshaft torque at given path_idx */ /* Skalar - min ICE torque allowed */ /* Skalar - max ICE torque */ /* struct der Fahrzeugparameter */ st.site = &d_emlrtRSI; /* Skalar für die Batterieleistung */ /* Skalar Kraftstoffkraft */ /* Skalar für die Wegschrittweite in m */ /* vehicular velocity */ /* Nebenverbraucherlast */ /* Skalar - battery open circuit voltage */ /* Skalar - Batterieenergieänderung */ /* Skalar - crankshaft speed at given path_idx */ /* Skalar - crankshaft torque at given path_idx */ /* Skalar - min ICE torque allowed */ /* Skalar - max ICE torque */ /* struct der Fahrzeugparameter */ /* */ /* FULENGCLC Calculating fuel consumption */ /* Erstellungsdatum der ersten Version 04.09.2015 - Stephan Uebel */ /* */ /* Diese Funktion berechnet den Kraftstoffverbrauch für einen gegebenen */ /* Wegschritt der kinetischen Energie, der Batterieenergie und des */ /* Antriebsstrangzustands über dem Weg. */ /* this function calculates fuel consumption for a given route step of */ /* KE, the battery energy, and drivetrain state of the current path_idx */ /* */ /* Version vom 17.02.2016 : Rotationsmassen vernachlässigt */ /* ^^ neglected rotatary masses */ /* */ /* Version vom 25.05.2016: Zero-Order-Hold (keine mittlere Geschwindigkeit) */ /* */ /* version from 1.06.2016 - removed crsTrq calulations - they are already */ /* done in parent function (clcPMP_olHyb_tmp) and do not change w/ each */ /* iteration, making the caluclation here unnecessary */ /* % Initialisieren der Ausgabe der Funktion */ /* initializing function output */ /* Skalar - electric battery power (W) */ fulFrc = rtInf; /* Skalar - fuel force intialization (N) */ /* % Batterie */ /* Batterieenergieänderung über dem Weg (Batteriekraft) */ /* Change in battery energy over the path_idx way (ie battery power) */ batFrc = batEngDlt / wayStp; /* Fallunterscheidung, ob Batterie geladen oder entladen wird */ /* Case analysis - check if battery is charging or discharging. Set */ /* resistance accordingly */ /* elektrische Leistung des Elektromotors */ /* electric power from electric motor - DERIVATION? dunno */ /* innere Batterieleistung / internal batt power */ /* dissipat. Leist. / dissipated */ if (batFrc < 0.0) { b_batFrc = par->batRstDch; } else { b_batFrc = par->batRstChr; } batPwr = (-batFrc * vehVel - batFrc * batFrc * (vehVel * vehVel) / (batOcv * batOcv) * b_batFrc) - batPwrAux; /* Nebenverbrauchlast / auxiliary power */ /* % Elektromotor */ /* Ermitteln des Kurbelwellenmoments durch EM aus Batterieleistung */ /* determine crankshaft torque cauesd by EM's battery power */ /* switching out codegen_interp2 for lininterp2-just might work! */ /* */ b_st.site = &k_emlrtRSI; emoTrq = codegen_interp2(&b_st, par->emoSpdMgd, par->emoPwrMgd, par->emoTrq_emoSpd_emoPwr, crsSpd, batPwr); /* emoTrq = lininterp2(par.emoSpdMgd(1,:), par.emoPwrMgd(:,1),... */ /* par.emoTrq_emoSpd_emoPwr',crsSpd,emoPwrEle); */ if (muDoubleScalarIsInf(emoTrq)) { } else { /* Grenzen des Elektromotors müssen hier nicht überprüft werden, da die */ /* Ladungsdeltas schon so gewählt wurden, dass das maximale Motormoment */ /* nicht überstiegen wird. */ /* Electric motor limits need not be checked here, since the charge deltas */ /* have been chosen so that the max torque is not exceeded. */ /* % Verbrennungsmotor */ /* Ermitteln des Kurbelwellenmoments durch den Verbrennungsmotor */ /* Determining the crankshaft moment from the ICE */ iceTrq = crsTrq - emoTrq; /* Wenn das Verbrennungsmotormoment kleiner als das minimale */ /* Moment ist, ist dieser in der Schubabschaltung. Das */ /* verbleibende Moment liefern die Bremsen */ /* If engine torque is less than the min torque, fuel is cut. The */ /* remaining torque is deliver the brakes. */ if (iceTrq < iceTrqMin) { fulPwr = 0.0; } else if (iceTrq > iceTrqMax) { fulPwr = rtInf; } else { /* replacing another coden_interp2 */ b_st.site = &l_emlrtRSI; fulPwr = codegen_interp2(&b_st, par->iceSpdMgd, par->iceTrqMgd, par->iceFulPwr_iceSpd_iceTrq, crsSpd, iceTrq); /* fulPwr = lininterp2(par.iceSpdMgd(1,:), par.iceTrqMgd(:,1), ... */ /* par.iceFulPwr_iceSpd_iceTrq', crsSpd, iceTrq); */ } /* Berechnen der Kraftstoffkraft */ /* calculate fuel force */ fulFrc = fulPwr / vehVel; /* Berechnen der Kraftstoffvolumenänderung */ /* caluclate change in fuel volume - energy, no? */ /* % Ende der Funktion */ } /* FUNCTION CALL */ /* Skalar - Batterieklemmleistung */ /* Skalar - mittlere Geschwindigkeit im Intervall */ /* Skalar - Entladewiderstand */ /* Skalar - Ladewiderstand */ /* Skalar - battery open circuit voltage */ batFrc = batFrcClc_tmp(batPwr, vehVel, par->batRstDch, par->batRstChr, batOcv); /* %% Hamiltonfunktion bestimmen */ /* determine the hamiltonian */ /* Eq (29b) */ crsSpdVec[0] = (fulFrc + psiBatEng * batFrc) + psiTim / vehVel; ixstart = 1; mtmp = crsSpdVec[0]; itmp = 1; if (muDoubleScalarIsNaN(crsSpdVec[0])) { ix = 2; exitg1 = false; while ((!exitg1) && (ix < 3)) { ixstart = 2; if (!muDoubleScalarIsNaN(*cosHamMin)) { mtmp = *cosHamMin; itmp = 2; exitg1 = true; } else { ix = 3; } } } if ((ixstart < 2) && (*cosHamMin < mtmp)) { mtmp = *cosHamMin; itmp = 2; } *cosHamMin = mtmp; /* Wenn der aktuelle Punkt besser ist, als der in cosHamMin */ /* gespeicherte Wert, werden die Ausgabegrößen neu beschrieben. */ /* if the current point is better than the stored cosHamMin value, */ /* then the output values are rewritten (selected prev. value is = 2) */ if (itmp == 1) { *batFrcOut = batFrc; *fulFrcOut = fulFrc; } k++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } } } } } /* end of function */ }
/* Function Definitions */ void b_sqrt(real_T *x) { *x = muDoubleScalarSqrt(*x); }
static void c_eml_qrsolve(const emlrtStack *sp, const emxArray_real_T *A, emxArray_real_T *B, emxArray_real_T *Y) { emxArray_real_T *b_A; emxArray_real_T *work; int32_T mn; int32_T i51; int32_T ix; emxArray_real_T *tau; emxArray_int32_T *jpvt; int32_T m; int32_T n; int32_T b_mn; emxArray_real_T *vn1; emxArray_real_T *vn2; int32_T k; boolean_T overflow; boolean_T b12; int32_T i; int32_T i_i; int32_T nmi; int32_T mmi; int32_T pvt; int32_T iy; boolean_T b13; real_T xnorm; int32_T i52; real_T atmp; real_T d16; boolean_T b14; boolean_T b_i; ptrdiff_t n_t; ptrdiff_t incx_t; double * xix0_t; boolean_T exitg1; const mxArray *y; static const int32_T iv78[2] = { 1, 8 }; const mxArray *m14; char_T cv76[8]; static const char_T cv77[8] = { '%', '%', '%', 'd', '.', '%', 'd', 'e' }; char_T cv78[14]; uint32_T unnamed_idx_0; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_st; emlrtStack f_st; emlrtStack g_st; emlrtStack h_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; d_st.prev = &c_st; d_st.tls = c_st.tls; e_st.prev = &d_st; e_st.tls = d_st.tls; f_st.prev = &e_st; f_st.tls = e_st.tls; g_st.prev = &f_st; g_st.tls = f_st.tls; h_st.prev = &g_st; h_st.tls = g_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); emxInit_real_T(sp, &b_A, 2, &m_emlrtRTEI, true); b_emxInit_real_T(sp, &work, 1, &rb_emlrtRTEI, true); mn = (int32_T)muDoubleScalarMin(A->size[0], A->size[1]); st.site = &mc_emlrtRSI; b_st.site = &nc_emlrtRSI; c_st.site = &oc_emlrtRSI; i51 = b_A->size[0] * b_A->size[1]; b_A->size[0] = A->size[0]; b_A->size[1] = A->size[1]; emxEnsureCapacity(&c_st, (emxArray__common *)b_A, i51, (int32_T)sizeof(real_T), &m_emlrtRTEI); ix = A->size[0] * A->size[1]; for (i51 = 0; i51 < ix; i51++) { b_A->data[i51] = A->data[i51]; } b_emxInit_real_T(&c_st, &tau, 1, &m_emlrtRTEI, true); b_emxInit_int32_T(&c_st, &jpvt, 2, &m_emlrtRTEI, true); m = b_A->size[0]; n = b_A->size[1]; b_mn = muIntScalarMin_sint32(b_A->size[0], b_A->size[1]); i51 = tau->size[0]; tau->size[0] = b_mn; emxEnsureCapacity(&c_st, (emxArray__common *)tau, i51, (int32_T)sizeof(real_T), &n_emlrtRTEI); d_st.site = &mf_emlrtRSI; e_st.site = &rb_emlrtRSI; f_st.site = &sb_emlrtRSI; g_st.site = &tb_emlrtRSI; eml_signed_integer_colon(&g_st, b_A->size[1], jpvt); if ((b_A->size[0] == 0) || (b_A->size[1] == 0)) { } else { ix = b_A->size[1]; i51 = work->size[0]; work->size[0] = ix; emxEnsureCapacity(&c_st, (emxArray__common *)work, i51, (int32_T)sizeof (real_T), &m_emlrtRTEI); for (i51 = 0; i51 < ix; i51++) { work->data[i51] = 0.0; } b_emxInit_real_T(&c_st, &vn1, 1, &pb_emlrtRTEI, true); b_emxInit_real_T(&c_st, &vn2, 1, &qb_emlrtRTEI, true); d_st.site = &tc_emlrtRSI; ix = b_A->size[1]; i51 = vn1->size[0]; vn1->size[0] = ix; emxEnsureCapacity(&c_st, (emxArray__common *)vn1, i51, (int32_T)sizeof (real_T), &pb_emlrtRTEI); i51 = vn2->size[0]; vn2->size[0] = ix; emxEnsureCapacity(&c_st, (emxArray__common *)vn2, i51, (int32_T)sizeof (real_T), &qb_emlrtRTEI); k = 1; d_st.site = &nf_emlrtRSI; overflow = (b_A->size[1] > 2147483646); if (overflow) { e_st.site = &db_emlrtRSI; check_forloop_overflow_error(&e_st); } for (ix = 0; ix + 1 <= b_A->size[1]; ix++) { d_st.site = &sc_emlrtRSI; vn1->data[ix] = b_eml_xnrm2(&d_st, b_A->size[0], b_A, k); vn2->data[ix] = vn1->data[ix]; k += b_A->size[0]; } d_st.site = &rc_emlrtRSI; if (1 > b_mn) { b12 = false; } else { b12 = (b_mn > 2147483646); } if (b12) { e_st.site = &db_emlrtRSI; check_forloop_overflow_error(&e_st); } for (i = 1; i <= b_mn; i++) { i_i = (i + (i - 1) * m) - 1; nmi = n - i; mmi = m - i; d_st.site = &of_emlrtRSI; ix = eml_ixamax(&d_st, 1 + nmi, vn1, i); pvt = (i + ix) - 2; if (pvt + 1 != i) { d_st.site = &pf_emlrtRSI; e_st.site = &bc_emlrtRSI; f_st.site = &cc_emlrtRSI; ix = 1 + m * pvt; iy = 1 + m * (i - 1); g_st.site = &dc_emlrtRSI; if (1 > m) { b13 = false; } else { b13 = (m > 2147483646); } if (b13) { h_st.site = &db_emlrtRSI; check_forloop_overflow_error(&h_st); } for (k = 1; k <= m; k++) { i51 = b_A->size[0] * b_A->size[1]; xnorm = b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51, &le_emlrtBCI, &f_st) - 1]; i51 = b_A->size[0] * b_A->size[1]; i52 = b_A->size[0] * b_A->size[1]; b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51, &le_emlrtBCI, &f_st) - 1] = b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i52, &le_emlrtBCI, &f_st) - 1]; i51 = b_A->size[0] * b_A->size[1]; b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i51, &le_emlrtBCI, &f_st) - 1] = xnorm; ix++; iy++; } ix = jpvt->data[pvt]; jpvt->data[pvt] = jpvt->data[i - 1]; jpvt->data[i - 1] = ix; vn1->data[pvt] = vn1->data[i - 1]; vn2->data[pvt] = vn2->data[i - 1]; } if (i < m) { d_st.site = &qc_emlrtRSI; atmp = b_A->data[i_i]; d16 = 0.0; if (1 + mmi <= 0) { } else { e_st.site = &wc_emlrtRSI; xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2); if (xnorm != 0.0) { xnorm = muDoubleScalarHypot(b_A->data[i_i], xnorm); if (b_A->data[i_i] >= 0.0) { xnorm = -xnorm; } if (muDoubleScalarAbs(xnorm) < 1.0020841800044864E-292) { ix = 0; do { ix++; e_st.site = &xc_emlrtRSI; b_eml_xscal(&e_st, mmi, 9.9792015476736E+291, b_A, i_i + 2); xnorm *= 9.9792015476736E+291; atmp *= 9.9792015476736E+291; } while (!(muDoubleScalarAbs(xnorm) >= 1.0020841800044864E-292)); e_st.site = &yc_emlrtRSI; xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2); xnorm = muDoubleScalarHypot(atmp, xnorm); if (atmp >= 0.0) { xnorm = -xnorm; } d16 = (xnorm - atmp) / xnorm; e_st.site = &ad_emlrtRSI; b_eml_xscal(&e_st, mmi, 1.0 / (atmp - xnorm), b_A, i_i + 2); e_st.site = &bd_emlrtRSI; if (1 > ix) { b14 = false; } else { b14 = (ix > 2147483646); } if (b14) { f_st.site = &db_emlrtRSI; check_forloop_overflow_error(&f_st); } for (k = 1; k <= ix; k++) { xnorm *= 1.0020841800044864E-292; } atmp = xnorm; } else { d16 = (xnorm - b_A->data[i_i]) / xnorm; atmp = 1.0 / (b_A->data[i_i] - xnorm); e_st.site = &cd_emlrtRSI; b_eml_xscal(&e_st, mmi, atmp, b_A, i_i + 2); atmp = xnorm; } } } tau->data[i - 1] = d16; } else { atmp = b_A->data[i_i]; d_st.site = &pc_emlrtRSI; tau->data[i - 1] = eml_matlab_zlarfg(); } b_A->data[i_i] = atmp; if (i < n) { atmp = b_A->data[i_i]; b_A->data[i_i] = 1.0; d_st.site = &qf_emlrtRSI; eml_matlab_zlarf(&d_st, mmi + 1, nmi, i_i + 1, tau->data[i - 1], b_A, i + i * m, m, work); b_A->data[i_i] = atmp; } d_st.site = &rf_emlrtRSI; if (i + 1 > n) { b_i = false; } else { b_i = (n > 2147483646); } if (b_i) { e_st.site = &db_emlrtRSI; check_forloop_overflow_error(&e_st); } for (ix = i; ix + 1 <= n; ix++) { if (vn1->data[ix] != 0.0) { xnorm = muDoubleScalarAbs(b_A->data[(i + b_A->size[0] * ix) - 1]) / vn1->data[ix]; xnorm = 1.0 - xnorm * xnorm; if (xnorm < 0.0) { xnorm = 0.0; } atmp = vn1->data[ix] / vn2->data[ix]; atmp = xnorm * (atmp * atmp); if (atmp <= 1.4901161193847656E-8) { if (i < m) { d_st.site = &sf_emlrtRSI; e_st.site = &uc_emlrtRSI; if (mmi < 1) { xnorm = 0.0; } else { f_st.site = &vc_emlrtRSI; g_st.site = &vc_emlrtRSI; n_t = (ptrdiff_t)(mmi); g_st.site = &vc_emlrtRSI; incx_t = (ptrdiff_t)(1); i51 = b_A->size[0] * b_A->size[1]; i52 = (i + m * ix) + 1; xix0_t = (double *)(&b_A->data[emlrtDynamicBoundsCheckFastR2012b (i52, 1, i51, &vb_emlrtBCI, &f_st) - 1]); xnorm = dnrm2(&n_t, xix0_t, &incx_t); } vn1->data[ix] = xnorm; vn2->data[ix] = vn1->data[ix]; } else { vn1->data[ix] = 0.0; vn2->data[ix] = 0.0; } } else { d_st.site = &tf_emlrtRSI; vn1->data[ix] *= muDoubleScalarSqrt(xnorm); } } } } emxFree_real_T(&vn2); emxFree_real_T(&vn1); } atmp = 0.0; if (mn > 0) { xnorm = muDoubleScalarMax(A->size[0], A->size[1]) * muDoubleScalarAbs (b_A->data[0]) * 2.2204460492503131E-16; k = 0; exitg1 = false; while ((!exitg1) && (k <= mn - 1)) { if (muDoubleScalarAbs(b_A->data[k + b_A->size[0] * k]) <= xnorm) { st.site = &lc_emlrtRSI; y = NULL; m14 = emlrtCreateCharArray(2, iv78); for (i = 0; i < 8; i++) { cv76[i] = cv77[i]; } emlrtInitCharArrayR2013a(&st, 8, m14, cv76); emlrtAssign(&y, m14); b_st.site = &tg_emlrtRSI; emlrt_marshallIn(&b_st, c_sprintf(&b_st, b_sprintf(&b_st, y, emlrt_marshallOut(14.0), emlrt_marshallOut(6.0), &o_emlrtMCI), emlrt_marshallOut(xnorm), &p_emlrtMCI), "sprintf", cv78); st.site = &kc_emlrtRSI; b_eml_warning(&st, atmp, cv78); exitg1 = true; } else { atmp++; k++; } } } unnamed_idx_0 = (uint32_T)A->size[1]; i51 = Y->size[0]; Y->size[0] = (int32_T)unnamed_idx_0; emxEnsureCapacity(sp, (emxArray__common *)Y, i51, (int32_T)sizeof(real_T), &m_emlrtRTEI); ix = (int32_T)unnamed_idx_0; for (i51 = 0; i51 < ix; i51++) { Y->data[i51] = 0.0; } for (ix = 0; ix < mn; ix++) { if (tau->data[ix] != 0.0) { xnorm = B->data[ix]; i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0)); emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0], mxDOUBLE_CLASS, i51, &ac_emlrtRTEI, sp); for (i = 0; i < i51; i++) { unnamed_idx_0 = ((uint32_T)ix + i) + 2U; xnorm += b_A->data[((int32_T)unnamed_idx_0 + b_A->size[0] * ix) - 1] * B->data[(int32_T)unnamed_idx_0 - 1]; } xnorm *= tau->data[ix]; if (xnorm != 0.0) { B->data[ix] -= xnorm; i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0)); emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0], mxDOUBLE_CLASS, i51, &yb_emlrtRTEI, sp); for (i = 0; i < i51; i++) { unnamed_idx_0 = ((uint32_T)ix + i) + 2U; B->data[(int32_T)unnamed_idx_0 - 1] -= b_A->data[((int32_T) unnamed_idx_0 + b_A->size[0] * ix) - 1] * xnorm; } } } } emxFree_real_T(&tau); emlrtForLoopVectorCheckR2012b(1.0, 1.0, atmp, mxDOUBLE_CLASS, (int32_T)atmp, &xb_emlrtRTEI, sp); for (i = 0; i < (int32_T)atmp; i++) { Y->data[jpvt->data[i] - 1] = B->data[i]; } emlrtForLoopVectorCheckR2012b(atmp, -1.0, 1.0, mxDOUBLE_CLASS, (int32_T)-(1.0 + (-1.0 - atmp)), &wb_emlrtRTEI, sp); for (ix = 0; ix < (int32_T)-(1.0 + (-1.0 - atmp)); ix++) { xnorm = atmp + -(real_T)ix; Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] = eml_div(Y->data[jpvt->data [(int32_T)xnorm - 1] - 1], b_A->data[((int32_T)xnorm + b_A->size[0] * ((int32_T)xnorm - 1)) - 1]); for (i = 0; i < (int32_T)(xnorm - 1.0); i++) { Y->data[jpvt->data[i] - 1] -= Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] * b_A->data[i + b_A->size[0] * ((int32_T)xnorm - 1)]; } } emxFree_int32_T(&jpvt); emxFree_real_T(&work); emxFree_real_T(&b_A); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
/* Function Definitions */ void rsf2csf(const emxArray_real_T *Ur, const emxArray_real_T *Tr, emxArray_creal_T *U, emxArray_creal_T *T) { int32_T y; int32_T loop_ub; int16_T varargin_1[2]; int32_T mtmp; int32_T m; real_T c; real_T b; real_T temp; real_T p; real_T bcmax; real_T scale; real_T bb; real_T b_p; real_T cs; int32_T b_scale; real_T b_c; real_T mu1_re; emlrtPushRtStackR2012b(&bh_emlrtRSI, emlrtRootTLSGlobal); y = T->size[0] * T->size[1]; T->size[0] = Tr->size[0]; T->size[1] = Tr->size[1]; emxEnsureCapacity((emxArray__common *)T, y, (int32_T)sizeof(creal_T), &v_emlrtRTEI); loop_ub = Tr->size[0] * Tr->size[1]; for (y = 0; y < loop_ub; y++) { T->data[y].re = Tr->data[y]; T->data[y].im = 0.0; } y = U->size[0] * U->size[1]; U->size[0] = Ur->size[0]; U->size[1] = Ur->size[1]; emxEnsureCapacity((emxArray__common *)U, y, (int32_T)sizeof(creal_T), &v_emlrtRTEI); loop_ub = Ur->size[0] * Ur->size[1]; for (y = 0; y < loop_ub; y++) { U->data[y].re = Ur->data[y]; U->data[y].im = 0.0; } for (y = 0; y < 2; y++) { varargin_1[y] = (int16_T)Tr->size[y]; } mtmp = varargin_1[0]; if (varargin_1[1] < varargin_1[0]) { mtmp = varargin_1[1]; } for (y = 0; y < 2; y++) { varargin_1[y] = (int16_T)Ur->size[y]; } loop_ub = varargin_1[0]; if (varargin_1[1] < varargin_1[0]) { loop_ub = varargin_1[1]; } mtmp = (int32_T)muDoubleScalarMin(mtmp, loop_ub); if (mtmp == 0) { } else { for (m = mtmp - 1; m + 1 >= 2; m--) { if (Tr->data[m + Tr->size[0] * (m - 1)] != 0.0) { emlrtPushRtStackR2012b(&ch_emlrtRSI, emlrtRootTLSGlobal); c = Tr->data[m + Tr->size[0] * (m - 1)]; b = Tr->data[(m + Tr->size[0] * m) - 1]; temp = Tr->data[(m + Tr->size[0] * (m - 1)) - 1]; if (Tr->data[m + Tr->size[0] * (m - 1)] == 0.0) { } else if (Tr->data[(m + Tr->size[0] * m) - 1] == 0.0) { temp = Tr->data[m + Tr->size[0] * m]; b = -Tr->data[m + Tr->size[0] * (m - 1)]; c = 0.0; } else if ((Tr->data[(m + Tr->size[0] * (m - 1)) - 1] - Tr->data[m + Tr->size[0] * m] == 0.0) && ((Tr->data[(m + Tr->size[0] * m) - 1] < 0.0) != (Tr->data[m + Tr->size[0] * (m - 1)] < 0.0))) { } else { temp = Tr->data[(m + Tr->size[0] * (m - 1)) - 1] - Tr->data[m + Tr->size[0] * m]; p = 0.5 * temp; bcmax = muDoubleScalarMax(muDoubleScalarAbs(Tr->data[(m + Tr->size[0] * m) - 1]), muDoubleScalarAbs(Tr->data[m + Tr->size[0] * (m - 1)])); if (!(Tr->data[(m + Tr->size[0] * m) - 1] < 0.0)) { loop_ub = 1; } else { loop_ub = -1; } if (!(Tr->data[m + Tr->size[0] * (m - 1)] < 0.0)) { y = 1; } else { y = -1; } scale = muDoubleScalarMax(muDoubleScalarAbs(p), bcmax); bcmax = p / scale * p + bcmax / scale * (muDoubleScalarMin (muDoubleScalarAbs(Tr->data[(m + Tr->size[0] * m) - 1]), muDoubleScalarAbs(Tr->data[m + Tr->size[0] * (m - 1)])) * (real_T) loop_ub * (real_T)y); if (bcmax >= 8.8817841970012523E-16) { emlrtPushRtStackR2012b(&gg_emlrtRSI, emlrtRootTLSGlobal); bb = muDoubleScalarSqrt(scale) * muDoubleScalarSqrt(bcmax); emlrtPopRtStackR2012b(&gg_emlrtRSI, emlrtRootTLSGlobal); if (!(p < 0.0)) { b_p = bb; } else { b_p = -bb; } temp = Tr->data[m + Tr->size[0] * m] + (p + b_p); b = Tr->data[(m + Tr->size[0] * m) - 1] - Tr->data[m + Tr->size[0] * (m - 1)]; c = 0.0; } else { scale = Tr->data[(m + Tr->size[0] * m) - 1] + Tr->data[m + Tr->size [0] * (m - 1)]; bcmax = muDoubleScalarHypot(scale, temp); emlrtPushRtStackR2012b(&hg_emlrtRSI, emlrtRootTLSGlobal); bb = 0.5 * (1.0 + muDoubleScalarAbs(scale) / bcmax); if (bb < 0.0) { emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); eml_error(); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); } cs = muDoubleScalarSqrt(bb); emlrtPopRtStackR2012b(&hg_emlrtRSI, emlrtRootTLSGlobal); if (!(scale < 0.0)) { b_scale = 1; } else { b_scale = -1; } bcmax = -(p / (bcmax * cs)) * (real_T)b_scale; scale = Tr->data[(m + Tr->size[0] * (m - 1)) - 1] * cs + Tr->data[(m + Tr->size[0] * m) - 1] * bcmax; bb = -Tr->data[(m + Tr->size[0] * (m - 1)) - 1] * bcmax + Tr->data [(m + Tr->size[0] * m) - 1] * cs; p = Tr->data[m + Tr->size[0] * (m - 1)] * cs + Tr->data[m + Tr-> size[0] * m] * bcmax; temp = -Tr->data[m + Tr->size[0] * (m - 1)] * bcmax + Tr->data[m + Tr->size[0] * m] * cs; b = bb * cs + temp * bcmax; c = -scale * bcmax + p * cs; temp = 0.5 * ((scale * cs + p * bcmax) + (-bb * bcmax + temp * cs)); if (c != 0.0) { if (b != 0.0) { if ((b < 0.0) == (c < 0.0)) { emlrtPushRtStackR2012b(&ig_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&ig_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jg_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&jg_emlrtRSI, emlrtRootTLSGlobal); bb = muDoubleScalarSqrt(muDoubleScalarAbs(b)) * muDoubleScalarSqrt(muDoubleScalarAbs(c)); emlrtPushRtStackR2012b(&kg_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&kg_emlrtRSI, emlrtRootTLSGlobal); if (!(c < 0.0)) { b_c = bb; } else { b_c = -bb; } temp += b_c; b -= c; c = 0.0; } } else { b = -c; c = 0.0; } } } } if (c == 0.0) { bcmax = 0.0; } else { emlrtPushRtStackR2012b(&lg_emlrtRSI, emlrtRootTLSGlobal); bcmax = muDoubleScalarSqrt(muDoubleScalarAbs(b)) * muDoubleScalarSqrt (muDoubleScalarAbs(c)); emlrtPopRtStackR2012b(&lg_emlrtRSI, emlrtRootTLSGlobal); } emlrtPopRtStackR2012b(&ch_emlrtRSI, emlrtRootTLSGlobal); mu1_re = temp - Tr->data[m + Tr->size[0] * m]; scale = muDoubleScalarHypot(muDoubleScalarHypot(mu1_re, bcmax), Tr-> data[m + Tr->size[0] * (m - 1)]); if (bcmax == 0.0) { mu1_re /= scale; cs = 0.0; } else if (mu1_re == 0.0) { mu1_re = 0.0; cs = bcmax / scale; } else { mu1_re /= scale; cs = bcmax / scale; } c = Tr->data[m + Tr->size[0] * (m - 1)] / scale; emlrtPushRtStackR2012b(&dh_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&dh_emlrtRSI, emlrtRootTLSGlobal); for (loop_ub = m - 1; loop_ub + 1 <= mtmp; loop_ub++) { b = T->data[(m + T->size[0] * loop_ub) - 1].re; temp = T->data[(m + T->size[0] * loop_ub) - 1].im; bb = T->data[(m + T->size[0] * loop_ub) - 1].re; p = T->data[(m + T->size[0] * loop_ub) - 1].im; bcmax = T->data[(m + T->size[0] * loop_ub) - 1].im; scale = T->data[(m + T->size[0] * loop_ub) - 1].re; T->data[(m + T->size[0] * loop_ub) - 1].re = (mu1_re * bb + cs * p) + c * T->data[m + T->size[0] * loop_ub].re; T->data[(m + T->size[0] * loop_ub) - 1].im = (mu1_re * bcmax - cs * scale) + c * T->data[m + T->size[0] * loop_ub].im; bcmax = mu1_re * T->data[m + T->size[0] * loop_ub].re - cs * T->data[m + T->size[0] * loop_ub].im; scale = mu1_re * T->data[m + T->size[0] * loop_ub].im + cs * T->data[m + T->size[0] * loop_ub].re; T->data[m + T->size[0] * loop_ub].re = bcmax - c * b; T->data[m + T->size[0] * loop_ub].im = scale - c * temp; } emlrtPushRtStackR2012b(&eh_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&eh_emlrtRSI, emlrtRootTLSGlobal); for (loop_ub = 0; loop_ub + 1 <= m + 1; loop_ub++) { b = T->data[loop_ub + T->size[0] * (m - 1)].re; temp = T->data[loop_ub + T->size[0] * (m - 1)].im; bcmax = mu1_re * T->data[loop_ub + T->size[0] * (m - 1)].re - cs * T->data[loop_ub + T->size[0] * (m - 1)].im; scale = mu1_re * T->data[loop_ub + T->size[0] * (m - 1)].im + cs * T->data[loop_ub + T->size[0] * (m - 1)].re; bb = T->data[loop_ub + T->size[0] * m].re; p = T->data[loop_ub + T->size[0] * m].im; T->data[loop_ub + T->size[0] * (m - 1)].re = bcmax + c * bb; T->data[loop_ub + T->size[0] * (m - 1)].im = scale + c * p; bb = T->data[loop_ub + T->size[0] * m].re; p = T->data[loop_ub + T->size[0] * m].im; bcmax = T->data[loop_ub + T->size[0] * m].im; scale = T->data[loop_ub + T->size[0] * m].re; T->data[loop_ub + T->size[0] * m].re = (mu1_re * bb + cs * p) - c * b; T->data[loop_ub + T->size[0] * m].im = (mu1_re * bcmax - cs * scale) - c * temp; } emlrtPushRtStackR2012b(&fh_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&fh_emlrtRSI, emlrtRootTLSGlobal); for (loop_ub = 0; loop_ub + 1 <= mtmp; loop_ub++) { b = U->data[loop_ub + U->size[0] * (m - 1)].re; temp = U->data[loop_ub + U->size[0] * (m - 1)].im; bcmax = mu1_re * U->data[loop_ub + U->size[0] * (m - 1)].re - cs * U->data[loop_ub + U->size[0] * (m - 1)].im; scale = mu1_re * U->data[loop_ub + U->size[0] * (m - 1)].im + cs * U->data[loop_ub + U->size[0] * (m - 1)].re; bb = U->data[loop_ub + U->size[0] * m].re; p = U->data[loop_ub + U->size[0] * m].im; U->data[loop_ub + U->size[0] * (m - 1)].re = bcmax + c * bb; U->data[loop_ub + U->size[0] * (m - 1)].im = scale + c * p; bb = U->data[loop_ub + U->size[0] * m].re; p = U->data[loop_ub + U->size[0] * m].im; bcmax = U->data[loop_ub + U->size[0] * m].im; scale = U->data[loop_ub + U->size[0] * m].re; U->data[loop_ub + U->size[0] * m].re = (mu1_re * bb + cs * p) - c * b; U->data[loop_ub + U->size[0] * m].im = (mu1_re * bcmax - cs * scale) - c * temp; } T->data[m + T->size[0] * (m - 1)].re = 0.0; T->data[m + T->size[0] * (m - 1)].im = 0.0; } } } emlrtPopRtStackR2012b(&bh_emlrtRSI, emlrtRootTLSGlobal); }
/* Function Definitions */ real_T batFrcClc_tmp(real_T batPwr, real_T vel, real_T batRstDch, real_T batRstChr, real_T batOcv) { real_T batFrc; real_T batRst; real_T batFrcCpl_re; real_T yr; real_T yi; real_T ar; real_T ai; real_T br; real_T batFrcCpl_im; /* Skalar - Batteriekraft (E') */ /* Skalar - Batterieklemmleistung */ /* Skalar - mittlere Geschwindigkeit im Intervall */ /* Skalar - Entladewiderstand */ /* Skalar - Ladewiderstand */ /* Skalar - battery open-circuit voltage */ /* BATFRCCLC Calculating losses in battery */ /* Batteriekraft (E') aus Verlusten in der Batterie berechnen */ /* Calucluate battery power losses (E') */ /* */ /* Version vom 25.05.2016: Zero-Order-Hold (keine mittlere Geschwindigkeit) */ /* Zero-Order-Hold (average velocity is NOT used) */ /* % Initialisieren der Ausgabe der Funktion */ /* initializing the function output */ batFrc = rtInf; /* % Berechnung der Verluste in der Batterie */ /* calculating battery losses */ /* Berechnung der Batterieenergienderung im Wegschritt in externer Funktion */ /* Fallunterscheidung, ob Batterie geladen oder entladen wird */ /* */ /* calculate the change in battery energy along path_idx in exterior func, */ /* distinguished whether battery is charging or discharging. */ /* Assining battery resistance value */ if (batPwr > 0.0) { batRst = batRstDch; } else { batRst = batRstChr; } /* Batterieenergieänderung über dem Weg berechnen. Herleitung der Formel */ /* kann zum Beispiel dem Paper mit Chalmers entnommen werden */ /* calculate battery power charge for path_idx. Formula derivation can be */ /* found from other papers (for example, Chalmers paper) */ batFrcCpl_re = 1.0 - 4.0 * batRst / (batOcv * batOcv) * batPwr; if (batFrcCpl_re < 0.0) { yr = 0.0; yi = muDoubleScalarSqrt(muDoubleScalarAbs(batFrcCpl_re)); } else { yr = muDoubleScalarSqrt(batFrcCpl_re); yi = 0.0; } ar = batOcv * batOcv * (yr - 1.0); ai = batOcv * batOcv * yi; br = 2.0 * batRst * vel; if (ai == 0.0) { batFrcCpl_re = ar / br; batFrcCpl_im = 0.0; } else if (ar == 0.0) { batFrcCpl_re = 0.0; batFrcCpl_im = ai / br; } else { batFrcCpl_re = ar / br; batFrcCpl_im = ai / br; } /* Sollte die physikalisch mögliche Batterieleistung überschritten werden, */ /* wird der Term unter der Wurzel negativ. In diesem Fall wird die Ausgabe */ /* ungültig geschrieben. */ /* check to make sure that the battery capacity is not exceeded (when the */ /* root becomes negative, the output is no longer valid) (Quadrants 3, 4) */ if (batFrcCpl_im != 0.0) { } else { batFrc = batFrcCpl_re; } return batFrc; }
static void sf_c3_car_model(SFc3_car_modelInstanceStruct *chartInstance) { int32_T c3_i3; int32_T c3_i4; int32_T c3_i5; int32_T c3_previousEvent; int32_T c3_i6; real_T c3_hoistedGlobal[4]; int32_T c3_i7; real_T c3_b_hoistedGlobal[3]; int32_T c3_i8; real_T c3_X[4]; int32_T c3_i9; real_T c3_u[3]; uint32_T c3_debug_family_var_map[22]; real_T c3_l_F; real_T c3_l_R; real_T c3_Vx; real_T c3_Vy; real_T c3_r; real_T c3_psi; real_T c3_f_Fx; real_T c3_f_Rx; real_T c3_delta; real_T c3_beta; real_T c3_V; real_T c3_s_Fy_num; real_T c3_s_Fy_denum; real_T c3_s_Fy; real_T c3_s_Ry_num; real_T c3_s_Ry_denum; real_T c3_s_Ry; real_T c3_nargin = 2.0; real_T c3_nargout = 1.0; real_T c3_s[2]; real_T c3_A; real_T c3_B; real_T c3_x; real_T c3_y; real_T c3_b_x; real_T c3_b_y; real_T c3_c_x; real_T c3_c_y; real_T c3_d_y; real_T c3_d_x; real_T c3_e_x; real_T c3_f_x; real_T c3_g_x; real_T c3_h_x; real_T c3_i_x; real_T c3_j_x; real_T c3_a; real_T c3_b; real_T c3_e_y; real_T c3_b_a; real_T c3_f_y; real_T c3_k_x; real_T c3_l_x; real_T c3_m_x; real_T c3_c_a; real_T c3_b_b; real_T c3_g_y; real_T c3_n_x; real_T c3_o_x; real_T c3_p_x; real_T c3_d_a; real_T c3_c_b; real_T c3_h_y; real_T c3_e_a; real_T c3_i_y; real_T c3_q_x; real_T c3_r_x; real_T c3_s_x; real_T c3_f_a; real_T c3_d_b; real_T c3_j_y; real_T c3_b_A; real_T c3_b_B; real_T c3_t_x; real_T c3_k_y; real_T c3_u_x; real_T c3_l_y; real_T c3_v_x; real_T c3_m_y; real_T c3_w_x; real_T c3_x_x; real_T c3_y_x; real_T c3_g_a; real_T c3_e_b; real_T c3_n_y; real_T c3_h_a; real_T c3_o_y; real_T c3_ab_x; real_T c3_bb_x; real_T c3_cb_x; real_T c3_i_a; real_T c3_f_b; real_T c3_c_A; real_T c3_c_B; real_T c3_db_x; real_T c3_p_y; real_T c3_eb_x; real_T c3_q_y; real_T c3_fb_x; real_T c3_r_y; int32_T c3_i10; real_T (*c3_b_s)[2]; real_T (*c3_b_u)[3]; real_T (*c3_b_X)[4]; c3_b_u = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 1); c3_b_s = (real_T (*)[2])ssGetOutputPortSignal(chartInstance->S, 1); c3_b_X = (real_T (*)[4])ssGetInputPortSignal(chartInstance->S, 0); _sfTime_ = (real_T)ssGetT(chartInstance->S); _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG,2); for (c3_i3 = 0; c3_i3 < 4; c3_i3 = c3_i3 + 1) { _SFD_DATA_RANGE_CHECK((*c3_b_X)[c3_i3], 0U); } for (c3_i4 = 0; c3_i4 < 2; c3_i4 = c3_i4 + 1) { _SFD_DATA_RANGE_CHECK((*c3_b_s)[c3_i4], 1U); } for (c3_i5 = 0; c3_i5 < 3; c3_i5 = c3_i5 + 1) { _SFD_DATA_RANGE_CHECK((*c3_b_u)[c3_i5], 2U); } c3_previousEvent = _sfEvent_; _sfEvent_ = CALL_EVENT; _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,2); for (c3_i6 = 0; c3_i6 < 4; c3_i6 = c3_i6 + 1) { c3_hoistedGlobal[c3_i6] = (*c3_b_X)[c3_i6]; } for (c3_i7 = 0; c3_i7 < 3; c3_i7 = c3_i7 + 1) { c3_b_hoistedGlobal[c3_i7] = (*c3_b_u)[c3_i7]; } for (c3_i8 = 0; c3_i8 < 4; c3_i8 = c3_i8 + 1) { c3_X[c3_i8] = c3_hoistedGlobal[c3_i8]; } for (c3_i9 = 0; c3_i9 < 3; c3_i9 = c3_i9 + 1) { c3_u[c3_i9] = c3_b_hoistedGlobal[c3_i9]; } sf_debug_symbol_scope_push_eml(0U, 22U, 22U, c3_debug_family_names, c3_debug_family_var_map); sf_debug_symbol_scope_add_eml(&c3_l_F, c3_d_sf_marshall, 0U); sf_debug_symbol_scope_add_eml(&c3_l_R, c3_d_sf_marshall, 1U); sf_debug_symbol_scope_add_eml(&c3_Vx, c3_d_sf_marshall, 2U); sf_debug_symbol_scope_add_eml(&c3_Vy, c3_d_sf_marshall, 3U); sf_debug_symbol_scope_add_eml(&c3_r, c3_d_sf_marshall, 4U); sf_debug_symbol_scope_add_eml(&c3_psi, c3_d_sf_marshall, 5U); sf_debug_symbol_scope_add_eml(&c3_f_Fx, c3_d_sf_marshall, 6U); sf_debug_symbol_scope_add_eml(&c3_f_Rx, c3_d_sf_marshall, 7U); sf_debug_symbol_scope_add_eml(&c3_delta, c3_d_sf_marshall, 8U); sf_debug_symbol_scope_add_eml(&c3_beta, c3_d_sf_marshall, 9U); sf_debug_symbol_scope_add_eml(&c3_V, c3_d_sf_marshall, 10U); sf_debug_symbol_scope_add_eml(&c3_s_Fy_num, c3_d_sf_marshall, 11U); sf_debug_symbol_scope_add_eml(&c3_s_Fy_denum, c3_d_sf_marshall, 12U); sf_debug_symbol_scope_add_eml(&c3_s_Fy, c3_d_sf_marshall, 13U); sf_debug_symbol_scope_add_eml(&c3_s_Ry_num, c3_d_sf_marshall, 14U); sf_debug_symbol_scope_add_eml(&c3_s_Ry_denum, c3_d_sf_marshall, 15U); sf_debug_symbol_scope_add_eml(&c3_s_Ry, c3_d_sf_marshall, 16U); sf_debug_symbol_scope_add_eml(&c3_nargin, c3_d_sf_marshall, 17U); sf_debug_symbol_scope_add_eml(&c3_nargout, c3_d_sf_marshall, 18U); sf_debug_symbol_scope_add_eml(&c3_X, c3_c_sf_marshall, 19U); sf_debug_symbol_scope_add_eml(&c3_u, c3_b_sf_marshall, 20U); sf_debug_symbol_scope_add_eml(&c3_s, c3_sf_marshall, 21U); CV_EML_FCN(0, 0); /* l_F = param.l_F; */ /* l_R = param.l_R; */ _SFD_EML_CALL(0,7); c3_l_F = 1.1; _SFD_EML_CALL(0,8); c3_l_R = 1.6; _SFD_EML_CALL(0,10); c3_Vx = c3_X[0]; _SFD_EML_CALL(0,11); c3_Vy = c3_X[1]; _SFD_EML_CALL(0,12); c3_r = c3_X[2]; _SFD_EML_CALL(0,13); c3_psi = c3_X[3]; _SFD_EML_CALL(0,15); c3_f_Fx = c3_u[0]; _SFD_EML_CALL(0,16); c3_f_Rx = c3_u[1]; _SFD_EML_CALL(0,17); c3_delta = c3_u[2]; _SFD_EML_CALL(0,20); if (CV_EML_COND(0, 0, c3_Vx == 0.0)) { if (CV_EML_COND(0, 1, c3_Vy == 0.0)) { CV_EML_MCDC(0, 0, TRUE); CV_EML_IF(0, 0, TRUE); _SFD_EML_CALL(0,21); c3_beta = 0.0; goto label_1; } } CV_EML_MCDC(0, 0, FALSE); CV_EML_IF(0, 0, FALSE); _SFD_EML_CALL(0,23); c3_A = c3_Vy; c3_B = c3_Vx; c3_x = c3_A; c3_y = c3_B; c3_b_x = c3_x; c3_b_y = c3_y; c3_c_x = c3_b_x; c3_c_y = c3_b_y; c3_d_y = c3_c_x / c3_c_y; c3_d_x = c3_d_y; c3_beta = c3_d_x; c3_e_x = c3_beta; c3_beta = c3_e_x; c3_beta = muDoubleScalarAtan(c3_beta); label_1: ; _SFD_EML_CALL(0,26); c3_f_x = c3_mpower(chartInstance, c3_Vx) + c3_mpower(chartInstance, c3_Vy); c3_V = c3_f_x; if (c3_V < 0.0) { c3_eml_error(chartInstance); } c3_g_x = c3_V; c3_V = c3_g_x; c3_V = muDoubleScalarSqrt(c3_V); _SFD_EML_CALL(0,28); c3_h_x = c3_beta - c3_delta; c3_i_x = c3_h_x; c3_j_x = c3_i_x; c3_i_x = c3_j_x; c3_i_x = muDoubleScalarSin(c3_i_x); c3_a = c3_V; c3_b = c3_i_x; c3_e_y = c3_a * c3_b; c3_b_a = c3_r; c3_f_y = c3_b_a * 1.1; c3_k_x = c3_delta; c3_l_x = c3_k_x; c3_m_x = c3_l_x; c3_l_x = c3_m_x; c3_l_x = muDoubleScalarCos(c3_l_x); c3_c_a = c3_f_y; c3_b_b = c3_l_x; c3_g_y = c3_c_a * c3_b_b; c3_s_Fy_num = c3_e_y + c3_g_y; _SFD_EML_CALL(0,29); c3_n_x = c3_beta - c3_delta; c3_o_x = c3_n_x; c3_p_x = c3_o_x; c3_o_x = c3_p_x; c3_o_x = muDoubleScalarCos(c3_o_x); c3_d_a = c3_V; c3_c_b = c3_o_x; c3_h_y = c3_d_a * c3_c_b; c3_e_a = c3_r; c3_i_y = c3_e_a * 1.1; c3_q_x = c3_delta; c3_r_x = c3_q_x; c3_s_x = c3_r_x; c3_r_x = c3_s_x; c3_r_x = muDoubleScalarSin(c3_r_x); c3_f_a = c3_i_y; c3_d_b = c3_r_x; c3_j_y = c3_f_a * c3_d_b; c3_s_Fy_denum = c3_h_y + c3_j_y; _SFD_EML_CALL(0,31); if (CV_EML_COND(0, 2, c3_s_Fy_num == 0.0)) { if (CV_EML_COND(0, 3, c3_s_Fy_denum == 0.0)) { CV_EML_MCDC(0, 1, TRUE); CV_EML_IF(0, 1, TRUE); _SFD_EML_CALL(0,32); c3_s_Fy = 0.0; goto label_2; } } CV_EML_MCDC(0, 1, FALSE); CV_EML_IF(0, 1, FALSE); _SFD_EML_CALL(0,34); c3_b_A = c3_s_Fy_num; c3_b_B = c3_s_Fy_denum; c3_t_x = c3_b_A; c3_k_y = c3_b_B; c3_u_x = c3_t_x; c3_l_y = c3_k_y; c3_v_x = c3_u_x; c3_m_y = c3_l_y; c3_s_Fy = c3_v_x / c3_m_y; label_2: ; _SFD_EML_CALL(0,37); c3_w_x = c3_beta; c3_x_x = c3_w_x; c3_y_x = c3_x_x; c3_x_x = c3_y_x; c3_x_x = muDoubleScalarSin(c3_x_x); c3_g_a = c3_V; c3_e_b = c3_x_x; c3_n_y = c3_g_a * c3_e_b; c3_h_a = c3_r; c3_o_y = c3_h_a * 1.6; c3_s_Ry_num = c3_n_y - c3_o_y; _SFD_EML_CALL(0,38); c3_ab_x = c3_beta; c3_bb_x = c3_ab_x; c3_cb_x = c3_bb_x; c3_bb_x = c3_cb_x; c3_bb_x = muDoubleScalarCos(c3_bb_x); c3_i_a = c3_V; c3_f_b = c3_bb_x; c3_s_Ry_denum = c3_i_a * c3_f_b; _SFD_EML_CALL(0,40); if (CV_EML_COND(0, 4, c3_s_Ry_num == 0.0)) { if (CV_EML_COND(0, 5, c3_s_Ry_denum == 0.0)) { CV_EML_MCDC(0, 2, TRUE); CV_EML_IF(0, 2, TRUE); _SFD_EML_CALL(0,41); c3_s_Ry = 0.0; goto label_3; } } CV_EML_MCDC(0, 2, FALSE); CV_EML_IF(0, 2, FALSE); _SFD_EML_CALL(0,43); c3_c_A = c3_s_Ry_num; c3_c_B = c3_s_Ry_denum; c3_db_x = c3_c_A; c3_p_y = c3_c_B; c3_eb_x = c3_db_x; c3_q_y = c3_p_y; c3_fb_x = c3_eb_x; c3_r_y = c3_q_y; c3_s_Ry = c3_fb_x / c3_r_y; label_3: ; _SFD_EML_CALL(0,46); c3_s[0] = c3_s_Fy; c3_s[1] = c3_s_Ry; _SFD_EML_CALL(0,-46); sf_debug_symbol_scope_pop(); for (c3_i10 = 0; c3_i10 < 2; c3_i10 = c3_i10 + 1) { (*c3_b_s)[c3_i10] = c3_s[c3_i10]; } _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,2); _sfEvent_ = c3_previousEvent; sf_debug_check_for_state_inconsistency(_car_modelMachineNumber_, chartInstance->chartNumber, chartInstance->instanceNumber); }
/* Function Definitions */ real_T Acoeff(const emlrtStack *sp, real_T ksi, real_T j, real_T x, real_T t, const emxArray_real_T *gridT) { real_T vals; int32_T k; int32_T i0; boolean_T b_x[3]; boolean_T y; boolean_T exitg4; real_T c_x; boolean_T exitg3; real_T z0; boolean_T d_x[2]; boolean_T exitg2; real_T z1; boolean_T exitg1; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* evaluate the coefficient A at the boundary ksi=0 or ksi=1; */ /* for the index j which describes the time steps timePoints_j, at time t and space */ /* point x */ /* timePoints is a vector describing the time descritized domain */ k = gridT->size[1]; i0 = (int32_T)emlrtIntegerCheckFastR2012b(j, &emlrtDCI, sp); if (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &d_emlrtBCI, sp) - 1]) { vals = 0.0; } else { k = gridT->size[1]; i0 = (int32_T)j; b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &e_emlrtBCI, sp) - 1]); k = gridT->size[1]; i0 = (int32_T)((uint32_T)j + 1U); b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &f_emlrtBCI, sp) - 1]); b_x[2] = (x == ksi); y = true; k = 0; exitg4 = false; while ((!exitg4) && (k < 3)) { if (b_x[k] == 0) { y = false; exitg4 = true; } else { k++; } } if (y) { k = gridT->size[1]; i0 = (int32_T)j; emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &c_emlrtBCI, sp); c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931; st.site = &emlrtRSI; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } vals = muDoubleScalarSqrt(c_x); } else { k = gridT->size[1]; i0 = (int32_T)j; b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &g_emlrtBCI, sp) - 1]); k = gridT->size[1]; i0 = (int32_T)((uint32_T)j + 1U); b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &h_emlrtBCI, sp) - 1]); b_x[2] = (x != ksi); y = true; k = 0; exitg3 = false; while ((!exitg3) && (k < 3)) { if (b_x[k] == 0) { y = false; exitg3 = true; } else { k++; } } if (y) { st.site = &b_emlrtRSI; k = gridT->size[1]; i0 = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &m_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } z0 = muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(c_x)); vals = muDoubleScalarAbs(x - ksi) / 3.5449077018110318 * (muDoubleScalarExp(-(z0 * z0)) / z0 - 1.7724538509055159 * scalar_erf (z0)); } else { k = gridT->size[1]; i0 = (int32_T)((uint32_T)j + 1U); d_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &i_emlrtBCI, sp) - 1]); d_x[1] = (x == ksi); y = true; k = 0; exitg2 = false; while ((!exitg2) && (k < 2)) { if (d_x[k] == 0) { y = false; exitg2 = true; } else { k++; } } if (y) { k = gridT->size[1]; i0 = (int32_T)j; emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &b_emlrtBCI, sp); c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931; k = gridT->size[1]; i0 = (int32_T)(j + 1.0); emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &emlrtBCI, sp); z1 = (t - gridT->data[(int32_T)(j + 1.0) - 1]) / 3.1415926535897931; st.site = &c_emlrtRSI; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } st.site = &c_emlrtRSI; if (z1 < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } vals = muDoubleScalarSqrt(c_x) - muDoubleScalarSqrt(z1); } else { k = gridT->size[1]; i0 = (int32_T)((uint32_T)j + 1U); d_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &j_emlrtBCI, sp) - 1]); d_x[1] = (x != ksi); y = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (d_x[k] == 0) { y = false; exitg1 = true; } else { k++; } } if (y) { st.site = &d_emlrtRSI; k = gridT->size[1]; i0 = (int32_T)j; c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &k_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } z0 = muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(c_x)); st.site = &e_emlrtRSI; k = gridT->size[1]; i0 = (int32_T)((uint32_T)j + 1U); c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i0, 1, k, &l_emlrtBCI, &st) - 1]; if (c_x < 0.0) { b_st.site = &f_emlrtRSI; eml_error(&b_st); } z1 = muDoubleScalarAbs(x - ksi) / (2.0 * muDoubleScalarSqrt(c_x)); vals = muDoubleScalarAbs(x - ksi) / 3.5449077018110318 * ((muDoubleScalarExp(-(z0 * z0)) / z0 - muDoubleScalarExp(-(z1 * z1)) / z1) + 1.7724538509055159 * (b_scalar_erf(z0) - b_scalar_erf(z1))); } else { vals = 0.0; } } } } } return vals; }