📄 tau_damp.c
字号:
/*
* MATLAB Compiler: 2.1
* Date: Wed Oct 17 16:15:00 2001
* Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
* "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
* "array_indexing:on" "-O" "optimize_conditionals:on" "-h" "-x" "-W" "mex"
* "-L" "C" "-t" "-T" "link:mexlibrary" "libmatlbmx.mlib" "vxdot.m"
*/
#include "tau_damp.h"
#include "a2clcd.h"
#include "a2clcdxc.h"
#include "libmatlbm.h"
#include "vp.h"
static mxChar _array1_[134] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 't', 'a', 'u', '_', 'd',
'a', 'm', 'p', ' ', 'L', 'i', 'n', 'e', ':',
' ', '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
't', 'a', 'u', '_', 'd', 'a', 'm', 'p', '"',
' ', 'w', 'a', 's', ' ', 'c', 'a', 'l', 'l',
'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'm',
'o', 'r', 'e', ' ', 't', 'h', 'a', 'n', ' ',
't', 'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a',
'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e',
'r', ' ', 'o', 'f', ' ', 'o', 'u', 't', 'p',
'u', 't', 's', ' ', '(', '1', ')', '.' };
static mxArray * _mxarray0_;
static mxChar _array3_[133] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 't', 'a', 'u', '_', 'd',
'a', 'm', 'p', ' ', 'L', 'i', 'n', 'e', ':',
' ', '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
't', 'a', 'u', '_', 'd', 'a', 'm', 'p', '"',
' ', 'w', 'a', 's', ' ', 'c', 'a', 'l', 'l',
'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'm',
'o', 'r', 'e', ' ', 't', 'h', 'a', 'n', ' ',
't', 'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a',
'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e',
'r', ' ', 'o', 'f', ' ', 'i', 'n', 'p', 'u',
't', 's', ' ', '(', '3', ')', '.' };
static mxArray * _mxarray2_;
static mxArray * _mxarray4_;
static mxArray * _mxarray5_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;
static mxArray * _mxarray9_;
static double _array11_[3] = { 1.0, 0.0, 0.0 };
static mxArray * _mxarray10_;
static mxArray * _mxarray12_;
static mxArray * _mxarray13_;
static double _array15_[3] = { 0.0, 0.0, 1.0 };
static mxArray * _mxarray14_;
static double _array17_[3] = { 0.0, 1.0, 0.0 };
static mxArray * _mxarray16_;
static mxArray * _mxarray18_;
static double _array20_[3] = { 0.0, -1.0, 0.0 };
static mxArray * _mxarray19_;
void InitializeModule_tau_damp(void) {
_mxarray0_ = mclInitializeString(134, _array1_);
_mxarray2_ = mclInitializeString(133, _array3_);
_mxarray4_ = mclInitializeDouble(.7853981633974483);
_mxarray5_ = mclInitializeDouble(2.0);
_mxarray6_ = mclInitializeDouble(1.0);
_mxarray7_ = mclInitializeDouble(3.0);
_mxarray8_ = mclInitializeDouble(4.0);
_mxarray9_ = mclInitializeDouble(6.0);
_mxarray10_ = mclInitializeDoubleVector(3, 1, _array11_);
_mxarray12_ = mclInitializeDouble(0.0);
_mxarray13_ = mclInitializeDouble(1e-12);
_mxarray14_ = mclInitializeDoubleVector(3, 1, _array15_);
_mxarray16_ = mclInitializeDoubleVector(1, 3, _array17_);
_mxarray18_ = mclInitializeDouble(-.5);
_mxarray19_ = mclInitializeDoubleVector(1, 3, _array20_);
}
void TerminateModule_tau_damp(void) {
mxDestroyArray(_mxarray19_);
mxDestroyArray(_mxarray18_);
mxDestroyArray(_mxarray16_);
mxDestroyArray(_mxarray14_);
mxDestroyArray(_mxarray13_);
mxDestroyArray(_mxarray12_);
mxDestroyArray(_mxarray10_);
mxDestroyArray(_mxarray9_);
mxDestroyArray(_mxarray8_);
mxDestroyArray(_mxarray7_);
mxDestroyArray(_mxarray6_);
mxDestroyArray(_mxarray5_);
mxDestroyArray(_mxarray4_);
mxDestroyArray(_mxarray2_);
mxDestroyArray(_mxarray0_);
}
static mxArray * Mtau_damp(int nargout_,
mxArray * veh,
mxArray * vr,
mxArray * de);
_mexLocalFunctionTable _local_function_table_tau_damp
= { 0, (mexFunctionTableEntry *)NULL };
/*
* The function "mlfTau_damp" contains the normal interface for the "tau_damp"
* M-function from file "D:\RTW\new3\tau_damp.m" (lines 1-307). This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
mxArray * mlfTau_damp(mxArray * veh, mxArray * vr, mxArray * de) {
int nargout = 1;
mxArray * td = mclGetUninitializedArray();
mlfEnterNewContext(0, 3, veh, vr, de);
td = Mtau_damp(nargout, veh, vr, de);
mlfRestorePreviousContext(0, 3, veh, vr, de);
return mlfReturnValue(td);
}
/*
* The function "mlxTau_damp" contains the feval interface for the "tau_damp"
* M-function from file "D:\RTW\new3\tau_damp.m" (lines 1-307). The feval
* function calls the implementation version of tau_damp through this function.
* This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
void mlxTau_damp(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
mxArray * mprhs[3];
mxArray * mplhs[1];
int i;
if (nlhs > 1) {
mlfError(_mxarray0_);
}
if (nrhs > 3) {
mlfError(_mxarray2_);
}
for (i = 0; i < 1; ++i) {
mplhs[i] = mclGetUninitializedArray();
}
for (i = 0; i < 3 && i < nrhs; ++i) {
mprhs[i] = prhs[i];
}
for (; i < 3; ++i) {
mprhs[i] = NULL;
}
mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
mplhs[0] = Mtau_damp(nlhs, mprhs[0], mprhs[1], mprhs[2]);
mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
plhs[0] = mplhs[0];
}
/*
* The function "Mtau_damp" is the implementation version of the "tau_damp"
* M-function from file "D:\RTW\new3\tau_damp.m" (lines 1-307). It contains the
* actual compiled code for that M-function. It is a static function and must
* only be called from one of the interface functions, appearing below.
*/
/*
* function td=tau_damp(veh,vr,de)
*/
static mxArray * Mtau_damp(int nargout_,
mxArray * veh,
mxArray * vr,
mxArray * de) {
mexLocalFunctionTable save_local_function_table_ = mclSetCurrentLocalFunctionTable(
&_local_function_table_tau_damp);
mxArray * td = mclGetUninitializedArray();
mxArray * t8 = mclGetUninitializedArray();
mxArray * M_8bb = mclGetUninitializedArray();
mxArray * F_8b = mclGetUninitializedArray();
mxArray * F_8w = mclGetUninitializedArray();
mxArray * R_w8 = mclGetUninitializedArray();
mxArray * a8 = mclGetUninitializedArray();
mxArray * v_8c8 = mclGetUninitializedArray();
mxArray * v_8cb = mclGetUninitializedArray();
mxArray * R_8b = mclGetUninitializedArray();
mxArray * t7 = mclGetUninitializedArray();
mxArray * M_7bb = mclGetUninitializedArray();
mxArray * F_7b = mclGetUninitializedArray();
mxArray * F_7w = mclGetUninitializedArray();
mxArray * R_w7 = mclGetUninitializedArray();
mxArray * a7 = mclGetUninitializedArray();
mxArray * v_7c7 = mclGetUninitializedArray();
mxArray * v_7cb = mclGetUninitializedArray();
mxArray * R_7b = mclGetUninitializedArray();
mxArray * t6 = mclGetUninitializedArray();
mxArray * M_6bb = mclGetUninitializedArray();
mxArray * F_6b = mclGetUninitializedArray();
mxArray * F_6w = mclGetUninitializedArray();
mxArray * R_w6 = mclGetUninitializedArray();
mxArray * a6 = mclGetUninitializedArray();
mxArray * v_6c6 = mclGetUninitializedArray();
mxArray * v_6cb = mclGetUninitializedArray();
mxArray * R_6b = mclGetUninitializedArray();
mxArray * t5 = mclGetUninitializedArray();
mxArray * M_5bb = mclGetUninitializedArray();
mxArray * F_5b = mclGetUninitializedArray();
mxArray * F_5w = mclGetUninitializedArray();
mxArray * R_w5 = mclGetUninitializedArray();
mxArray * a5 = mclGetUninitializedArray();
mxArray * v_5c5 = mclGetUninitializedArray();
mxArray * v_5cb = mclGetUninitializedArray();
mxArray * R_5b = mclGetUninitializedArray();
mxArray * t4 = mclGetUninitializedArray();
mxArray * M_4bb = mclGetUninitializedArray();
mxArray * F_4b = mclGetUninitializedArray();
mxArray * F_4w = mclGetUninitializedArray();
mxArray * R_w4 = mclGetUninitializedArray();
mxArray * a4 = mclGetUninitializedArray();
mxArray * v_4c4 = mclGetUninitializedArray();
mxArray * v_4cb = mclGetUninitializedArray();
mxArray * R_4b = mclGetUninitializedArray();
mxArray * t3 = mclGetUninitializedArray();
mxArray * M_3bb = mclGetUninitializedArray();
mxArray * F_3b = mclGetUninitializedArray();
mxArray * F_3w = mclGetUninitializedArray();
mxArray * R_w3 = mclGetUninitializedArray();
mxArray * a3 = mclGetUninitializedArray();
mxArray * v_3c3 = mclGetUninitializedArray();
mxArray * v_3cb = mclGetUninitializedArray();
mxArray * R_3b = mclGetUninitializedArray();
mxArray * t2 = mclGetUninitializedArray();
mxArray * M_2bb = mclGetUninitializedArray();
mxArray * F_2b = mclGetUninitializedArray();
mxArray * F_2w = mclGetUninitializedArray();
mxArray * R_w2 = mclGetUninitializedArray();
mxArray * a2 = mclGetUninitializedArray();
mxArray * v_2c2 = mclGetUninitializedArray();
mxArray * v_2cb = mclGetUninitializedArray();
mxArray * R_2b = mclGetUninitializedArray();
mxArray * t1 = mclGetUninitializedArray();
mxArray * M_1bb = mclGetUninitializedArray();
mxArray * F_1b = mclGetUninitializedArray();
mxArray * F_1w = mclGetUninitializedArray();
mxArray * R_w1 = mclGetUninitializedArray();
mxArray * a1 = mclGetUninitializedArray();
mxArray * v_1c1 = mclGetUninitializedArray();
mxArray * v_1cb = mclGetUninitializedArray();
mxArray * R_1b = mclGetUninitializedArray();
mxArray * tf = mclGetUninitializedArray();
mxArray * M_Bbb = mclGetUninitializedArray();
mxArray * Pf_b = mclGetUninitializedArray();
mxArray * F_Bb = mclGetUninitializedArray();
mxArray * F_Bw = mclGetUninitializedArray();
mxArray * xcp = mclGetUninitializedArray();
mxArray * cd = mclGetUninitializedArray();
mxArray * cl = mclGetUninitializedArray();
mxArray * R_wf = mclGetUninitializedArray();
mxArray * af = mclGetUninitializedArray();
mxArray * v_Bcf = mclGetUninitializedArray();
mxArray * R_fb = mclGetUninitializedArray();
mxArray * k_fb = mclGetUninitializedArray();
mxArray * i_fb = mclGetUninitializedArray();
mxArray * v_Bcb = mclGetUninitializedArray();
mxArray * sf = mclGetUninitializedArray();
mclCopyArray(&veh);
mclCopyArray(&vr);
mclCopyArray(&de);
/*
*
* % td=tau_damp(veh,vr,de); calculates damping forces from
* % vehicle variables ,generalized velocity vr and delta angles de
*
* % --------------------------------------------------------------
* % forces on FUSELAGE
*
* % Fuselage reference surface
* sf=pi/4*veh.d^2;
*/
mlfAssign(
&sf,
mclMtimes(
_mxarray4_,
mclFeval(
mclValueVarargout(),
mlxMpower,
mclVe(mlfIndexRef(mclVsa(veh, "veh"), ".d")),
_mxarray5_,
NULL)));
/*
*
* % relative velocity of B_b wrt c in b
* v_Bcb=vr(1:3)+vp(vr(4:6),veh.B_b);
*/
mlfAssign(
&v_Bcb,
mclPlus(
mclVe(
mclArrayRef1(
mclVsa(vr, "vr"), mlfColon(_mxarray6_, _mxarray7_, NULL))),
mclVe(
mclFeval(
mclValueVarargout(),
mlxVp,
mclVe(
mclArrayRef1(
mclVsa(vr, "vr"), mlfColon(_mxarray8_, _mxarray9_, NULL))),
mclVe(mlfIndexRef(mclVsa(veh, "veh"), ".B_b")),
NULL))));
/*
*
* % fuselage rotation matrix
* i_fb=[1; 0; 0];
*/
mlfAssign(&i_fb, _mxarray10_);
/*
* if norm([0; v_Bcb(2); v_Bcb(3)])<1e-12, k_fb=[0; 0; 1];
*/
if (mclLtBool(
mclVe(
mlfNorm(
mlfVertcat(
_mxarray12_,
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 2)),
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 3)),
NULL),
NULL)),
_mxarray13_)) {
mlfAssign(&k_fb, _mxarray14_);
/*
* else k_fb=[0; v_Bcb(2); v_Bcb(3)]/norm([0; v_Bcb(2); v_Bcb(3)]);end
*/
} else {
mlfAssign(
&k_fb,
mclMrdivide(
mlfVertcat(
_mxarray12_,
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 2)),
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 3)),
NULL),
mclVe(
mlfNorm(
mlfVertcat(
_mxarray12_,
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 2)),
mclVe(mclIntArrayRef1(mclVsv(v_Bcb, "v_Bcb"), 3)),
NULL),
NULL))));
}
/*
* R_fb=[i_fb, vp(k_fb,i_fb), k_fb];
*/
mlfAssign(
&R_fb,
mlfHorzcat(
mclVv(i_fb, "i_fb"),
mclVe(mlfVp(mclVv(k_fb, "k_fb"), mclVv(i_fb, "i_fb"))),
mclVv(k_fb, "k_fb"),
NULL));
/*
*
* % relative velocity of B_b wrt c in f
* v_Bcf=R_fb'*v_Bcb;
*/
mlfAssign(
&v_Bcf,
mclMtimes(mlfCtranspose(mclVv(R_fb, "R_fb")), mclVv(v_Bcb, "v_Bcb")));
/*
*
* % attack angle
* af=atan2(v_Bcf(3),v_Bcf(1));
*/
mlfAssign(
&af,
mlfAtan2(
mclVe(mclIntArrayRef1(mclVsv(v_Bcf, "v_Bcf"), 3)),
mclVe(mclIntArrayRef1(mclVsv(v_Bcf, "v_Bcf"), 1))));
/*
*
* % wind frame rotation matrix
* R_wf=[cos(af) 0 -sin(af); 0 1 0; sin(af) 0 cos(af)];
*/
mlfAssign(
&R_wf,
mlfVertcat(
mlfHorzcat(
mclVe(mlfCos(mclVv(af, "af"))),
_mxarray12_,
mclUminus(mclVe(mlfSin(mclVv(af, "af")))),
NULL),
_mxarray16_,
mlfHorzcat(
mclVe(mlfSin(mclVv(af, "af"))),
_mxarray12_,
mclVe(mlfCos(mclVv(af, "af"))),
NULL),
NULL));
/*
*
* % cl cd xcp computation
* [cl,cd,xcp]=a2clcdxc(af);
*/
mlfAssign(&cl, mlfA2clcdxc(&cd, &xcp, mclVv(af, "af")));
/*
*
* % damping forces on B wrt w
* F_Bw=-0.5*veh.rho*sf*v_Bcf'*v_Bcf*[cd; 0; cl];
*/
mlfAssign(
&F_Bw,
mclMtimes(
mclMtimes(
mclMtimes(
mclMtimes(
mclFeval(
mclValueVarargout(),
mlxMtimes,
_mxarray18_,
mclVe(mlfIndexRef(mclVsa(veh, "veh"), ".rho")),
NULL),
mclVv(sf, "sf")),
mlfCtranspose(mclVv(v_Bcf, "v_Bcf"))),
mclVv(v_Bcf, "v_Bcf")),
mlfVertcat(mclVv(cd, "cd"), _mxarray12_, mclVv(cl, "cl"), NULL)));
/*
*
* % damping forces on B wrt b
* F_Bb=R_fb*R_wf*F_Bw;
*/
mlfAssign(
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -