/* Function Definitions */ void lg1(real_T scale) { real_T d0; /* DRV_PN_LEGENDRE_VECTN Summary of this function goes here */ /* Detailed explanation goes here */ d0 = scale * 5.0 * 2.0; emlrtForLoopVectorCheckR2012b(1.0, 1.0, d0, mxDOUBLE_CLASS, (int32_T)d0, &emlrtRTEI, emlrtRootTLSGlobal); }
/* Function Definitions */ void compmat(const emlrtStack *sp, const emxArray_uint8_T *x, real_T dims, emxArray_real_T *y) { int32_T i1; real_T d3; int32_T ii; int32_T i; emxArray_boolean_T *b_x; emxArray_int32_T *b_ii; int32_T nx; int32_T idx; boolean_T overflow; boolean_T exitg1; boolean_T guard1 = false; 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 = &c_st; d_st.tls = c_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); /* UNTITLED Summary of this function goes here */ /* Detailed explanation goes here */ i1 = y->size[0] * y->size[1]; y->size[0] = 1; if (!(dims >= 0.0)) { emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp); } d3 = dims; if (d3 != (int32_T)muDoubleScalarFloor(d3)) { emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp); } y->size[1] = (int32_T)d3; emxEnsureCapacity(sp, (emxArray__common *)y, i1, (int32_T)sizeof(real_T), &f_emlrtRTEI); if (!(dims >= 0.0)) { emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp); } if (d3 != (int32_T)muDoubleScalarFloor(d3)) { emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp); } ii = (int32_T)d3; for (i1 = 0; i1 < ii; i1++) { y->data[i1] = 0.0; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, dims, mxDOUBLE_CLASS, (int32_T)dims, (emlrtRTEInfo *)&n_emlrtRTEI, sp); i = 0; emxInit_boolean_T(sp, &b_x, 2, &f_emlrtRTEI, true); emxInit_int32_T(sp, &b_ii, 2, &g_emlrtRTEI, true); while (i <= (int32_T)dims - 1) { st.site = &k_emlrtRSI; i1 = b_x->size[0] * b_x->size[1]; b_x->size[0] = 1; b_x->size[1] = x->size[1]; emxEnsureCapacity(&st, (emxArray__common *)b_x, i1, (int32_T)sizeof (boolean_T), &f_emlrtRTEI); ii = x->size[0] * x->size[1]; for (i1 = 0; i1 < ii; i1++) { b_x->data[i1] = (x->data[i1] == 1.0 + (real_T)i); } b_st.site = &h_emlrtRSI; nx = b_x->size[1]; idx = 0; i1 = b_ii->size[0] * b_ii->size[1]; b_ii->size[0] = 1; b_ii->size[1] = b_x->size[1]; emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &f_emlrtRTEI); c_st.site = &i_emlrtRSI; overflow = ((!(1 > b_x->size[1])) && (b_x->size[1] > 2147483646)); if (overflow) { d_st.site = &j_emlrtRSI; check_forloop_overflow_error(&d_st); } ii = 1; exitg1 = false; while ((!exitg1) && (ii <= nx)) { guard1 = false; if (b_x->data[ii - 1]) { idx++; b_ii->data[idx - 1] = ii; if (idx >= nx) { exitg1 = true; } else { guard1 = true; } } else { guard1 = true; } if (guard1) { ii++; } } if (idx <= b_x->size[1]) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &k_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (b_x->size[1] == 1) { if (idx == 0) { i1 = b_ii->size[0] * b_ii->size[1]; b_ii->size[0] = 1; b_ii->size[1] = 0; emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &f_emlrtRTEI); } } else { i1 = b_ii->size[0] * b_ii->size[1]; if (1 > idx) { b_ii->size[1] = 0; } else { b_ii->size[1] = idx; } emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &b_emlrtRTEI); } i1 = y->size[1]; if (!((i + 1 >= 1) && (i + 1 <= i1))) { emlrtDynamicBoundsCheckR2012b(i + 1, 1, i1, (emlrtBCInfo *)&w_emlrtBCI, sp); } y->data[i] = b_ii->size[1]; i++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_int32_T(&b_ii); emxFree_boolean_T(&b_x); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
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); }
void drr_151213_XRayInParam(const emlrtStack *sp, const emxArray_boolean_T *voxel_data, const real_T voxel_size_mm[3], const real_T detector_dimensions[2], const real_T XRayIntrinsicParam[12], const real_T voxel_corner_min[3], const real_T T_carm[16], emxArray_real_T *projection) { const mxArray *y; static const int32_T iv0[2] = { 1, 32 }; const mxArray *m0; char_T cv0[32]; int32_T i; static const char_T cv1[32] = { 'v', 'o', 'x', 'e', 'l', '_', 'd', 'a', 't', 'a', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', '3', '-', 'd', 'i', 'm', 'e', 'n', 's', 'i', 'o', 'n', 'a', 'l' }; int32_T i0; real_T pixel_size_mm_h; real_T pixel_size_mm_w; uint32_T voxDim[3]; real_T voxPlanes__max[3]; real_T source[3]; real_T pixel_size_mmel_wn[3]; real_T pixel_size_mmel_hn[3]; real_T corner[3]; int32_T ih; int32_T iw; real_T tstep[3]; real_T tnext[3]; real_T pixel_point_mm[3]; real_T ray_source2pixel[3]; real_T b_voxPlanes__max[3]; real_T b_ray_source2pixel[3]; real_T t_plane_min[3]; real_T t_plane_max[3]; real_T tmax; int32_T pixel_size_mmIntensity; boolean_T exitg8; boolean_T exitg7; boolean_T exitg6; real_T t_larger[4]; real_T temp; boolean_T exitg5; boolean_T exitg4; boolean_T exitg3; real_T t_smaller[4]; int32_T itmp; boolean_T exitg2; boolean_T exitg1; real_T iz; real_T tx; real_T ty; real_T tz; int32_T i1; int32_T i2; int32_T i3; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* % Modificiation Notes */ /* 15.12.04 */ /* - Release 기존의 파일을 참고로 하여 고성영이 수정하였음. */ /* - DRR을 완벽하게 하지 않고, voxel에 한점이라도 만나면 on으로 계산함 */ /* - 계산속도가 향상되었음 */ /* - 젬스에 있는 X-ray와 테스트하여 검증하였음 */ /* 15 12 13 : The function input has been changed to utilize the x-ray */ /* intrinsic parameter provided by GEMSS % 151213 kosy */ /* %function [projection] = drr (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, isocenter_mm, cbct_angles_deg) */ /* Creates a 2D projection at each cbct_angle of voxel_data. the projection */ /* axis is defined by the isocenter to which the source and center of */ /* the detector are aligned. This simulation assumes standard Cone Beam CT */ /* geometry (source to isocenter distance is 100 cm and source to detector */ /* distance is 150cm). */ /* */ /* voxel_data: must be a 3 dimensional matrix (typically of CT data) */ /* voxel_size_mm: a 3 element vector listing the size (in mm) of the voxels */ /* along each dimension */ /* detector_dimension: a 2 element vector listing the dimensions (number of */ /* pixels) in each dimension (u,v) */ /* pixel_size_mm: a number defining the height and width of each pixel */ /* (assumes square pixel) */ /* isocenter_mm: a 3 element vector pointing from the origin (corner) of the */ /* matrix element(1,1,1) to the isocenter */ /* cbct_angles_deg: a list of angles to generate projections */ /* */ /* Retrun Variable */ /* projection: a 3D matrix with the 3rd dimension representing the angle of */ /* roatation */ /* */ /* { */ /* Author: Michael M. Folkerts [email protected] */ /* Institution: UCSD Physics, UTSW Radiation Oncology */ /* Updated: 2014-July. */ /* Notes: Siddon's Incremental algorithm | modified to read in 3D matlab matrix | Simplified Input | No guarantees!! */ /* */ /* References: */ /* R.L. Siddon, */ /* "Fast calculation of the exact radiological path for a three-dimensional CT */ /* array," Medical Physics 12, 252-255 (1985). */ /* */ /* F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens and I. Lemahieu, */ /* "A fast algorithm to calculate the exact radiological path through a pixel_size_mmel or voxel space," */ /* Journal of Computing and Information Technology 6, 89-94 (1998). */ /* */ /* G. Han, Z. Liang and J. You, */ /* "A fast ray tracing technique for TCT and ECT studies," */ /* IEEE Medical Imaging Conference 1999. */ /* } */ /* function [projection] = drr_good_151204 (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, voxel_corner_min, T_carm) */ /* if(0) */ /* voxel_data = OUTPUTgrid; */ /* voxel_size_mm = voxel_size; */ /* detector_dimensions = detector_dimension; */ /* pixel_size_mm = pixel_size; */ /* isocenter_mm = isocenter; */ /* T_carm: Transformation matrix of C-arm (that is set at the middle of */ /* detector & source) with respect to Voxel coordinates */ /* tic; */ /* this will verify the size: */ if (eml_ndims_varsized(*(int32_T (*)[3])voxel_data->size) != 3) { st.site = &emlrtRSI; y = NULL; m0 = emlrtCreateCharArray(2, iv0); for (i = 0; i < 32; i++) { cv0[i] = cv1[i]; } emlrtInitCharArrayR2013a(&st, 32, m0, cv0); emlrtAssign(&y, m0); b_st.site = &b_emlrtRSI; error(&b_st, y, &emlrtMCI); } /* constants: */ /* .0001; */ /* .0001; */ /* sounce to imager(detector) distance */ /* source to axis distance %% RRI set the coordinate at the middle between source and the detector */ /* initialize memory for speed: */ i0 = projection->size[0] * projection->size[1]; pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0], &b_emlrtDCI, sp); projection->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &emlrtDCI, sp); pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1], &d_emlrtDCI, sp); projection->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &c_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)projection, i0, (int32_T)sizeof (real_T), &emlrtRTEI); pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0], &b_emlrtDCI, sp); pixel_size_mm_w = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1], &d_emlrtDCI, sp); i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &emlrtDCI, sp) * (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &c_emlrtDCI, sp); for (i0 = 0; i0 < i; i0++) { projection->data[i0] = 0.0; } for (i0 = 0; i0 < 3; i0++) { voxDim[i0] = (uint32_T)voxel_data->size[i0]; } /* [size(voxel_data,1), size(voxel_data,2), size(voxel_data,3)]; */ /* voxDim_x = voxDim(1); */ /* voxDim_y = voxDim(2); */ /* voxDim_z = voxDim(3); */ /* difine voxel boundaries: */ /* vector from origin to source */ /* vector from origin to CENTER of detector */ /* extract the key information from the intrinsic parameters % 151213 kosy modi */ pixel_size_mm_h = 1105.0 / XRayIntrinsicParam[0]; pixel_size_mm_w = 1105.0 / XRayIntrinsicParam[4]; /* vector pointing left, parallel to detector */ /* define incremental vectors: */ /* define upper lefthand corner of detector: */ /* corner = detector + ( center_pixel_w*pixel_size_mmel.wn + center_pixel_h*pixel_size_mmel.hn ); */ for (i = 0; i < 3; i++) { voxPlanes__max[i] = voxel_corner_min[i] + voxel_size_mm[i] * (real_T) voxDim[i]; /* define up: */ /* up = [0,0,1]; */ /* width of projection image */ /* height of projection image */ /* direction from the detector to the source */ /* end initialization timer: */ /* init_time = toc */ /* start tracing timer: */ /* tic; */ source[i] = 552.5 * T_carm[4 + i] + T_carm[12 + i]; /* define pixel_size_mmel vectors: */ /* length of pixel_size_mmel */ pixel_size_mmel_wn[i] = -pixel_size_mm_w * T_carm[i]; pixel_size_mmel_hn[i] = -pixel_size_mm_h * T_carm[8 + i]; corner[i] = (-552.5 * T_carm[4 + i] + T_carm[12 + i]) + (detector_dimensions[0] * (pixel_size_mm_w * T_carm[i]) + detector_dimensions[1] * (pixel_size_mm_h * T_carm[8 + i])) / 2.0; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[0], mxDOUBLE_CLASS, (int32_T)detector_dimensions[0], &d_emlrtRTEI, sp); ih = 1; while (ih - 1 <= (int32_T)detector_dimensions[0] - 1) { /* if(mod(ih,100)==0),fprintf('height:\t%i...\n',ih);end */ emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[1], mxDOUBLE_CLASS, (int32_T)detector_dimensions[1], &c_emlrtRTEI, sp); iw = 1; while (iw - 1 <= (int32_T)detector_dimensions[1] - 1) { /* pixel_point_mm = corner + (ih-1)*pixel_size_mmel.hp + (iw-1)*pixel_size_mmel.wp; %ray end point */ /* ray to be traced */ /* find parametrized (t) voxel plane (min or max) intersections: */ /* PLANE = P1 + t(P2-P1) */ /* SK added */ /* t_x = (i-x1) / (x2-x1), t_y = (j-y1) / (y2-y1), t_z = (k-z1) / (z2-z1) */ for (i = 0; i < 3; i++) { pixel_size_mm_h = (corner[i] + ((1.0 + (real_T)(ih - 1)) - 1.0) * pixel_size_mmel_hn[i]) + ((1.0 + (real_T)(iw - 1)) - 1.0) * pixel_size_mmel_wn[i]; /* ray end point */ pixel_size_mm_w = pixel_size_mm_h - source[i]; tstep[i] = voxel_corner_min[i] - source[i]; tnext[i] = pixel_size_mm_w + 2.2250738585072014E-308; b_voxPlanes__max[i] = voxPlanes__max[i] - source[i]; b_ray_source2pixel[i] = pixel_size_mm_w + 2.2250738585072014E-308; pixel_point_mm[i] = pixel_size_mm_h; ray_source2pixel[i] = pixel_size_mm_w; } rdivide(tstep, tnext, t_plane_min); rdivide(b_voxPlanes__max, b_ray_source2pixel, t_plane_max); /* compute (parametric) intersection values */ /* tmin = max { min{tx(0), tx(Nx)}, min{ty(0), ty(Ny)], min{tz(0), tz(Nz)}, 0.0 } */ /* tmax = min { max{tx(0), tx(Nx)}, max{ty(0), ty(Ny)], max{tz(0), tz(Nz)}, 1.0 } */ /* t_larger = [ max([t_plane_min(1), t_plane_max(1)]), max([t_plane_min(2), t_plane_max(2)]), max([t_plane_min(3), t_plane_max(3)]), 1.0 ]; */ /* t_smaller = [ min([t_plane_min(1), t_plane_max(1)]), min([t_plane_min(2), t_plane_max(2)]), min([t_plane_min(3), t_plane_max(3)]), 0.0 ]; */ i = 1; tmax = t_plane_min[0]; if (muDoubleScalarIsNaN(t_plane_min[0])) { pixel_size_mmIntensity = 2; exitg8 = false; while ((!exitg8) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[0])) { tmax = t_plane_max[0]; exitg8 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[0] > tmax)) { tmax = t_plane_max[0]; } i = 1; pixel_size_mm_h = t_plane_min[1]; if (muDoubleScalarIsNaN(t_plane_min[1])) { pixel_size_mmIntensity = 2; exitg7 = false; while ((!exitg7) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[1])) { pixel_size_mm_h = t_plane_max[1]; exitg7 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[1] > pixel_size_mm_h)) { pixel_size_mm_h = t_plane_max[1]; } i = 1; pixel_size_mm_w = t_plane_min[2]; if (muDoubleScalarIsNaN(t_plane_min[2])) { pixel_size_mmIntensity = 2; exitg6 = false; while ((!exitg6) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[2])) { pixel_size_mm_w = t_plane_max[2]; exitg6 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[2] > pixel_size_mm_w)) { pixel_size_mm_w = t_plane_max[2]; } t_larger[0] = tmax; t_larger[1] = pixel_size_mm_h; t_larger[2] = pixel_size_mm_w; t_larger[3] = 1.0; i = 1; temp = t_plane_min[0]; if (muDoubleScalarIsNaN(t_plane_min[0])) { pixel_size_mmIntensity = 2; exitg5 = false; while ((!exitg5) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[0])) { temp = t_plane_max[0]; exitg5 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[0] < temp)) { temp = t_plane_max[0]; } i = 1; pixel_size_mm_h = t_plane_min[1]; if (muDoubleScalarIsNaN(t_plane_min[1])) { pixel_size_mmIntensity = 2; exitg4 = false; while ((!exitg4) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[1])) { pixel_size_mm_h = t_plane_max[1]; exitg4 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[1] < pixel_size_mm_h)) { pixel_size_mm_h = t_plane_max[1]; } i = 1; pixel_size_mm_w = t_plane_min[2]; if (muDoubleScalarIsNaN(t_plane_min[2])) { pixel_size_mmIntensity = 2; exitg3 = false; while ((!exitg3) && (pixel_size_mmIntensity < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[2])) { pixel_size_mm_w = t_plane_max[2]; exitg3 = true; } else { pixel_size_mmIntensity = 3; } } } if ((i < 2) && (t_plane_max[2] < pixel_size_mm_w)) { pixel_size_mm_w = t_plane_max[2]; } t_smaller[0] = temp; t_smaller[1] = pixel_size_mm_h; t_smaller[2] = pixel_size_mm_w; t_smaller[3] = 0.0; i = 1; itmp = 0; if (muDoubleScalarIsNaN(temp)) { pixel_size_mmIntensity = 1; exitg2 = false; while ((!exitg2) && (pixel_size_mmIntensity + 1 < 5)) { i = pixel_size_mmIntensity + 1; if (!muDoubleScalarIsNaN(t_smaller[pixel_size_mmIntensity])) { temp = t_smaller[pixel_size_mmIntensity]; itmp = pixel_size_mmIntensity; exitg2 = true; } else { pixel_size_mmIntensity++; } } } if (i < 4) { while (i + 1 < 5) { if (t_smaller[i] > temp) { temp = t_smaller[i]; itmp = i; } i++; } } i = 1; if (muDoubleScalarIsNaN(tmax)) { pixel_size_mmIntensity = 2; exitg1 = false; while ((!exitg1) && (pixel_size_mmIntensity < 5)) { i = pixel_size_mmIntensity; if (!muDoubleScalarIsNaN(t_larger[pixel_size_mmIntensity - 1])) { tmax = t_larger[pixel_size_mmIntensity - 1]; exitg1 = true; } else { pixel_size_mmIntensity++; } } } if (i < 4) { while (i + 1 < 5) { if (t_larger[i] < tmax) { tmax = t_larger[i]; } i++; } } for (i0 = 0; i0 < 3; i0++) { pixel_point_mm[i0] = (real_T)(pixel_point_mm[i0] < source[i0]) * -2.0 + 1.0; } if (temp < tmax) { /* if ray intersects volume */ /* find index for each dimension: */ for (i = 0; i < 3; i++) { pixel_size_mm_h = muDoubleScalarFloor((((ray_source2pixel[i] * temp + source[i]) - voxel_corner_min[i]) + 2.2250738585072014E-308) / voxel_size_mm[i]); /* (parametric) intersection values... */ /* makes 0 or 1 */ tnext[i] = (voxel_corner_min[i] + ((pixel_size_mm_h + (pixel_point_mm[i] + 1.0) / 2.0) * voxel_size_mm[i] - source[i])) / (ray_source2pixel[i] + 2.2250738585072014E-308); /* parametric value for next plane intersection */ tstep[i] = muDoubleScalarAbs(voxel_size_mm[i] / (ray_source2pixel[i] + 2.2250738585072014E-308)); t_plane_min[i] = pixel_size_mm_h; } /* parametric step size */ /* address special cases... */ if (temp == t_plane_max[emlrtDynamicBoundsCheckFastR2012b(itmp + 1, 1, 3, &c_emlrtBCI, sp) - 1]) { /* if intersection is a "max" plane */ t_plane_min[itmp] = (real_T)voxDim[itmp] - 1.0; tnext[itmp] = temp + tstep[itmp]; /* next plane crossing */ } else { t_plane_min[itmp] = 0.0; tnext[itmp] = temp + tstep[itmp]; /* next plane crossing */ } /* voxel index values(add one for matlab): */ pixel_size_mm_h = t_plane_min[0] + 1.0; pixel_size_mm_w = t_plane_min[1] + 1.0; iz = t_plane_min[2] + 1.0; tx = tnext[0]; ty = tnext[1]; tz = tnext[2]; pixel_size_mmIntensity = 0; /* uncomment to generate P-matrix: */ /* pixel_size_mmNum = 1; */ /* len = norm(ray_source2pixel); % ray length */ while ((temp + 0.0001 < tmax) && (!(pixel_size_mm_h * pixel_size_mm_w * iz == 0.0))) { if ((tx < ty) && (tx < tz)) { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ i0 = voxel_data->size[0]; i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &k_emlrtDCI, sp); itmp = voxel_data->size[1]; i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &l_emlrtDCI, sp); i2 = voxel_data->size[2]; i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &m_emlrtDCI, sp); if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0, &j_emlrtBCI, sp) + voxel_data->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i1, 1, itmp, &k_emlrtBCI, sp) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2, &l_emlrtBCI, sp) - 1)) - 1]) { pixel_size_mmIntensity = 255; tmax = rtMinusInf; } temp = tx; tx += tstep[0]; pixel_size_mm_h += pixel_point_mm[0]; } else if (ty < tz) { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ i0 = voxel_data->size[0]; i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &h_emlrtDCI, sp); itmp = voxel_data->size[1]; i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &i_emlrtDCI, sp); i2 = voxel_data->size[2]; i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &j_emlrtDCI, sp); if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0, &g_emlrtBCI, sp) + voxel_data->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i1, 1, itmp, &h_emlrtBCI, sp) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2, &i_emlrtBCI, sp) - 1)) - 1]) { pixel_size_mmIntensity = 255; tmax = rtMinusInf; } temp = ty; ty += tstep[1]; pixel_size_mm_w += pixel_point_mm[1]; } else { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ i0 = voxel_data->size[0]; i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &e_emlrtDCI, sp); itmp = voxel_data->size[1]; i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &f_emlrtDCI, sp); i2 = voxel_data->size[2]; i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &g_emlrtDCI, sp); if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0, &d_emlrtBCI, sp) + voxel_data->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i1, 1, itmp, &e_emlrtBCI, sp) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2, &f_emlrtBCI, sp) - 1)) - 1]) { pixel_size_mmIntensity = 255; tmax = rtMinusInf; } temp = tz; tz += tstep[2]; iz += pixel_point_mm[2]; } emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } /* end while */ i0 = projection->size[0]; i = projection->size[1]; projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0, &m_emlrtBCI, sp) + projection->size[0] * (emlrtDynamicBoundsCheckFastR2012b(iw, 1, i, &n_emlrtBCI, sp) - 1)) - 1] = pixel_size_mmIntensity; } else { /* if no intersections */ i0 = projection->size[0]; i = projection->size[1]; projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0, &emlrtBCI, sp) + projection->size[0] * (emlrtDynamicBoundsCheckFastR2012b(iw, 1, i, &b_emlrtBCI, sp) - 1)) - 1] = 0.0; } /* if intersections */ /* uncomment to generate P-matrix: */ /* rayCount = rayCount + 1; */ iw++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } /* width */ /* fprintf('\n'); */ ih++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } /* height */ /* uncomment to generate P-matrix: */ /* matrix = matrix(1:mtxCount-1,:); */ /* stop trace timer: */ /* trace_time = toc */ /* fprintf('\n') */ /* function */ /* } */ }
/* Function Definitions */ void CalculateC(const emlrtStack *sp, real_T N, real_T N0, const emxArray_real_T *t, const emxArray_real_T *gridX, emxArray_real_T *C) { int32_T i9; real_T d5; real_T d6; int32_T loop_ub; int32_T i; int32_T k; int32_T b_C; real_T d7; emlrtStack st; st.prev = sp; st.tls = sp->tls; /* calculate the C matrix */ /* N- number of time points */ /* N0- number of space points */ /* t- time points */ /* gridX - grid for the space points */ i9 = C->size[0] * C->size[1]; d5 = 2.0 * N; d5 = emlrtNonNegativeCheckFastR2012b(d5, &ab_emlrtDCI, sp); C->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d5, &y_emlrtDCI, sp); d5 = emlrtNonNegativeCheckFastR2012b(N0, &cb_emlrtDCI, sp); C->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d5, &bb_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)C, i9, (int32_T)sizeof(real_T), &d_emlrtRTEI); d5 = 2.0 * N; d5 = emlrtNonNegativeCheckFastR2012b(d5, &ab_emlrtDCI, sp); d6 = emlrtNonNegativeCheckFastR2012b(N0, &cb_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d5, &y_emlrtDCI, sp) * (int32_T) emlrtIntegerCheckFastR2012b(d6, &bb_emlrtDCI, sp); for (i9 = 0; i9 < loop_ub; i9++) { C->data[i9] = 0.0; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N, &ec_emlrtRTEI, sp); i = 1; while (i - 1 <= (int32_T)N - 1) { /* space */ emlrtForLoopVectorCheckR2012b(1.0, 1.0, N0, mxDOUBLE_CLASS, (int32_T)N0, &fc_emlrtRTEI, sp); k = 0; while (k <= (int32_T)N0 - 1) { /* time */ d5 = 2.0 * (1.0 + (real_T)(i - 1)); b_C = C->size[0]; loop_ub = C->size[1]; emlrtDynamicBoundsCheckFastR2012b(k + 1, 1, loop_ub, &mc_emlrtBCI, sp); i9 = t->size[1]; st.site = &x_emlrtRSI; d6 = b_Ccoeff(&st, 1.0 + (real_T)k, 0.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i9, &nc_emlrtBCI, sp) - 1], gridX); i9 = t->size[1]; st.site = &y_emlrtRSI; d7 = b_Ccoeff(&st, 1.0 + (real_T)k, 1.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i9, &oc_emlrtBCI, sp) - 1], gridX); i9 = (int32_T)(d5 + -1.0); C->data[(emlrtDynamicBoundsCheckFastR2012b(i9, 1, b_C, &pc_emlrtBCI, sp) + C->size[0] * k) - 1] = d6; i9 = (int32_T)d5; C->data[(emlrtDynamicBoundsCheckFastR2012b(i9, 1, b_C, &pc_emlrtBCI, sp) + C->size[0] * k) - 1] = d7; k++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } }
/* Function Definitions */ void CalculateHeatSolution(const emlrtStack *sp, real_T N0, real_T N, const emxArray_real_T *t, const emxArray_real_T *gridT, const emxArray_real_T *x, const emxArray_real_T *u0, const emxArray_real_T *q0j, const emxArray_real_T *q1j, const emxArray_real_T *h0j, const emxArray_real_T *h1j, const emxArray_real_T *f, const emxArray_real_T *r, emxArray_real_T *u) { emxArray_real_T *eta; int32_T i12; real_T sTime; int32_T loop_ub; int32_T i13; int32_T j; emxArray_real_T *b_f; int32_T i; real_T sSpace; int32_T tIdx; int32_T b_i; int32_T i14; int32_T i15; int32_T i16; int32_T i17; int32_T i18; int32_T i19; int32_T i20; int32_T i21; int32_T i22; int32_T i23; int32_T i24; emlrtStack st; emlrtStack b_st; emlrtStack c_st; st.prev = sp; st.tls = sp->tls; b_st.prev = sp; b_st.tls = sp->tls; c_st.prev = sp; c_st.tls = sp->tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); emxInit_real_T(sp, &eta, 2, &f_emlrtRTEI, true); /* get the solution for the inverse heat source, u(x,t), */ /* N0 - number of space points */ /* N - number of time points */ /* t - time points */ /* gridT - time points grid */ /* x space points */ /* q0j flux at x=0 du/dn */ /* q1j flux at x=1 du/dn */ /* h0j boundary condition u(0,t) */ /* u1j boundary condition u(1,t) */ /* f multiplier of the source f(x,t)r(t) size[N N0] */ /* r calculated source term size [N,1] */ i12 = eta->size[0] * eta->size[1]; eta->size[0] = 1; sTime = emlrtNonNegativeCheckFastR2012b(N0, &eb_emlrtDCI, sp); eta->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &db_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)eta, i12, (int32_T)sizeof(real_T), &e_emlrtRTEI); sTime = emlrtNonNegativeCheckFastR2012b(N0, &eb_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &db_emlrtDCI, sp); for (i12 = 0; i12 < loop_ub; i12++) { eta->data[i12] = 1.0; } i12 = (int32_T)N0; emlrtDynamicBoundsCheckFastR2012b(1, 1, i12, &tc_emlrtBCI, sp); eta->data[0] = 0.5; i12 = (int32_T)N0; i13 = (int32_T)N0; eta->data[emlrtDynamicBoundsCheckFastR2012b(i13, 1, i12, &uc_emlrtBCI, sp) - 1] = 0.5; i12 = u->size[0] * u->size[1]; sTime = emlrtNonNegativeCheckFastR2012b(N, &gb_emlrtDCI, sp); u->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &fb_emlrtDCI, sp); u->size[1] = (int32_T)N0; emxEnsureCapacity(sp, (emxArray__common *)u, i12, (int32_T)sizeof(real_T), &e_emlrtRTEI); sTime = emlrtNonNegativeCheckFastR2012b(N, &gb_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &fb_emlrtDCI, sp) * (int32_T)N0; for (i12 = 0; i12 < loop_ub; i12++) { u->data[i12] = 0.0; } j = 1; emxInit_real_T(sp, &b_f, 2, &e_emlrtRTEI, true); while (j - 1 <= (int32_T)N0 - 1) { /* space index */ emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N, &gc_emlrtRTEI, sp); i = 1; while (i - 1 <= (int32_T)N - 1) { /* time index */ sTime = 0.0; /* cumulative sums */ sSpace = 0.0; emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N, &hc_emlrtRTEI, sp); tIdx = 0; while (tIdx <= (int32_T)N - 1) { /* time index */ loop_ub = f->size[1]; i12 = f->size[0]; b_i = emlrtDynamicBoundsCheckFastR2012b(i, 1, i12, &sc_emlrtBCI, sp); i12 = b_f->size[0] * b_f->size[1]; b_f->size[0] = 1; b_f->size[1] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)b_f, i12, (int32_T)sizeof (real_T), &e_emlrtRTEI); for (i12 = 0; i12 < loop_ub; i12++) { b_f->data[b_f->size[0] * i12] = f->data[(b_i + f->size[0] * i12) - 1]; } i12 = x->size[1]; i13 = t->size[1]; i14 = q0j->size[0]; i15 = x->size[1]; loop_ub = t->size[1]; b_i = q1j->size[0]; i16 = x->size[1]; i17 = t->size[1]; i18 = h0j->size[0]; i19 = x->size[1]; i20 = t->size[1]; i21 = h1j->size[0]; i22 = x->size[1]; i23 = t->size[1]; i24 = r->size[0]; st.site = &bb_emlrtRSI; b_st.site = &cb_emlrtRSI; c_st.site = &db_emlrtRSI; sTime = ((((sTime + Acoeff(&st, 0.0, 1.0 + (real_T)tIdx, x-> data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i12, &cd_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i13, &dd_emlrtBCI, sp) - 1], gridT) * q0j->data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i14, &ed_emlrtBCI, sp) - 1]) + Acoeff(&st, 1.0, 1.0 + (real_T) tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i15, &fd_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, loop_ub, &gd_emlrtBCI, sp) - 1], gridT) * q1j-> data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, b_i, &hd_emlrtBCI, sp) - 1]) - Bcoeff(&b_st, 0.0, 1.0 + (real_T) tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i16, &id_emlrtBCI, sp) - 1], t-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i17, &jd_emlrtBCI, sp) - 1], gridT) * h0j-> data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i18, &kd_emlrtBCI, sp) - 1]) - Bcoeff(&b_st, 1.0, 1.0 + (real_T) tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i19, &ld_emlrtBCI, sp) - 1], t-> data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i20, &md_emlrtBCI, sp) - 1], gridT) * h1j-> data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i21, &nd_emlrtBCI, sp) - 1]) + b_Dcoeff(&c_st, x, 1.0 + (real_T) tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i22, &od_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i23, &pd_emlrtBCI, sp) - 1], gridT, b_f) * r-> data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i24, &qd_emlrtBCI, sp) - 1]; tIdx++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } loop_ub = 0; while (loop_ub <= (int32_T)N0 - 1) { /* space index */ i12 = x->size[1]; i13 = t->size[1]; i14 = u0->size[1]; i15 = 1 + loop_ub; st.site = &eb_emlrtRSI; sSpace += b_Ccoeff(&st, 1.0 + (real_T)loop_ub, x-> data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i12, &yc_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i13, &ad_emlrtBCI, sp) - 1], gridT) * u0-> data[emlrtDynamicBoundsCheckFastR2012b(i15, 1, i14, &bd_emlrtBCI, sp) - 1]; loop_ub++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } i12 = u->size[0]; i13 = u->size[1]; i14 = eta->size[1]; u->data[(emlrtDynamicBoundsCheckFastR2012b(i, 1, i12, &vc_emlrtBCI, sp) + u->size[0] * (emlrtDynamicBoundsCheckFastR2012b(j, 1, i13, &wc_emlrtBCI, sp) - 1)) - 1] = (sTime + sSpace) * eta-> data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i14, &xc_emlrtBCI, sp) - 1]; i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } j++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } emxFree_real_T(&b_f); emxFree_real_T(&eta); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
/* Function Definitions */ void linearODESSEP2X4(const emxArray_real_T *T, const emxArray_real_T *I) { int32_T i; real_T hoistedGlobal[9]; int32_T j; int32_T b_i; real_T normA; real_T y[81]; real_T F[81]; boolean_T exitg2; real_T s; boolean_T exitg1; static const real_T theta[5] = { 0.01495585217958292, 0.253939833006323, 0.95041789961629319, 2.097847961257068, 5.3719203511481517 }; static const int8_T iv2[5] = { 3, 5, 7, 9, 13 }; int32_T eint; real_T b_y[81]; real_T beta1; char_T TRANSB; char_T TRANSA; ptrdiff_t m_t; ptrdiff_t n_t; ptrdiff_t k_t; ptrdiff_t lda_t; ptrdiff_t ldb_t; ptrdiff_t ldc_t; double * alpha1_t; double * Aia0_t; double * Bib0_t; double * beta1_t; double * Cic0_t; emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); /* global k1 k2 k3 k4 k5 k6 k7 k8 k9 k10 k11 k12 L1 L2 L3 L4 H1 H2 H3 H4 g1 g2 E1 E2 alpha A J Q; */ /* Right */ /* [C1,C2,C3,Q1,Q2,Q3,D1,D2,Z] */ Q[0] = -k2 * A - L2 * J; Q[9] = L2 * J; Q[18] = 0.0; Q[27] = k2 * A; Q[36] = 0.0; Q[45] = 0.0; Q[54] = 0.0; Q[63] = 0.0; Q[72] = 0.0; Q[1] = L1; Q[10] = (-k4 * A - L1) - L4 * J; Q[19] = L4 * J; Q[28] = 0.0; Q[37] = k4 * A; Q[46] = 0.0; Q[55] = 0.0; Q[64] = 0.0; Q[73] = 0.0; Q[2] = 0.0; Q[11] = L3; Q[20] = -k6 * A - L3; Q[29] = 0.0; Q[38] = 0.0; Q[47] = k6 * A; Q[56] = 0.0; Q[65] = 0.0; Q[74] = 0.0; Q[3] = k1; Q[12] = 0.0; Q[21] = 0.0; Q[30] = (-k1 - L2 * J) - H2; Q[39] = L2 * J; Q[48] = 0.0; Q[57] = 0.0; Q[66] = H2; Q[75] = 0.0; Q[4] = 0.0; Q[13] = k3; Q[22] = 0.0; Q[31] = L1; Q[40] = (-k3 - L1) - L4 * J; Q[49] = L4 * J; Q[58] = 0.0; Q[67] = 0.0; Q[76] = 0.0; Q[5] = 0.0; Q[14] = 0.0; Q[23] = k5; Q[32] = 0.0; Q[41] = L3; Q[50] = -k5 - L3; Q[59] = 0.0; Q[68] = 0.0; Q[77] = 0.0; Q[6] = H1; Q[15] = 0.0; Q[24] = 0.0; Q[33] = 0.0; Q[42] = 0.0; Q[51] = 0.0; Q[60] = -k2 * A - H1; Q[69] = k2 * A; Q[78] = 0.0; Q[7] = 0.0; Q[16] = 0.0; Q[25] = 0.0; Q[34] = 0.0; Q[43] = 0.0; Q[52] = 0.0; Q[61] = k1; Q[70] = -k1 - H3; Q[79] = H3; Q[8] = H4; Q[17] = 0.0; Q[26] = 0.0; Q[35] = 0.0; Q[44] = 0.0; Q[53] = 0.0; Q[62] = 0.0; Q[71] = 0.0; Q[80] = -H4; Q_dirty |= 1U; emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); i = 0; while (i <= T->size[0] - 1) { emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); memcpy(&hoistedGlobal[0], &p0[0], 9U * sizeof(real_T)); j = T->size[0]; b_i = (int32_T)(1.0 + (real_T)i); emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &t_emlrtBCI, emlrtRootTLSGlobal); normA = T->data[i]; for (j = 0; j < 81; j++) { y[j] = Q[j] * normA; } normA = 0.0; j = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (j < 9)) { s = 0.0; for (b_i = 0; b_i < 9; b_i++) { s += muDoubleScalarAbs(y[b_i + 9 * j]); } if (muDoubleScalarIsNaN(s)) { normA = rtNaN; exitg2 = TRUE; } else { if (s > normA) { normA = s; } j++; } } if (normA <= 5.3719203511481517) { b_i = 0; exitg1 = FALSE; while ((exitg1 == FALSE) && (b_i < 5)) { if (normA <= theta[b_i]) { emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); PadeApproximantOfDegree(y, iv2[b_i], F); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); exitg1 = TRUE; } else { b_i++; } } } else { normA /= 5.3719203511481517; if ((!muDoubleScalarIsInf(normA)) && (!muDoubleScalarIsNaN(normA))) { normA = frexp(normA, &eint); j = eint; } else { j = 0; } s = j; if (normA == 0.5) { s = (real_T)j - 1.0; } normA = muDoubleScalarPower(2.0, s); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); for (j = 0; j < 81; j++) { b_y[j] = y[j] / normA; } PadeApproximantOfDegree(b_y, 13.0, F); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtForLoopVectorCheckR2012b(1.0, 1.0, s, mxDOUBLE_CLASS, (int32_T)s, &g_emlrtRTEI, emlrtRootTLSGlobal); for (j = 0; j < (int32_T)s; j++) { emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal); memcpy(&y[0], &F[0], 81U * sizeof(real_T)); emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal); normA = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; memset(&F[0], 0, 81U * sizeof(real_T)); emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); m_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); n_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); k_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); lda_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); ldb_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); ldc_t = (ptrdiff_t)(9); emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); alpha1_t = (double *)(&normA); emlrtPopRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Aia0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Bib0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Cic0_t = (double *)(&F[0]); emlrtPopRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); } } for (j = 0; j < 9; j++) { p0[j] = 0.0; for (b_i = 0; b_i < 9; b_i++) { p0[j] += hoistedGlobal[b_i] * F[b_i + 9 * j]; } } p0_dirty |= 1U; emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); j = I->size[0]; b_i = 1 + i; normA = Acell * 1.0E+12 * (g1 * p0[3] * (V - E1) + g2 * (p0[4] + p0[5]) * (V - E2)) - I->data[emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &u_emlrtBCI, emlrtRootTLSGlobal) - 1]; normA = muDoubleScalarAbs(normA); err += normA * normA; err_dirty |= 1U; i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal); } }
/* Function Definitions */ void linearODESSEP2X4(const emxArray_real_T *T, const emxArray_real_T *I) { int32_T i; real_T hoistedGlobal[17]; int32_T j; int32_T b_i; real_T normA; real_T y[289]; real_T F[289]; boolean_T exitg2; real_T s; boolean_T exitg1; static const real_T theta[5] = { 0.01495585217958292, 0.253939833006323, 0.95041789961629319, 2.097847961257068, 5.3719203511481517 }; static const int8_T iv2[5] = { 3, 5, 7, 9, 13 }; int32_T eint; real_T b_y[289]; real_T beta1; char_T TRANSB; char_T TRANSA; ptrdiff_t m_t; ptrdiff_t n_t; ptrdiff_t k_t; ptrdiff_t lda_t; ptrdiff_t ldb_t; ptrdiff_t ldc_t; double * alpha1_t; double * Aia0_t; double * Bib0_t; double * beta1_t; double * Cic0_t; emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal); Q[0] = -k2 * A - L2 * J; Q[17] = k2 * A; Q[34] = L2 * J; Q[51] = 0.0; Q[68] = 0.0; Q[85] = 0.0; Q[102] = 0.0; Q[119] = 0.0; Q[136] = 0.0; Q[153] = 0.0; Q[170] = 0.0; Q[187] = 0.0; Q[204] = 0.0; Q[221] = 0.0; Q[238] = 0.0; Q[255] = 0.0; Q[272] = 0.0; Q[1] = k1; Q[18] = ((-k1 - k4 * A) - H2) - L2 * J; Q[35] = 0.0; Q[52] = L2 * J; Q[69] = 0.0; Q[86] = 0.0; Q[103] = k4 * A; Q[120] = 0.0; Q[137] = 0.0; Q[154] = 0.0; Q[171] = 0.0; Q[188] = 0.0; Q[205] = 0.0; Q[222] = H2; Q[239] = 0.0; Q[256] = 0.0; Q[273] = 0.0; Q[2] = L1; Q[19] = 0.0; Q[36] = (-k8 * A - L1) - L4 * J; Q[53] = k8 * A; Q[70] = L4 * J; Q[87] = 0.0; Q[104] = 0.0; Q[121] = 0.0; Q[138] = 0.0; Q[155] = 0.0; Q[172] = 0.0; Q[189] = 0.0; Q[206] = 0.0; Q[223] = 0.0; Q[240] = 0.0; Q[257] = 0.0; Q[274] = 0.0; Q[3] = 0.0; Q[20] = L1; Q[37] = k7; Q[54] = ((-k7 - k10 * A) - L1) - L4 * J; Q[71] = 0.0; Q[88] = L4 * J; Q[105] = 0.0; Q[122] = 0.0; Q[139] = k10 * A; Q[156] = 0.0; Q[173] = 0.0; Q[190] = 0.0; Q[207] = 0.0; Q[224] = 0.0; Q[241] = 0.0; Q[258] = 0.0; Q[275] = 0.0; Q[4] = 0.0; Q[21] = 0.0; Q[38] = L3; Q[55] = 0.0; Q[72] = -k8 * alpha * A - L3; Q[89] = k8 * alpha * A; Q[106] = 0.0; Q[123] = 0.0; Q[140] = 0.0; Q[157] = 0.0; Q[174] = 0.0; Q[191] = 0.0; Q[208] = 0.0; Q[225] = 0.0; Q[242] = 0.0; Q[259] = 0.0; Q[276] = 0.0; Q[5] = 0.0; Q[22] = 0.0; Q[39] = 0.0; Q[56] = L3; Q[73] = k7; Q[90] = (-k7 - k10 * alpha * A) - L3; Q[107] = 0.0; Q[124] = 0.0; Q[141] = 0.0; Q[158] = 0.0; Q[175] = k10 * alpha * A; Q[192] = 0.0; Q[209] = 0.0; Q[226] = 0.0; Q[243] = 0.0; Q[260] = 0.0; Q[277] = 0.0; Q[6] = 0.0; Q[23] = k3; Q[40] = 0.0; Q[57] = 0.0; Q[74] = 0.0; Q[91] = 0.0; Q[108] = ((-k3 - k6 * A) - H2) - L2 * J; Q[125] = k6 * A; Q[142] = L2 * J; Q[159] = 0.0; Q[176] = 0.0; Q[193] = 0.0; Q[210] = 0.0; Q[227] = 0.0; Q[244] = H2; Q[261] = 0.0; Q[278] = 0.0; Q[7] = 0.0; Q[24] = 0.0; Q[41] = 0.0; Q[58] = 0.0; Q[75] = 0.0; Q[92] = 0.0; Q[109] = k5; Q[126] = (-k5 - H2) - L2 * J; Q[143] = 0.0; Q[160] = L2 * J; Q[177] = 0.0; Q[194] = 0.0; Q[211] = 0.0; Q[228] = 0.0; Q[245] = 0.0; Q[262] = H2; Q[279] = 0.0; Q[8] = 0.0; Q[25] = 0.0; Q[42] = 0.0; Q[59] = k9; Q[76] = 0.0; Q[93] = 0.0; Q[110] = L1; Q[127] = 0.0; Q[144] = ((-k9 - k12 * A) - L1) - L4 * J; Q[161] = k12 * A; Q[178] = L4 * J; Q[195] = 0.0; Q[212] = 0.0; Q[229] = 0.0; Q[246] = 0.0; Q[263] = 0.0; Q[280] = 0.0; Q[9] = 0.0; Q[26] = 0.0; Q[43] = 0.0; Q[60] = 0.0; Q[77] = 0.0; Q[94] = 0.0; Q[111] = 0.0; Q[128] = L1; Q[145] = k11; Q[162] = (-k11 - L1) - L4 * J; Q[179] = 0.0; Q[196] = L4 * J; Q[213] = 0.0; Q[230] = 0.0; Q[247] = 0.0; Q[264] = 0.0; Q[281] = 0.0; Q[10] = 0.0; Q[27] = 0.0; Q[44] = 0.0; Q[61] = 0.0; Q[78] = 0.0; Q[95] = k9; Q[112] = 0.0; Q[129] = 0.0; Q[146] = L3; Q[163] = 0.0; Q[180] = (-k9 - k12 * alpha * A) - L3; Q[197] = k12 * alpha * A; Q[214] = 0.0; Q[231] = 0.0; Q[248] = 0.0; Q[265] = 0.0; Q[282] = 0.0; Q[11] = 0.0; Q[28] = 0.0; Q[45] = 0.0; Q[62] = 0.0; Q[79] = 0.0; Q[96] = 0.0; Q[113] = 0.0; Q[130] = 0.0; Q[147] = 0.0; Q[164] = L3; Q[181] = k11; Q[198] = -k11 - L3; Q[215] = 0.0; Q[232] = 0.0; Q[249] = 0.0; Q[266] = 0.0; Q[283] = 0.0; Q[12] = H1; Q[29] = 0.0; Q[46] = 0.0; Q[63] = 0.0; Q[80] = 0.0; Q[97] = 0.0; Q[114] = 0.0; Q[131] = 0.0; Q[148] = 0.0; Q[165] = 0.0; Q[182] = 0.0; Q[199] = 0.0; Q[216] = -k2 * A - H1; Q[233] = k2 * A; Q[250] = 0.0; Q[267] = 0.0; Q[284] = 0.0; Q[13] = 0.0; Q[30] = 0.0; Q[47] = 0.0; Q[64] = 0.0; Q[81] = 0.0; Q[98] = 0.0; Q[115] = 0.0; Q[132] = 0.0; Q[149] = 0.0; Q[166] = 0.0; Q[183] = 0.0; Q[200] = 0.0; Q[217] = k1; Q[234] = -k1 - k4 * A; Q[251] = k4 * A; Q[268] = 0.0; Q[285] = 0.0; Q[14] = 0.0; Q[31] = 0.0; Q[48] = 0.0; Q[65] = 0.0; Q[82] = 0.0; Q[99] = 0.0; Q[116] = 0.0; Q[133] = 0.0; Q[150] = 0.0; Q[167] = 0.0; Q[184] = 0.0; Q[201] = 0.0; Q[218] = 0.0; Q[235] = k3; Q[252] = -k3 - k6 * A; Q[269] = k6 * A; Q[286] = 0.0; Q[15] = 0.0; Q[32] = 0.0; Q[49] = 0.0; Q[66] = 0.0; Q[83] = 0.0; Q[100] = 0.0; Q[117] = 0.0; Q[134] = 0.0; Q[151] = 0.0; Q[168] = 0.0; Q[185] = 0.0; Q[202] = 0.0; Q[219] = 0.0; Q[236] = 0.0; Q[253] = k5; Q[270] = -k5 - H3; Q[287] = H3; Q[16] = H4; Q[33] = 0.0; Q[50] = 0.0; Q[67] = 0.0; Q[84] = 0.0; Q[101] = 0.0; Q[118] = 0.0; Q[135] = 0.0; Q[152] = 0.0; Q[169] = 0.0; Q[186] = 0.0; Q[203] = 0.0; Q[220] = 0.0; Q[237] = 0.0; Q[254] = 0.0; Q[271] = 0.0; Q[288] = -H4; Q_dirty |= 1U; emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal); i = 0; while (i <= T->size[0] - 1) { emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal); memcpy(&hoistedGlobal[0], &p0[0], 17U * sizeof(real_T)); j = T->size[0]; b_i = (int32_T)(1.0 + (real_T)i); emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &bd_emlrtBCI, emlrtRootTLSGlobal); normA = T->data[i]; for (j = 0; j < 289; j++) { y[j] = Q[j] * normA; } normA = 0.0; j = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (j < 17)) { s = 0.0; for (b_i = 0; b_i < 17; b_i++) { s += muDoubleScalarAbs(y[b_i + 17 * j]); } if (muDoubleScalarIsNaN(s)) { normA = rtNaN; exitg2 = TRUE; } else { if (s > normA) { normA = s; } j++; } } if (normA <= 5.3719203511481517) { b_i = 0; exitg1 = FALSE; while ((exitg1 == FALSE) && (b_i < 5)) { if (normA <= theta[b_i]) { emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal); PadeApproximantOfDegree(y, iv2[b_i], F); emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal); exitg1 = TRUE; } else { b_i++; } } } else { normA /= 5.3719203511481517; if ((!muDoubleScalarIsInf(normA)) && (!muDoubleScalarIsNaN(normA))) { normA = frexp(normA, &eint); j = eint; } else { j = 0; } s = j; if (normA == 0.5) { s = (real_T)j - 1.0; } normA = muDoubleScalarPower(2.0, s); emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal); for (j = 0; j < 289; j++) { b_y[j] = y[j] / normA; } PadeApproximantOfDegree(b_y, 13.0, F); emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal); emlrtForLoopVectorCheckR2012b(1.0, 1.0, s, mxDOUBLE_CLASS, (int32_T)s, &l_emlrtRTEI, emlrtRootTLSGlobal); for (j = 0; j < (int32_T)s; j++) { emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal); memcpy(&y[0], &F[0], 289U * sizeof(real_T)); emlrtPushRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal); normA = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; memset(&F[0], 0, 289U * sizeof(real_T)); emlrtPushRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); m_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); n_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); k_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); lda_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); ldb_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); ldc_t = (ptrdiff_t)(17); emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); alpha1_t = (double *)(&normA); emlrtPopRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Aia0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Bib0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); Cic0_t = (double *)(&F[0]); emlrtPopRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal); emlrt_checkEscapedGlobals(); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal); } } for (j = 0; j < 17; j++) { p0[j] = 0.0; for (b_i = 0; b_i < 17; b_i++) { p0[j] += hoistedGlobal[b_i] * F[b_i + 17 * j]; } } p0_dirty |= 1U; emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal); j = I->size[0]; b_i = 1 + i; normA = Acell * 1.0E+12 * (g1 * (p0[6] + p0[7]) * (V - E1) + g2 * (((p0[8] + p0[9]) + p0[10]) + p0[11]) * (V - E2)) - I-> data[emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &cd_emlrtBCI, emlrtRootTLSGlobal) - 1]; normA = muDoubleScalarAbs(normA); err += normA * normA; err_dirty |= 1U; i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal); } }
/* 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 */ real_T compressedindex(const emlrtStack *sp, const emxArray_real_T *x, const emxArray_real_T *ctable, real_T range, real_T dims) { real_T y; real_T py; int32_T i; int32_T i2; int32_T i3; real_T d4; int32_T k; int32_T vlen; boolean_T p; boolean_T b_p; int32_T exitg1; int32_T b_k; 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; /* for a given vector, find its index within the transition space matrix */ /* workspace; */ py = 1.0; range++; emlrtForLoopVectorCheckR2012b(1.0, 1.0, dims - 2.0, mxDOUBLE_CLASS, (int32_T) (dims - 2.0), (emlrtRTEInfo *)&o_emlrtRTEI, sp); i = 0; while (i <= (int32_T)(dims - 2.0) - 1) { i2 = x->size[1]; if (!((i + 1 >= 1) && (i + 1 <= i2))) { emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&bb_emlrtBCI, sp); } if (x->data[i] == 0.0) { } else { i2 = x->size[1]; if (!((i + 1 >= 1) && (i + 1 <= i2))) { emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&cb_emlrtBCI, sp); } d4 = range - (x->data[i] - 1.0); if (d4 > range) { i3 = 1; i2 = 1; } else { if (d4 != (int32_T)muDoubleScalarFloor(d4)) { emlrtIntegerCheckR2012b(d4, (emlrtDCInfo *)&k_emlrtDCI, sp); } i2 = ctable->size[0]; i3 = (int32_T)d4; if (!((i3 >= 1) && (i3 <= i2))) { emlrtDynamicBoundsCheckR2012b(i3, 1, i2, (emlrtBCInfo *)&x_emlrtBCI, sp); } if (range != (int32_T)muDoubleScalarFloor(range)) { emlrtIntegerCheckR2012b(range, (emlrtDCInfo *)&k_emlrtDCI, sp); } i2 = ctable->size[0]; k = (int32_T)range; if (!((k >= 1) && (k <= i2))) { emlrtDynamicBoundsCheckR2012b(k, 1, i2, (emlrtBCInfo *)&x_emlrtBCI, sp); } i2 = k + 1; } st.site = &l_emlrtRSI; d4 = dims - (1.0 + (real_T)i); if (d4 != (int32_T)muDoubleScalarFloor(d4)) { emlrtIntegerCheckR2012b(d4, (emlrtDCInfo *)&l_emlrtDCI, &st); } k = ctable->size[1]; vlen = (int32_T)d4; if (!((vlen >= 1) && (vlen <= k))) { emlrtDynamicBoundsCheckR2012b(vlen, 1, k, (emlrtBCInfo *)&y_emlrtBCI, &st); } b_st.site = &m_emlrtRSI; if ((i2 - i3 == 1) || (i2 - i3 != 1)) { p = true; } else { p = false; } if (p) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &p_emlrtRTEI, "Coder:toolbox:autoDimIncompatibility", 0); } p = false; b_p = false; k = 0; do { exitg1 = 0; if (k < 2) { if (k + 1 <= 1) { b_k = i2 - i3; } else { b_k = 1; } if (b_k != 0) { exitg1 = 1; } else { k++; } } else { b_p = true; exitg1 = 1; } } while (exitg1 == 0); if (!b_p) { } else { p = true; } if (!p) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &q_emlrtRTEI, "Coder:toolbox:UnsupportedSpecialEmpty", 0); } c_st.site = &n_emlrtRSI; if (i2 - i3 == 0) { y = 0.0; } else { vlen = i2 - i3; y = ctable->data[(i3 + ctable->size[0] * ((int32_T)(dims - (1.0 + (real_T)i)) - 1)) - 1]; d_st.site = &o_emlrtRSI; if ((!(2 > i2 - i3)) && (i2 - i3 > 2147483646)) { e_st.site = &j_emlrtRSI; check_forloop_overflow_error(&e_st); } for (k = 0; k + 2 <= vlen; k++) { y += ctable->data[(i3 + k) + ctable->size[0] * ((int32_T)(dims - (1.0 + (real_T)i)) - 1)]; } } py += y; i2 = x->size[1]; if (!((i + 1 >= 1) && (i + 1 <= i2))) { emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&db_emlrtBCI, sp); } range -= x->data[i]; } i++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } i2 = x->size[1]; i3 = x->size[1] - 1; if (!((i3 >= 1) && (i3 <= i2))) { emlrtDynamicBoundsCheckR2012b(i3, 1, i2, (emlrtBCInfo *)&ab_emlrtBCI, sp); } return py + x->data[i3 - 1]; }
/* Function Definitions */ void occflow(const emlrtStack *sp, const emxArray_real_T *cgridvec, emxArray_real_T *cgridvecprev, emxArray_real_T *context, const emxArray_real_T *nei_idx, const emxArray_real_T *nei_weight, real_T nei_filter_n, const emxArray_real_T *nei4u_idx, const emxArray_real_T *nei4u_weight, real_T nei4u_filter_n, real_T occval, real_T minthreshold, real_T maxthreshold, real_T reinitval, real_T intensifyrate, real_T nocc_attenuaterate, real_T unknown_attenuaterate, real_T sigm_coef, real_T do_attenuation_first, emxArray_real_T *predvec, emxArray_real_T *maxvec) { emxArray_boolean_T *x; int32_T ix; int32_T idx; emxArray_boolean_T *r0; int32_T nx; emxArray_int32_T *ii; boolean_T overflow; int32_T iy; boolean_T exitg6; boolean_T guard3 = false; boolean_T guard4 = false; emxArray_real_T *newlyoccidx; boolean_T exitg5; boolean_T guard2 = false; boolean_T b_guard3 = false; emxArray_real_T *occidx; boolean_T exitg4; boolean_T guard1 = false; boolean_T b_guard2 = false; emxArray_real_T *noccidx; int32_T nrnocc; int32_T j; emxArray_real_T *curr_col; emxArray_real_T *updt_col; emxArray_real_T *z; int32_T coccidx; boolean_T b_guard1 = false; int32_T ixstart; int32_T n; real_T mtmp; boolean_T exitg3; int32_T varargin_1[2]; int32_T k; int32_T iv3[2]; int32_T iv4[2]; real_T d0; emxArray_real_T *tempcontext; emxArray_real_T *b_nei4u_weight; real_T sumval; int32_T m; int32_T iv5[2]; boolean_T b_ix; boolean_T exitg2; boolean_T b_ixstart; int32_T varargin_2[2]; boolean_T p; boolean_T exitg1; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_st; emlrtStack f_st; (void)unknown_attenuaterate; 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; emlrtHeapReferenceStackEnterFcnR2012b(sp); emxInit_boolean_T(sp, &x, 1, &emlrtRTEI, true); /* */ /* Occupancy flow with vector input */ /* */ /* Compute indices first */ ix = x->size[0]; x->size[0] = cgridvec->size[0]; emxEnsureCapacity(sp, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); idx = cgridvec->size[0]; for (ix = 0; ix < idx; ix++) { x->data[ix] = (cgridvec->data[ix] == occval); } emxInit_boolean_T(sp, &r0, 1, &emlrtRTEI, true); ix = r0->size[0]; r0->size[0] = cgridvecprev->size[0]; emxEnsureCapacity(sp, (emxArray__common *)r0, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); idx = cgridvecprev->size[0]; for (ix = 0; ix < idx; ix++) { r0->data[ix] = (cgridvecprev->data[ix] != occval); } ix = x->size[0]; nx = r0->size[0]; if (ix != nx) { emlrtSizeEqCheck1DR2012b(ix, nx, &emlrtECI, sp); } st.site = &emlrtRSI; ix = x->size[0]; emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); idx = x->size[0]; for (ix = 0; ix < idx; ix++) { x->data[ix] = (x->data[ix] && r0->data[ix]); } emxFree_boolean_T(&r0); emxInit_int32_T(&st, &ii, 1, &l_emlrtRTEI, true); b_st.site = &i_emlrtRSI; nx = x->size[0]; idx = 0; ix = ii->size[0]; ii->size[0] = x->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); c_st.site = &j_emlrtRSI; if (1 > x->size[0]) { overflow = false; } else { overflow = (x->size[0] > 2147483646); } if (overflow) { d_st.site = &l_emlrtRSI; check_forloop_overflow_error(&d_st); } iy = 1; exitg6 = false; while ((!exitg6) && (iy <= nx)) { guard3 = false; if (x->data[iy - 1]) { idx++; ii->data[idx - 1] = iy; if (idx >= nx) { exitg6 = true; } else { guard3 = true; } } else { guard3 = true; } if (guard3) { iy++; } } if (idx <= x->size[0]) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (x->size[0] == 1) { if (idx == 0) { ix = ii->size[0]; ii->size[0] = 0; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof (int32_T), &emlrtRTEI); } } else { if (1 > idx) { ix = 0; } else { ix = idx; } c_st.site = &k_emlrtRSI; overflow = !(ii->size[0] != 1); guard4 = false; if (overflow) { overflow = false; if (ix != 1) { overflow = true; } if (overflow) { overflow = true; } else { guard4 = true; } } else { guard4 = true; } if (guard4) { overflow = false; } d_st.site = &m_emlrtRSI; if (!overflow) { } else { emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI, "Coder:FE:PotentialVectorVector", 0); } nx = ii->size[0]; ii->size[0] = ix; emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T), &c_emlrtRTEI); } emxInit_real_T(&b_st, &newlyoccidx, 1, &f_emlrtRTEI, true); ix = newlyoccidx->size[0]; newlyoccidx->size[0] = ii->size[0]; emxEnsureCapacity(&st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = ii->size[0]; for (ix = 0; ix < idx; ix++) { newlyoccidx->data[ix] = ii->data[ix]; } st.site = &b_emlrtRSI; ix = x->size[0]; x->size[0] = cgridvec->size[0]; emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); idx = cgridvec->size[0]; for (ix = 0; ix < idx; ix++) { x->data[ix] = (cgridvec->data[ix] == occval); } b_st.site = &i_emlrtRSI; nx = x->size[0]; idx = 0; ix = ii->size[0]; ii->size[0] = x->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); c_st.site = &j_emlrtRSI; if (1 > x->size[0]) { overflow = false; } else { overflow = (x->size[0] > 2147483646); } if (overflow) { d_st.site = &l_emlrtRSI; check_forloop_overflow_error(&d_st); } iy = 1; exitg5 = false; while ((!exitg5) && (iy <= nx)) { guard2 = false; if (x->data[iy - 1]) { idx++; ii->data[idx - 1] = iy; if (idx >= nx) { exitg5 = true; } else { guard2 = true; } } else { guard2 = true; } if (guard2) { iy++; } } if (idx <= x->size[0]) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (x->size[0] == 1) { if (idx == 0) { ix = ii->size[0]; ii->size[0] = 0; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof (int32_T), &emlrtRTEI); } } else { if (1 > idx) { ix = 0; } else { ix = idx; } c_st.site = &k_emlrtRSI; overflow = !(ii->size[0] != 1); b_guard3 = false; if (overflow) { overflow = false; if (ix != 1) { overflow = true; } if (overflow) { overflow = true; } else { b_guard3 = true; } } else { b_guard3 = true; } if (b_guard3) { overflow = false; } d_st.site = &m_emlrtRSI; if (!overflow) { } else { emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI, "Coder:FE:PotentialVectorVector", 0); } nx = ii->size[0]; ii->size[0] = ix; emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T), &c_emlrtRTEI); } emxInit_real_T(&b_st, &occidx, 1, &g_emlrtRTEI, true); ix = occidx->size[0]; occidx->size[0] = ii->size[0]; emxEnsureCapacity(&st, (emxArray__common *)occidx, ix, (int32_T)sizeof(real_T), &emlrtRTEI); idx = ii->size[0]; for (ix = 0; ix < idx; ix++) { occidx->data[ix] = ii->data[ix]; } st.site = &c_emlrtRSI; ix = x->size[0]; x->size[0] = cgridvec->size[0]; emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); idx = cgridvec->size[0]; for (ix = 0; ix < idx; ix++) { x->data[ix] = (cgridvec->data[ix] != occval); } b_st.site = &i_emlrtRSI; nx = x->size[0]; idx = 0; ix = ii->size[0]; ii->size[0] = x->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); c_st.site = &j_emlrtRSI; if (1 > x->size[0]) { overflow = false; } else { overflow = (x->size[0] > 2147483646); } if (overflow) { d_st.site = &l_emlrtRSI; check_forloop_overflow_error(&d_st); } iy = 1; exitg4 = false; while ((!exitg4) && (iy <= nx)) { guard1 = false; if (x->data[iy - 1]) { idx++; ii->data[idx - 1] = iy; if (idx >= nx) { exitg4 = true; } else { guard1 = true; } } else { guard1 = true; } if (guard1) { iy++; } } if (idx <= x->size[0]) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (x->size[0] == 1) { if (idx == 0) { ix = ii->size[0]; ii->size[0] = 0; emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof (int32_T), &emlrtRTEI); } } else { if (1 > idx) { ix = 0; } else { ix = idx; } c_st.site = &k_emlrtRSI; overflow = !(ii->size[0] != 1); b_guard2 = false; if (overflow) { overflow = false; if (ix != 1) { overflow = true; } if (overflow) { overflow = true; } else { b_guard2 = true; } } else { b_guard2 = true; } if (b_guard2) { overflow = false; } d_st.site = &m_emlrtRSI; if (!overflow) { } else { emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI, "Coder:FE:PotentialVectorVector", 0); } nx = ii->size[0]; ii->size[0] = ix; emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T), &c_emlrtRTEI); } emxFree_boolean_T(&x); emxInit_real_T(&b_st, &noccidx, 1, &h_emlrtRTEI, true); ix = noccidx->size[0]; noccidx->size[0] = ii->size[0]; emxEnsureCapacity(&st, (emxArray__common *)noccidx, ix, (int32_T)sizeof(real_T), &emlrtRTEI); idx = ii->size[0]; for (ix = 0; ix < idx; ix++) { noccidx->data[ix] = ii->data[ix]; } nrnocc = noccidx->size[0] - 1; /* 1 Intensify newly occupied cells */ j = 0; emxInit_real_T1(sp, &curr_col, 2, &i_emlrtRTEI, true); emxInit_real_T1(sp, &updt_col, 2, &j_emlrtRTEI, true); emxInit_real_T1(sp, &z, 2, &emlrtRTEI, true); while (j <= newlyoccidx->size[0] - 1) { /* For newly occupied cells */ ix = newlyoccidx->size[0]; if (!((j + 1 >= 1) && (j + 1 <= ix))) { emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &eb_emlrtBCI, sp); } coccidx = (int32_T)newlyoccidx->data[j] - 1; ix = context->size[0]; nx = (int32_T)newlyoccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &emlrtBCI, sp); } st.site = &d_emlrtRSI; b_st.site = &n_emlrtRSI; c_st.site = &o_emlrtRSI; ix = context->size[1]; b_guard1 = false; if (ix == 1) { b_guard1 = true; } else { ix = context->size[1]; if (ix != 1) { b_guard1 = true; } else { overflow = false; } } if (b_guard1) { overflow = true; } if (overflow) { } else { emlrtErrorWithMessageIdR2012b(&c_st, &u_emlrtRTEI, "Coder:toolbox:autoDimIncompatibility", 0); } ix = context->size[1]; if (ix > 0) { } else { emlrtErrorWithMessageIdR2012b(&c_st, &v_emlrtRTEI, "Coder:toolbox:eml_min_or_max_varDimZero", 0); } d_st.site = &p_emlrtRSI; ixstart = 1; n = context->size[1]; nx = (int32_T)newlyoccidx->data[j]; mtmp = context->data[nx - 1]; ix = context->size[1]; if (ix > 1) { if (muDoubleScalarIsNaN(mtmp)) { e_st.site = &r_emlrtRSI; ix = context->size[1]; if (2 > ix) { overflow = false; } else { ix = context->size[1]; overflow = (ix > 2147483646); } if (overflow) { f_st.site = &l_emlrtRSI; check_forloop_overflow_error(&f_st); } ix = 2; exitg3 = false; while ((!exitg3) && (ix <= n)) { ixstart = ix; if (!muDoubleScalarIsNaN(context->data[coccidx + context->size[0] * (ix - 1)])) { mtmp = context->data[coccidx + context->size[0] * (ix - 1)]; exitg3 = true; } else { ix++; } } } ix = context->size[1]; if (ixstart < ix) { e_st.site = &q_emlrtRSI; ix = context->size[1]; if (ixstart + 1 > ix) { overflow = false; } else { ix = context->size[1]; overflow = (ix > 2147483646); } if (overflow) { f_st.site = &l_emlrtRSI; check_forloop_overflow_error(&f_st); } for (ix = ixstart + 1; ix <= n; ix++) { if (context->data[coccidx + context->size[0] * (ix - 1)] > mtmp) { mtmp = context->data[coccidx + context->size[0] * (ix - 1)]; } } } } if (mtmp < minthreshold) { idx = context->size[1]; iy = context->size[0]; nx = (int32_T)newlyoccidx->data[j]; if (!((nx >= 1) && (nx <= iy))) { emlrtDynamicBoundsCheckR2012b(nx, 1, iy, &b_emlrtBCI, sp); } for (ix = 0; ix < idx; ix++) { context->data[(nx + context->size[0] * ix) - 1] = reinitval; } /* Reinitialize */ } else { idx = context->size[1]; nx = (int32_T)newlyoccidx->data[j]; ix = updt_col->size[0] * updt_col->size[1]; updt_col->size[0] = 1; updt_col->size[1] = idx; emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { updt_col->data[updt_col->size[0] * ix] = intensifyrate * context->data [(nx + context->size[0] * ix) - 1]; } /* Intensify */ st.site = &e_emlrtRSI; b_st.site = &s_emlrtRSI; c_st.site = &o_emlrtRSI; d_st.site = &t_emlrtRSI; ix = curr_col->size[0] * curr_col->size[1]; curr_col->size[0] = 1; curr_col->size[1] = updt_col->size[1]; emxEnsureCapacity(&d_st, (emxArray__common *)curr_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = updt_col->size[0] * updt_col->size[1]; for (ix = 0; ix < idx; ix++) { curr_col->data[ix] = updt_col->data[ix]; } e_st.site = &u_emlrtRSI; for (ix = 0; ix < 2; ix++) { varargin_1[ix] = updt_col->size[ix]; } ix = z->size[0] * z->size[1]; z->size[0] = 1; z->size[1] = updt_col->size[1]; emxEnsureCapacity(&e_st, (emxArray__common *)z, ix, (int32_T)sizeof(real_T), &d_emlrtRTEI); iy = updt_col->size[1]; ix = updt_col->size[0] * updt_col->size[1]; updt_col->size[0] = 1; updt_col->size[1] = varargin_1[1]; emxEnsureCapacity(&e_st, (emxArray__common *)updt_col, ix, (int32_T)sizeof (real_T), &e_emlrtRTEI); if (dimagree(updt_col, curr_col)) { } else { emlrtErrorWithMessageIdR2012b(&e_st, &x_emlrtRTEI, "MATLAB:dimagree", 0); } e_st.site = &v_emlrtRSI; if (1 > z->size[1]) { overflow = false; } else { overflow = (z->size[1] > 2147483646); } if (overflow) { f_st.site = &l_emlrtRSI; check_forloop_overflow_error(&f_st); } for (k = 0; k + 1 <= iy; k++) { updt_col->data[k] = muDoubleScalarMin(curr_col->data[k], maxthreshold); } /* Max-thesholding */ ix = context->size[0]; nx = (int32_T)newlyoccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &c_emlrtBCI, sp); } idx = context->size[1]; ix = ii->size[0]; ii->size[0] = idx; emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { ii->data[ix] = ix; } iv3[0] = 1; iv3[1] = ii->size[0]; emlrtSubAssignSizeCheckR2012b(iv3, 2, *(int32_T (*)[2])updt_col->size, 2, &b_emlrtECI, sp); nx = (int32_T)newlyoccidx->data[j]; idx = updt_col->size[1]; for (ix = 0; ix < idx; ix++) { context->data[(nx + context->size[0] * ii->data[ix]) - 1] = updt_col->data[updt_col->size[0] * ix]; } } j++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_real_T(&z); /* 2 Attenuate unoccupied cells */ if (do_attenuation_first == 1.0) { j = 0; while (j <= nrnocc) { /* For unoccupied cells */ ix = noccidx->size[0]; nx = j + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &d_emlrtBCI, sp); } ix = context->size[0]; nx = (int32_T)noccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &e_emlrtBCI, sp); } idx = context->size[1]; iy = (int32_T)noccidx->data[j]; ix = updt_col->size[0] * updt_col->size[1]; updt_col->size[0] = 1; updt_col->size[1] = idx; emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { updt_col->data[updt_col->size[0] * ix] = context->data[(iy + context->size[0] * ix) - 1] * nocc_attenuaterate; } /* Attenuate */ ix = context->size[0]; nx = (int32_T)noccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &f_emlrtBCI, sp); } idx = context->size[1]; ix = ii->size[0]; ii->size[0] = idx; emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { ii->data[ix] = ix; } iv4[0] = 1; iv4[1] = ii->size[0]; emlrtSubAssignSizeCheckR2012b(iv4, 2, *(int32_T (*)[2])updt_col->size, 2, &c_emlrtECI, sp); iy = (int32_T)noccidx->data[j]; idx = updt_col->size[1]; for (ix = 0; ix < idx; ix++) { context->data[(iy + context->size[0] * ii->data[ix]) - 1] = updt_col->data[updt_col->size[0] * ix]; } j++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } } /* 4 Propagation */ j = 0; while (j <= occidx->size[0] - 1) { /* For occupied cells */ ix = occidx->size[0]; if (!((j + 1 >= 1) && (j + 1 <= ix))) { emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &bb_emlrtBCI, sp); } idx = context->size[1]; ix = context->size[0]; iy = (int32_T)occidx->data[j]; if (!((iy >= 1) && (iy <= ix))) { emlrtDynamicBoundsCheckR2012b(iy, 1, ix, &g_emlrtBCI, sp); } ix = curr_col->size[0] * curr_col->size[1]; curr_col->size[0] = 1; curr_col->size[1] = idx; emxEnsureCapacity(sp, (emxArray__common *)curr_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { curr_col->data[curr_col->size[0] * ix] = context->data[(iy + context-> size[0] * ix) - 1]; } ix = nei_idx->size[0]; nx = (int32_T)occidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &h_emlrtBCI, sp); } ix = nei_weight->size[0]; nx = (int32_T)occidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &i_emlrtBCI, sp); } emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei_filter_n, mxDOUBLE_CLASS, (int32_T)nei_filter_n, &p_emlrtRTEI, sp); k = 0; while (k <= (int32_T)nei_filter_n - 1) { /* For all neighbor cells */ ix = curr_col->size[1]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &j_emlrtBCI, sp); } ix = nei_idx->size[1]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &k_emlrtBCI, sp); } ix = nei_weight->size[1]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &l_emlrtBCI, sp); } iy = (int32_T)occidx->data[j]; if (nei_idx->data[(iy + nei_idx->size[0] * k) - 1] != 0.0) { /* If properly connected, propagate */ iy = (int32_T)occidx->data[j]; d0 = nei_idx->data[(iy + nei_idx->size[0] * k) - 1]; if (d0 != (int32_T)muDoubleScalarFloor(d0)) { emlrtIntegerCheckR2012b(d0, &emlrtDCI, sp); } ix = context->size[0]; nx = (int32_T)d0; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &m_emlrtBCI, sp); } ix = context->size[1]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &n_emlrtBCI, sp); } /* Maximum value thresholding */ iy = (int32_T)occidx->data[j]; idx = (int32_T)occidx->data[j]; nx = (int32_T)occidx->data[j]; ix = context->size[0]; nx = (int32_T)nei_idx->data[(nx + nei_idx->size[0] * k) - 1]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &cb_emlrtBCI, sp); } ix = context->size[1]; if (!((k + 1 >= 1) && (k + 1 <= ix))) { emlrtDynamicBoundsCheckR2012b(k + 1, 1, ix, &db_emlrtBCI, sp); } context->data[(nx + context->size[0] * k) - 1] = muDoubleScalarMax (context->data[((int32_T)nei_idx->data[(iy + nei_idx->size[0] * k) - 1] + context->size[0] * k) - 1], muDoubleScalarMin (nei_weight->data[(idx + nei_weight->size[0] * k) - 1] * curr_col->data[k], maxthreshold)); /* Make sure current context propagation does not weaken the flow information */ } k++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } j++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_real_T(&occidx); emxInit_real_T1(sp, &tempcontext, 2, &k_emlrtRTEI, true); /* 5 Uncertainty in acceleration */ ix = tempcontext->size[0] * tempcontext->size[1]; tempcontext->size[0] = context->size[0]; tempcontext->size[1] = context->size[1]; emxEnsureCapacity(sp, (emxArray__common *)tempcontext, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = context->size[0] * context->size[1]; for (ix = 0; ix < idx; ix++) { tempcontext->data[ix] = context->data[ix]; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei_filter_n, mxDOUBLE_CLASS, (int32_T) nei_filter_n, &q_emlrtRTEI, sp); j = 0; emxInit_real_T1(sp, &b_nei4u_weight, 2, &emlrtRTEI, true); while (j <= (int32_T)nei_filter_n - 1) { /* For all context level */ k = 0; while (k <= nei_idx->size[0] - 1) { /* For all cells */ sumval = 0.0; emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei4u_filter_n, mxDOUBLE_CLASS, (int32_T)nei4u_filter_n, &r_emlrtRTEI, sp); m = 0; while (m <= (int32_T)nei4u_filter_n - 1) { ix = nei4u_idx->size[0]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &o_emlrtBCI, sp); } ix = nei4u_idx->size[1]; nx = m + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &p_emlrtBCI, sp); } ix = nei4u_weight->size[0]; nx = k + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &q_emlrtBCI, sp); } ix = nei4u_weight->size[1]; nx = m + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &r_emlrtBCI, sp); } idx = nei4u_weight->size[1]; ix = nei4u_weight->size[0]; nx = 1 + k; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &s_emlrtBCI, sp); } ix = b_nei4u_weight->size[0] * b_nei4u_weight->size[1]; b_nei4u_weight->size[0] = 1; b_nei4u_weight->size[1] = idx; emxEnsureCapacity(sp, (emxArray__common *)b_nei4u_weight, ix, (int32_T) sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { b_nei4u_weight->data[b_nei4u_weight->size[0] * ix] = nei4u_weight->data[(nx + nei4u_weight->size[0] * ix) - 1]; } st.site = &f_emlrtRSI; mtmp = sum(&st, b_nei4u_weight); if (nei4u_idx->data[k + nei4u_idx->size[0] * m] != 0.0) { d0 = nei4u_idx->data[k + nei4u_idx->size[0] * m]; if (d0 != (int32_T)muDoubleScalarFloor(d0)) { emlrtIntegerCheckR2012b(d0, &b_emlrtDCI, sp); } ix = context->size[0]; nx = (int32_T)d0; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &t_emlrtBCI, sp); } ix = context->size[1]; nx = j + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &u_emlrtBCI, sp); } sumval += nei4u_weight->data[k + nei4u_weight->size[0] * m] / mtmp * context->data[((int32_T)nei4u_idx->data[k + nei4u_idx->size[0] * m] + context->size[0] * j) - 1]; } m++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } ix = tempcontext->size[0]; nx = 1 + k; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &y_emlrtBCI, sp); } ix = tempcontext->size[1]; if (!((j + 1 >= 1) && (j + 1 <= ix))) { emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &ab_emlrtBCI, sp); } tempcontext->data[(nx + tempcontext->size[0] * j) - 1] = sumval; k++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } j++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_real_T(&b_nei4u_weight); ix = context->size[0] * context->size[1]; context->size[0] = tempcontext->size[0]; context->size[1] = tempcontext->size[1]; emxEnsureCapacity(sp, (emxArray__common *)context, ix, (int32_T)sizeof(real_T), &emlrtRTEI); idx = tempcontext->size[1]; for (ix = 0; ix < idx; ix++) { iy = tempcontext->size[0]; for (nx = 0; nx < iy; nx++) { context->data[nx + context->size[0] * ix] = tempcontext->data[nx + tempcontext->size[0] * ix]; } } if (do_attenuation_first == 0.0) { /* 2 Attenuate unoccupied cells */ j = 0; while (j <= nrnocc) { /* For unoccupied cells, attenuate */ ix = noccidx->size[0]; nx = j + 1; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &v_emlrtBCI, sp); } ix = context->size[0]; nx = (int32_T)noccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &w_emlrtBCI, sp); } idx = context->size[1]; iy = (int32_T)noccidx->data[j]; ix = updt_col->size[0] * updt_col->size[1]; updt_col->size[0] = 1; updt_col->size[1] = idx; emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { updt_col->data[updt_col->size[0] * ix] = context->data[(iy + context->size[0] * ix) - 1] * nocc_attenuaterate; } ix = context->size[0]; nx = (int32_T)noccidx->data[j]; if (!((nx >= 1) && (nx <= ix))) { emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &x_emlrtBCI, sp); } idx = context->size[1]; ix = ii->size[0]; ii->size[0] = idx; emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < idx; ix++) { ii->data[ix] = ix; } iv5[0] = 1; iv5[1] = ii->size[0]; emlrtSubAssignSizeCheckR2012b(iv5, 2, *(int32_T (*)[2])updt_col->size, 2, &d_emlrtECI, sp); iy = (int32_T)noccidx->data[j]; idx = updt_col->size[1]; for (ix = 0; ix < idx; ix++) { context->data[(iy + context->size[0] * ii->data[ix]) - 1] = updt_col->data[updt_col->size[0] * ix]; } j++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } } emxFree_int32_T(&ii); emxFree_real_T(&updt_col); emxFree_real_T(&noccidx); /* 6 Prediction */ st.site = &g_emlrtRSI; ix = tempcontext->size[0] * tempcontext->size[1]; tempcontext->size[0] = context->size[1]; tempcontext->size[1] = context->size[0]; emxEnsureCapacity(&st, (emxArray__common *)tempcontext, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = context->size[0]; for (ix = 0; ix < idx; ix++) { iy = context->size[1]; for (nx = 0; nx < iy; nx++) { tempcontext->data[nx + tempcontext->size[0] * ix] = context->data[ix + context->size[0] * nx]; } } b_st.site = &n_emlrtRSI; c_st.site = &o_emlrtRSI; if (((tempcontext->size[0] == 1) && (tempcontext->size[1] == 1)) || (tempcontext->size[0] != 1)) { overflow = true; } else { overflow = false; } if (overflow) { } else { emlrtErrorWithMessageIdR2012b(&c_st, &u_emlrtRTEI, "Coder:toolbox:autoDimIncompatibility", 0); } if (tempcontext->size[0] > 0) { } else { emlrtErrorWithMessageIdR2012b(&c_st, &v_emlrtRTEI, "Coder:toolbox:eml_min_or_max_varDimZero", 0); } ix = curr_col->size[0] * curr_col->size[1]; curr_col->size[0] = 1; curr_col->size[1] = tempcontext->size[1]; emxEnsureCapacity(&c_st, (emxArray__common *)curr_col, ix, (int32_T)sizeof (real_T), &emlrtRTEI); n = tempcontext->size[0]; ix = 0; iy = -1; d_st.site = &ab_emlrtRSI; if (1 > tempcontext->size[1]) { overflow = false; } else { overflow = (tempcontext->size[1] > 2147483646); } if (overflow) { e_st.site = &l_emlrtRSI; check_forloop_overflow_error(&e_st); } for (nx = 1; nx <= tempcontext->size[1]; nx++) { d_st.site = &bb_emlrtRSI; ixstart = ix; idx = ix + n; mtmp = tempcontext->data[ix]; if (n > 1) { if (muDoubleScalarIsNaN(tempcontext->data[ix])) { e_st.site = &r_emlrtRSI; if (ix + 2 > idx) { b_ix = false; } else { b_ix = (idx > 2147483646); } if (b_ix) { f_st.site = &l_emlrtRSI; check_forloop_overflow_error(&f_st); } k = ix + 1; exitg2 = false; while ((!exitg2) && (k + 1 <= idx)) { ixstart = k; if (!muDoubleScalarIsNaN(tempcontext->data[k])) { mtmp = tempcontext->data[k]; exitg2 = true; } else { k++; } } } if (ixstart + 1 < idx) { e_st.site = &q_emlrtRSI; if (ixstart + 2 > idx) { b_ixstart = false; } else { b_ixstart = (idx > 2147483646); } if (b_ixstart) { f_st.site = &l_emlrtRSI; check_forloop_overflow_error(&f_st); } for (k = ixstart + 1; k + 1 <= idx; k++) { if (tempcontext->data[k] > mtmp) { mtmp = tempcontext->data[k]; } } } } iy++; curr_col->data[iy] = mtmp; ix += n; } emxFree_real_T(&tempcontext); ix = maxvec->size[0]; maxvec->size[0] = curr_col->size[1]; emxEnsureCapacity(sp, (emxArray__common *)maxvec, ix, (int32_T)sizeof(real_T), &emlrtRTEI); idx = curr_col->size[1]; for (ix = 0; ix < idx; ix++) { maxvec->data[ix] = curr_col->data[curr_col->size[0] * ix]; } emxFree_real_T(&curr_col); st.site = &h_emlrtRSI; /* sigm_a <= if we increase the value, than the sigm function gets peaky! */ b_st.site = &cb_emlrtRSI; ix = predvec->size[0]; predvec->size[0] = maxvec->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = maxvec->size[0]; for (ix = 0; ix < idx; ix++) { predvec->data[ix] = -sigm_coef * maxvec->data[ix]; } c_st.site = &cb_emlrtRSI; b_exp(&c_st, predvec); ix = predvec->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = predvec->size[0]; for (ix = 0; ix < idx; ix++) { predvec->data[ix] = 1.0 - predvec->data[ix]; } ix = newlyoccidx->size[0]; newlyoccidx->size[0] = maxvec->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = maxvec->size[0]; for (ix = 0; ix < idx; ix++) { newlyoccidx->data[ix] = -sigm_coef * maxvec->data[ix]; } c_st.site = &cb_emlrtRSI; b_exp(&c_st, newlyoccidx); ix = newlyoccidx->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = newlyoccidx->size[0]; for (ix = 0; ix < idx; ix++) { newlyoccidx->data[ix]++; } varargin_1[0] = predvec->size[0]; varargin_1[1] = 1; varargin_2[0] = newlyoccidx->size[0]; varargin_2[1] = 1; overflow = false; p = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (!(varargin_1[k] == varargin_2[k])) { p = false; exitg1 = true; } else { k++; } } if (!p) { } else { overflow = true; } if (overflow) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &w_emlrtRTEI, "MATLAB:dimagree", 0); } ix = predvec->size[0]; emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = predvec->size[0]; for (ix = 0; ix < idx; ix++) { predvec->data[ix] /= newlyoccidx->data[ix]; } emxFree_real_T(&newlyoccidx); /* 7 Save previous grid */ ix = cgridvecprev->size[0]; cgridvecprev->size[0] = cgridvec->size[0]; emxEnsureCapacity(sp, (emxArray__common *)cgridvecprev, ix, (int32_T)sizeof (real_T), &emlrtRTEI); idx = cgridvec->size[0]; for (ix = 0; ix < idx; ix++) { cgridvecprev->data[ix] = cgridvec->data[ix]; } emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
/* Function Definitions */ void CalculateABBStarD(const emlrtStack *sp, real_T N, const emxArray_real_T *t, const emxArray_real_T *gridT, const emxArray_real_T *x, const emxArray_real_T * f, emxArray_real_T *A, emxArray_real_T *B, emxArray_real_T *Bstar, emxArray_real_T *D) { int32_T i4; real_T d1; real_T d2; int32_T loop_ub; int32_T i; emxArray_real_T *a; int32_T j; int32_T deltaij; int32_T b_A; real_T d3; real_T d4; real_T b1j0i; real_T b1j1i; int32_T i5; int32_T i6; int32_T i7; int32_T i8; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); /* Calculate A and B, B*, and D */ /* N is the number of time points */ /* grid T is the time points grid on which the solution is calculated */ /* f is the multiplicative function for the source f(x,t)*r(t), size [N, */ /* N0], with N0 the number of space points */ i4 = A->size[0] * A->size[1]; d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &j_emlrtDCI, sp); A->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &i_emlrtDCI, sp); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &l_emlrtDCI, sp); A->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &k_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)A, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &j_emlrtDCI, sp); d2 = 2.0 * N; d2 = emlrtNonNegativeCheckFastR2012b(d2, &l_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &i_emlrtDCI, sp) * (int32_T) emlrtIntegerCheckFastR2012b(d2, &k_emlrtDCI, sp); for (i4 = 0; i4 < loop_ub; i4++) { A->data[i4] = 0.0; } i4 = B->size[0] * B->size[1]; d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &n_emlrtDCI, sp); B->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &m_emlrtDCI, sp); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &p_emlrtDCI, sp); B->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &o_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)B, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &n_emlrtDCI, sp); d2 = 2.0 * N; d2 = emlrtNonNegativeCheckFastR2012b(d2, &p_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &m_emlrtDCI, sp) * (int32_T) emlrtIntegerCheckFastR2012b(d2, &o_emlrtDCI, sp); for (i4 = 0; i4 < loop_ub; i4++) { B->data[i4] = 0.0; } i4 = Bstar->size[0] * Bstar->size[1]; d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &r_emlrtDCI, sp); Bstar->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &q_emlrtDCI, sp); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &t_emlrtDCI, sp); Bstar->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &s_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)Bstar, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &r_emlrtDCI, sp); d2 = 2.0 * N; d2 = emlrtNonNegativeCheckFastR2012b(d2, &t_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &q_emlrtDCI, sp) * (int32_T) emlrtIntegerCheckFastR2012b(d2, &s_emlrtDCI, sp); for (i4 = 0; i4 < loop_ub; i4++) { Bstar->data[i4] = 0.0; } i4 = D->size[0] * D->size[1]; d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &v_emlrtDCI, sp); D->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &u_emlrtDCI, sp); d1 = emlrtNonNegativeCheckFastR2012b(N, &x_emlrtDCI, sp); D->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &w_emlrtDCI, sp); emxEnsureCapacity(sp, (emxArray__common *)D, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); d1 = 2.0 * N; d1 = emlrtNonNegativeCheckFastR2012b(d1, &v_emlrtDCI, sp); d2 = emlrtNonNegativeCheckFastR2012b(N, &x_emlrtDCI, sp); loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &u_emlrtDCI, sp) * (int32_T) emlrtIntegerCheckFastR2012b(d2, &w_emlrtDCI, sp); for (i4 = 0; i4 < loop_ub; i4++) { D->data[i4] = 0.0; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N, &dc_emlrtRTEI, sp); i = 0; emxInit_real_T(sp, &a, 2, &c_emlrtRTEI, true); while (i <= (int32_T)N - 1) { /* time */ emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N, &cc_emlrtRTEI, sp); j = 0; while (j <= (int32_T)N - 1) { /* time */ deltaij = (1.0 + (real_T)i == 1.0 + (real_T)j); d1 = 2.0 * (1.0 + (real_T)i); loop_ub = A->size[0]; d2 = 2.0 * (1.0 + (real_T)j); b_A = A->size[1]; i4 = t->size[1]; st.site = &n_emlrtRSI; d3 = Acoeff(&st, 0.0, 1.0 + (real_T)j, 0.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &qb_emlrtBCI, sp) - 1], gridT); i4 = t->size[1]; st.site = &n_emlrtRSI; d4 = Acoeff(&st, 1.0, 1.0 + (real_T)j, 0.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &rb_emlrtBCI, sp) - 1], gridT); i4 = t->size[1]; st.site = &o_emlrtRSI; b1j0i = Acoeff(&st, 0.0, 1.0 + (real_T)j, 1.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &sb_emlrtBCI, sp) - 1], gridT); i4 = t->size[1]; st.site = &o_emlrtRSI; b1j1i = Acoeff(&st, 1.0, 1.0 + (real_T)j, 1.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &tb_emlrtBCI, sp) - 1], gridT); i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)(d2 + -1.0); A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI, sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &vb_emlrtBCI, sp) - 1)) - 1] = d3; i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)d2; A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI, sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &vb_emlrtBCI, sp) - 1)) - 1] = d4; i4 = (int32_T)d1; i5 = (int32_T)(d2 + -1.0); A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI, sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &vb_emlrtBCI, sp) - 1)) - 1] = b1j0i; i4 = (int32_T)d1; i5 = (int32_T)d2; A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI, sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &vb_emlrtBCI, sp) - 1)) - 1] = b1j1i; /* temp terms */ i4 = t->size[1]; st.site = &p_emlrtRSI; b1j0i = Bcoeff(&st, 1.0, 1.0 + (real_T)j, 0.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &wb_emlrtBCI, sp) - 1], gridT); i4 = t->size[1]; st.site = &q_emlrtRSI; b1j1i = Bcoeff(&st, 1.0, 1.0 + (real_T)j, 1.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &xb_emlrtBCI, sp) - 1], gridT); d1 = 2.0 * (1.0 + (real_T)i); loop_ub = B->size[0]; d2 = 2.0 * (1.0 + (real_T)j); b_A = B->size[1]; i4 = t->size[1]; st.site = &r_emlrtRSI; d3 = Bcoeff(&st, 0.0, 1.0 + (real_T)j, 0.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &yb_emlrtBCI, sp) - 1], gridT); i4 = t->size[1]; st.site = &s_emlrtRSI; d4 = Bcoeff(&st, 0.0, 1.0 + (real_T)j, 1.0, t-> data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4, &ac_emlrtBCI, sp) - 1], gridT); i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)(d2 + -1.0); B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI, sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &cc_emlrtBCI, sp) - 1)) - 1] = d3 + 0.5 * (real_T)deltaij; i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)d2; B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI, sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &cc_emlrtBCI, sp) - 1)) - 1] = b1j0i; i4 = (int32_T)d1; i5 = (int32_T)(d2 + -1.0); B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI, sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &cc_emlrtBCI, sp) - 1)) - 1] = d4; i4 = (int32_T)d1; i5 = (int32_T)d2; B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI, sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A, &cc_emlrtBCI, sp) - 1)) - 1] = b1j1i + 0.5 * (real_T)deltaij; d1 = 2.0 * (1.0 + (real_T)i); loop_ub = Bstar->size[0]; d2 = 2.0 * (1.0 + (real_T)j); b_A = Bstar->size[1]; i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)(d2 + -1.0); Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b (i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = b1j0i; i4 = (int32_T)(d1 + -1.0); i5 = (int32_T)d2; Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b (i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = -b1j0i; i4 = (int32_T)d1; i5 = (int32_T)(d2 + -1.0); Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b (i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = b1j1i + (real_T)deltaij / 2.0; i4 = (int32_T)d1; i5 = (int32_T)d2; Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b (i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = -b1j1i - 0.5 * (real_T) deltaij; st.site = &t_emlrtRSI; i4 = t->size[1]; i5 = i + 1; emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &pb_emlrtBCI, &st); i4 = f->size[0]; i5 = i + 1; emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &ob_emlrtBCI, &st); /* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */ /* integration rule */ /* the spatial integration of all points y at time t_j */ i4 = a->size[0] * a->size[1]; a->size[0] = 1; emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); loop_ub = x->size[1]; i4 = a->size[0] * a->size[1]; a->size[1] = loop_ub; emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); loop_ub = x->size[1]; for (i4 = 0; i4 < loop_ub; i4++) { a->data[i4] = 0.0; } b1j0i = 0.0; loop_ub = x->size[1]; emlrtDynamicBoundsCheckFastR2012b(1, 1, loop_ub, &jb_emlrtBCI, &st); i4 = x->size[1]; emlrtDynamicBoundsCheckFastR2012b(1, 1, i4, &kb_emlrtBCI, &st); b_st.site = &v_emlrtRSI; a->data[0] = Acoeff(&b_st, x->data[0], 1.0 + (real_T)j, 0.0, t->data[i], gridT); /* y = 0:1/(numel(y)-2):1; */ i4 = f->size[1]; loop_ub = 2; while (loop_ub - 2 <= i4 - 2) { i5 = a->size[1]; b_A = x->size[1]; b_st.site = &w_emlrtRSI; a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &gc_emlrtBCI, &st) - 1] = Acoeff(&b_st, x->data[emlrtDynamicBoundsCheckFastR2012b (loop_ub, 1, b_A, &hc_emlrtBCI, &st) - 1], 1.0 + (real_T)j, 0.0, t->data[i], gridT); i5 = f->size[1]; emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ib_emlrtBCI, &st); i5 = f->size[1]; b_A = loop_ub - 1; emlrtDynamicBoundsCheckFastR2012b(b_A, 1, i5, &hb_emlrtBCI, &st); i5 = a->size[1]; b_A = a->size[1]; deltaij = loop_ub - 1; i6 = x->size[1]; i7 = x->size[1]; i8 = loop_ub - 1; b1j0i += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ic_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 1)] + a->data[emlrtDynamicBoundsCheckFastR2012b(deltaij, 1, b_A, &jc_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 2)]) * (x->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i6, &kc_emlrtBCI, &st) - 1] - x-> data[emlrtDynamicBoundsCheckFastR2012b(i8, 1, i7, &lc_emlrtBCI, &st) - 1]); loop_ub++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &st); } st.site = &u_emlrtRSI; i4 = t->size[1]; i5 = i + 1; emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &nb_emlrtBCI, &st); i4 = f->size[0]; i5 = i + 1; emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &mb_emlrtBCI, &st); /* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */ /* integration rule */ /* the spatial integration of all points y at time t_j */ i4 = a->size[0] * a->size[1]; a->size[0] = 1; emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); loop_ub = x->size[1]; i4 = a->size[0] * a->size[1]; a->size[1] = loop_ub; emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T), &b_emlrtRTEI); loop_ub = x->size[1]; for (i4 = 0; i4 < loop_ub; i4++) { a->data[i4] = 0.0; } b1j1i = 0.0; loop_ub = x->size[1]; emlrtDynamicBoundsCheckFastR2012b(1, 1, loop_ub, &jb_emlrtBCI, &st); i4 = x->size[1]; emlrtDynamicBoundsCheckFastR2012b(1, 1, i4, &kb_emlrtBCI, &st); b_st.site = &v_emlrtRSI; a->data[0] = Acoeff(&b_st, x->data[0], 1.0 + (real_T)j, 1.0, t->data[i], gridT); /* y = 0:1/(numel(y)-2):1; */ i4 = f->size[1]; loop_ub = 2; while (loop_ub - 2 <= i4 - 2) { i5 = a->size[1]; b_A = x->size[1]; b_st.site = &w_emlrtRSI; a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &gc_emlrtBCI, &st) - 1] = Acoeff(&b_st, x->data[emlrtDynamicBoundsCheckFastR2012b (loop_ub, 1, b_A, &hc_emlrtBCI, &st) - 1], 1.0 + (real_T)j, 1.0, t->data[i], gridT); i5 = f->size[1]; emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ib_emlrtBCI, &st); i5 = f->size[1]; b_A = loop_ub - 1; emlrtDynamicBoundsCheckFastR2012b(b_A, 1, i5, &hb_emlrtBCI, &st); i5 = a->size[1]; b_A = a->size[1]; deltaij = loop_ub - 1; i6 = x->size[1]; i7 = x->size[1]; i8 = loop_ub - 1; b1j1i += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ic_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 1)] + a->data[emlrtDynamicBoundsCheckFastR2012b(deltaij, 1, b_A, &jc_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 2)]) * (x->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i6, &kc_emlrtBCI, &st) - 1] - x-> data[emlrtDynamicBoundsCheckFastR2012b(i8, 1, i7, &lc_emlrtBCI, &st) - 1]); loop_ub++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &st); } d1 = 2.0 * (1.0 + (real_T)i); b_A = D->size[0]; loop_ub = D->size[1]; emlrtDynamicBoundsCheckFastR2012b(j + 1, 1, loop_ub, &lb_emlrtBCI, sp); i4 = (int32_T)(d1 + -1.0); D->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, b_A, &fc_emlrtBCI, sp) + D->size[0] * j) - 1] = b1j0i; i4 = (int32_T)d1; D->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, b_A, &fc_emlrtBCI, sp) + D->size[0] * j) - 1] = b1j1i; j++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } emxFree_real_T(&a); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }