MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
motor.cc
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/elec/motor.cc,v 1.32 2017/01/12 14:46:22 masarati Exp $ */
2 /*
3  * MBDyn (C) is a multibody analysis code.
4  * http://www.mbdyn.org
5  *
6  * Copyright (C) 1996-2017
7  *
8  * Pierangelo Masarati <masarati@aero.polimi.it>
9  * Paolo Mantegazza <mantegazza@aero.polimi.it>
10  *
11  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
12  * via La Masa, 34 - 20156 Milano, Italy
13  * http://www.aero.polimi.it
14  *
15  * Changing this copyright notice is forbidden.
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation (version 2 of the License).
20  *
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */
31 
32 #include "mbconfig.h" /* This goes first in every *.c,*.cc file */
33 
34 #include "drive.h"
35 #include "elec.h"
36 #include "strnode.h"
37 #include "elecnode.h"
38 #include "motor.h"
39 
40 /*
41  * Electric motor: an internal couple between two structural nodes
42  * whose value is represented by an internal state that is a current,
43  * according to equations:
44 
45  M = M0(Phi_e) - (Gain + M1(Phi_e)) * i
46 
47  C1 = -M
48 
49  C2 = M
50 
51  i1 = - i
52 
53  i2 = i
54 
55  d i
56  L * --- + R * i = - Gain * (Omega2 - Omega1) + V2 - V1
57  d t
58 
59  * In order to take into account the so called cogging torque or ripple torque
60  * of DC motors, the following data can be provided:
61  * M0(Phi_e) ... variation of the motor torque independent of current
62  * M1(Phi_e) ... variation of the motor torque proportional to current
63  * p ... number of terminal pairs
64  *
65  * Phi_m ... mechanical angle of rotation between rotor and stator
66  * Phi_e = p * Phi_m ... electric angle between rotor field and stator field
67  */
68 
70  {1, "omega"},
71  {2, "M"},
72  {3, "Pmech"},
73  {4, "U"},
74  {5, "i"},
75  {6, "iP"},
76  {7, "Pel"},
77  {8, "Phimech"},
78  {9, "Phiel"},
79  {10, "M0"},
80  {11, "M1"},
81  {12, "R"}
82 };
83 
84 Motor::Motor(const unsigned int uL, const DofOwner* pD,
85  const StructNode* pN1, const StructNode* pN2,
86  const ElectricNode* pV1, const ElectricNode* pV2,
87  const Mat3x3& Rn, doublereal dG,
88  const doublereal dL, DriveCaller* dR, const doublereal i0,
89  integer p,
90  const DriveCaller* pM0,
91  const DriveCaller* pM1,
92  const flag fOut)
93 : Elem(uL, fOut),
94 Electric(uL, pD, fOut),
95 pStrNode1(pN1), pStrNode2(pN2), pVoltage1(pV1), pVoltage2(pV2),
96 Rn(Rn), dGain(dG), dL(dL), dR(dR), p(p), M0(pM0), M1(pM1), M(i0 * dG), i(i0)
97 {
98  const doublereal dU = dGetVoltage();
99  const doublereal omega = dGetOmega();
100 
101  iP = (dU - dGain * omega - dR->dGet(fabs(i)) * i) / dL;
102 
105 }
106 
108 {
109  NO_OP;
110 }
111 
113 {
114  return Electric::MOTOR;
115 }
116 
117 /* Contributo al file di restart */
118 std::ostream&
119 Motor::Restart(std::ostream& out) const
120 {
121  out << "electric: " << GetLabel()
122  << ", motor, "
123  << pStrNode1->GetLabel() << ", "
124  << "orientation, " << Rn << ", "
125  << pStrNode2->GetLabel() << ", "
126  << pVoltage1->GetLabel() << ", "
127  << pVoltage2->GetLabel() << ", "
128  << dGain << ", "
129  << dL << ", ";
130 
131  dR.pGetDriveCaller()->Restart(out);
132 
133  out << ", initial current, " << i << ", M0, ";
134 
135  M0.pGetDriveCaller()->Restart(out);
136 
137  out << ", M1, ";
138 
139  M1.pGetDriveCaller()->Restart(out);
140 
141  out << ", terminal pairs, " << p << ";" << std::endl;
142 
143  return out;
144 }
145 
146 unsigned int
147 Motor::iGetNumDof(void) const
148 {
149  return 1;
150 }
151 
153 Motor::GetDofType(unsigned int i) const
154 {
155  return DofOrder::DIFFERENTIAL;
156 }
157 
158 void
159 Motor::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
160 {
161  *piNumRows = 9;
162  *piNumCols = 9;
163 }
164 
167  const doublereal dCoef,
168  const VectorHandler& XCurr,
169  const VectorHandler& XPrimeCurr)
170 {
171  FullSubMatrixHandler& WM = WorkMat.SetFull();
172 
173  /* Dimensiona e resetta la matrice di lavoro */
174  integer iNumRows = 0;
175  integer iNumCols = 0;
176  WorkSpaceDim(&iNumRows, &iNumCols);
177  WM.ResizeReset(iNumRows, iNumCols);
178 
179  integer iStrNode1FirstPosIdx = pStrNode1->iGetFirstPositionIndex() + 3;
180  integer iStrNode2FirstPosIdx = pStrNode2->iGetFirstPositionIndex() + 3;
181  integer iStrNode1FirstMomIdx = pStrNode1->iGetFirstMomentumIndex() + 3;
182  integer iStrNode2FirstMomIdx = pStrNode2->iGetFirstMomentumIndex() + 3;
183  integer iElecNode1FirstIndex = pVoltage1->iGetFirstRowIndex() + 1;
184  integer iElecNode2FirstIndex = pVoltage2->iGetFirstRowIndex() + 1;
185  integer iFirstIndex = iGetFirstIndex() + 1;
186 
187  for (integer iCnt = 1; iCnt <= 3; iCnt++) {
188  WM.PutRowIndex(iCnt, iStrNode1FirstMomIdx + iCnt);
189  WM.PutRowIndex(3+iCnt, iStrNode2FirstMomIdx + iCnt);
190 
191  WM.PutColIndex(iCnt, iStrNode1FirstPosIdx + iCnt);
192  WM.PutColIndex(3+iCnt, iStrNode2FirstPosIdx + iCnt);
193  }
194 
195  WM.PutRowIndex(7, iElecNode1FirstIndex);
196  WM.PutRowIndex(8, iElecNode2FirstIndex);
197  WM.PutRowIndex(9, iFirstIndex);
198 
199  WM.PutColIndex(7, iElecNode1FirstIndex);
200  WM.PutColIndex(8, iElecNode2FirstIndex);
201  WM.PutColIndex(9, iFirstIndex);
202 
203  const doublereal i = XCurr(iFirstIndex);
204  const Mat3x3& R1 = pStrNode1->GetRCurr();
205  const Mat3x3& R2 = pStrNode2->GetRCurr();
206  const Mat3x3& R1_0 = pStrNode1->GetRRef();
207  const Mat3x3& R2_0 = pStrNode2->GetRRef();
208  const Vec3& omega1 = pStrNode1->GetWCurr();
209  const Vec3& omega2 = pStrNode2->GetWCurr();
210  const Vec3& omega1_0 = pStrNode1->GetWRef();
211  const Vec3& omega2_0 = pStrNode2->GetWRef();
212  const Vec3& gP1 = pStrNode1->GetgPCurr();
213  const Vec3& gP2 = pStrNode2->GetgPCurr();
214  const Mat3x3 DeltaR = Rn.MulTM(R1.MulTM(R2));
215  const Vec3 dDeltaR21_dg1_T = -R2.GetCol(1).Cross(R1_0 * Rn.GetCol(2));
216  const Vec3 dDeltaR21_dg2_T = R2_0.GetCol(1).Cross(R1 * Rn.GetCol(2));
217  const Vec3 dDeltaR11_dg1_T = -R2.GetCol(1).Cross(R1_0 * Rn.GetCol(1));
218  const Vec3 dDeltaR11_dg2_T = R2_0.GetCol(1).Cross(R1 * Rn.GetCol(1));
219  const doublereal a0 = DeltaR(1, 1) * DeltaR(1, 1) + DeltaR(2, 1) * DeltaR(2, 1);
220  const Vec3 dPhi_dg1_T = (dDeltaR21_dg1_T * DeltaR(1, 1) - dDeltaR11_dg1_T * DeltaR(2, 1)) / a0;
221  const Vec3 dPhi_dg2_T = (dDeltaR21_dg2_T * DeltaR(1, 1) - dDeltaR11_dg2_T * DeltaR(2, 1)) / a0;
222  const doublereal dM0_dPhi = M0.dGetP(Phi_e) * p;
223  const doublereal dM1_dPhi = M1.dGetP(Phi_e) * p;
224  const Vec3 dM0_dg1_T = dPhi_dg1_T * dM0_dPhi;
225  const Vec3 dM0_dg2_T = dPhi_dg2_T * dM0_dPhi;
226  const Vec3 dM1_dg1_T = dPhi_dg1_T * dM1_dPhi;
227  const Vec3 dM1_dg2_T = dPhi_dg2_T * dM1_dPhi;
228  const Vec3 dM_dg1_T = dM0_dg1_T + dM1_dg1_T * i;
229  const Vec3 dM_dg2_T = dM0_dg2_T + dM1_dg2_T * i;
230  const Mat3x3 dC1_dg1 = Mat3x3(MatCross, R1_0 * Rn.GetCol(3) * M) - (R1 * Rn.GetCol(3)).Tens(dM_dg1_T);
231  const Mat3x3 dC1_dg2 = (-(R1 * Rn.GetCol(3))).Tens(dM_dg2_T);
232  const Vec3 dC1_di = -(R1 * Rn.GetCol(3) * (dGain + M1.dGet(Phi_e)));
233  const Vec3 dOmega_dg1_T = (omega1 - omega2).Cross(R1_0 * Rn.GetCol(3)) - (gP1 * 0.5 + omega1_0).Cross(R1 * Rn.GetCol(3));
234  const doublereal di1_di = -1;
235  const doublereal di2_di = 1;
236  const Vec3 dOmega_dgP1_T = -(R1 * Rn.GetCol(3));
237  const Vec3 dOmega_dg2_T = (gP2 * 0.5 + omega2_0).Cross(R1 * Rn.GetCol(3));
238  const Vec3 dOmega_dgP2_T = R1 * Rn.GetCol(3);
239  const Vec3 dfi_dg1_T = dOmega_dg1_T * (-dGain);
240  const Vec3 dfi_dgP1_T = dOmega_dgP1_T * (-dGain);
241  const Vec3 dfi_dg2_T = dOmega_dg2_T * (-dGain);
242  const Vec3 dfi_dgP2_T = dOmega_dgP2_T * (-dGain);
243  const doublereal dfi_du1 = -1;
244  const doublereal dfi_du2 = 1;
245  const doublereal abs_i = fabs(i);
246  const doublereal dfi_di = -dR.dGet(abs_i) - dR.dGetP(abs_i) * i;
247  const doublereal dfi_diP = -dL;
248 
249  WM.Put(1, 1, dC1_dg1 * (-dCoef));
250  WM.Put(1, 4, dC1_dg2 * (-dCoef));
251  WM.Put(4, 1, dC1_dg1 * dCoef);
252  WM.Put(4, 4, dC1_dg2 * dCoef);
253  WM.Put(1, 9, dC1_di * (-dCoef));
254  WM.Put(4, 9, dC1_di * dCoef);
255  WM.PutCoef(7, 9, -dCoef * di1_di);
256  WM.PutCoef(8, 9, -dCoef * di2_di);
257  WM.PutT(9, 1, -dfi_dgP1_T - dfi_dg1_T * dCoef);
258  WM.PutT(9, 4, -dfi_dgP2_T - dfi_dg2_T * dCoef);
259  WM.PutCoef(9, 7, -dCoef * dfi_du1);
260  WM.PutCoef(9, 8, -dCoef * dfi_du2);
261  WM.PutCoef(9, 9, -dfi_diP - dCoef * dfi_di);
262 
263  return WorkMat;
264 }
265 
268  const doublereal dCoef,
269  const VectorHandler& XCurr,
270  const VectorHandler& XPrimeCurr)
271 {
272  /* Dimensiona e resetta la matrice di lavoro */
273  integer iNumRows = 0;
274  integer iNumCols = 0;
275  WorkSpaceDim(&iNumRows, &iNumCols);
276  WorkVec.ResizeReset(iNumRows);
277 
278  integer iStrNode1FirstIndex = pStrNode1->iGetFirstMomentumIndex() + 3;
279  integer iStrNode2FirstIndex = pStrNode2->iGetFirstMomentumIndex() + 3;
280  integer iElecNode1FirstIndex = pVoltage1->iGetFirstRowIndex() + 1;
281  integer iElecNode2FirstIndex = pVoltage2->iGetFirstRowIndex() + 1;
282  integer iFirstIndex = iGetFirstIndex() + 1;
283 
284  for (integer iCnt = 1; iCnt <= 3; iCnt++) {
285  WorkVec.PutRowIndex(iCnt, iStrNode1FirstIndex + iCnt);
286  WorkVec.PutRowIndex(3+iCnt, iStrNode2FirstIndex + iCnt);
287  }
288 
289  WorkVec.PutRowIndex(7, iElecNode1FirstIndex);
290  WorkVec.PutRowIndex(8, iElecNode2FirstIndex);
291  WorkVec.PutRowIndex(9, iFirstIndex);
292 
295  i = XCurr(iFirstIndex);
296  iP = XPrimeCurr(iFirstIndex);
297  M = M0.dGet(Phi_e) + (dGain + M1.dGet(Phi_e)) * i;
298 
299  const Mat3x3& R1 = pStrNode1->GetRCurr();
300  const Vec3 n(R1 * Rn.GetCol(3));
301  const doublereal dU = dGetVoltage();
302  const Vec3 C(n * M);
303  const doublereal Omega = dGetOmega(n);
304 
305  WorkVec.Put(1, -C);
306  WorkVec.Put(4, C);
307  WorkVec.PutCoef(7, -i);
308  WorkVec.PutCoef(8, i);
309  WorkVec.PutCoef(9, dU - dGain * Omega - dL * iP - dR.dGet(fabs(i)) * i);
310 
311  return WorkVec;
312 }
313 
315  return pVoltage2->dGetX() - pVoltage1->dGetX();
316 }
317 
318 doublereal Motor::dGetOmega(const Vec3& TmpDir) const {
319  return TmpDir * (pStrNode2->GetWCurr() - pStrNode1->GetWCurr());
320 }
321 
323  return pStrNode1->GetRCurr() * Rn.GetCol(3);
324 }
325 
327  return dGetOmega(GetAxisOfRotation());
328 }
329 
331  const Mat3x3& R1 = pStrNode1->GetRCurr();
332  const Mat3x3& R2 = pStrNode2->GetRCurr();
333  const Vec3 DeltaR_e1 = Rn.MulTV(R1.MulTV(R2.GetCol(1)));
334 
335  return atan2(DeltaR_e1(2), DeltaR_e1(1));
336 }
337 
339  doublereal Phi_e = fmod(p * Phi_m, 2 * M_PI);
340 
341  if (Phi_e < 0.) {
342  Phi_e += 2 * M_PI;
343  }
344 
345  ASSERT(Phi_e >= 0 && Phi_e <= 2 * M_PI);
346 
347  return Phi_e;
348 }
349 
350 void
352 {
353  const integer iFirstIndex = iGetFirstIndex() + 1;
354 
355  X(iFirstIndex) = i;
356 }
357 
358 void
362 {
363  const integer iFirstIndex = iGetFirstIndex() + 1;
364 
365  X(iFirstIndex) = i;
366  XP(iFirstIndex) = iP;
367 }
368 
369 /* *******PER IL SOLUTORE PARALLELO******** */
370 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
371  * utile per l'assemblaggio della matrice di connessione fra i dofs */
372 void Motor::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
373  connectedNodes.resize(4);
374  connectedNodes[0] = pStrNode1;
375  connectedNodes[1] = pStrNode2;
376  connectedNodes[2] = pVoltage1;
377  connectedNodes[3] = pVoltage2;
378 };
379 /* ************************************************ */
380 
381 unsigned int Motor::iGetNumPrivData(void) const
382 {
383  return iNumPrivData;
384 }
385 
386 unsigned int Motor::iGetPrivDataIdx(const char *s) const
387 {
388  for (int i = 0; i < iNumPrivData; ++i ) {
389  if (0 == strcmp(rgPrivData[i].name, s)) {
390  return rgPrivData[i].index;
391  }
392  }
393 
394  return 0;
395 }
396 
397 doublereal Motor::dGetPrivData(unsigned int iIndex) const
398 {
399  switch (iIndex) {
400  case 1:
401  return dGetOmega();
402  case 2:
403  return M;
404  case 3:
405  return dGetOmega() * M;
406  case 4:
407  return dGetVoltage();
408  case 5:
409  return i;
410  case 6:
411  return iP;
412  case 7:
413  return dGetVoltage() * i;
414  case 8:
415  return dGetPhiMechanical();
416  case 9:
418  case 10:
420  case 11:
422  case 12:
423  return dR.dGet(fabs(i));
424  default:
426  }
427 }
Vec3 GetAxisOfRotation() const
Definition: motor.cc:322
const StructNode * pStrNode1
Definition: motor.h:66
virtual void SetInitialValue(VectorHandler &X)
Definition: motor.cc:351
const ElectricNode * pVoltage1
Definition: motor.h:68
virtual void GetConnectedNodes(std::vector< const Node * > &connectedNodes) const
Definition: motor.cc:372
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
#define M_PI
Definition: gradienttest.cc:67
virtual Electric::Type GetElectricType(void) const
Definition: motor.cc:112
Vec3 Cross(const Vec3 &v) const
Definition: matvec3.h:218
DriveOwner M1
Definition: motor.h:76
long int flag
Definition: mbdyn.h:43
virtual const Mat3x3 & GetRRef(void) const
Definition: strnode.h:1006
doublereal M
Definition: motor.h:85
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
Definition: matvec3.h:98
virtual void ResizeReset(integer)
Definition: vh.cc:55
const MatCross_Manip MatCross
Definition: matvec3.cc:639
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
void PutT(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:239
doublereal i
Definition: motor.h:85
void Put(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:221
void PutCoef(integer iRow, integer iCol, const doublereal &dCoef)
Definition: submat.h:672
Vec3 GetCol(unsigned short int i) const
Definition: matvec3.h:903
static const unsigned int iNumPrivData
Definition: beam.cc:249
virtual doublereal dGetPrivData(unsigned int i) const
Definition: motor.cc:397
virtual unsigned int iGetNumPrivData(void) const
Definition: motor.cc:381
const Mat3x3 & Tens(const Vec3 &a, const Vec3 &b)
Definition: matvec3.h:799
virtual const Vec3 & GetWRef(void) const
Definition: strnode.h:1024
VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: motor.cc:166
#define NO_OP
Definition: myassert.h:74
std::vector< Hint * > Hints
Definition: simentity.h:89
doublereal dGetP(const doublereal &dVar) const
Definition: drive.cc:683
GradientExpression< UnaryExpr< FuncFabs, Expr > > fabs(const GradientExpression< Expr > &u)
Definition: gradient.h:2973
doublereal iP
Definition: motor.h:85
virtual std::ostream & Restart(std::ostream &out) const =0
virtual unsigned int iGetPrivDataIdx(const char *s) const
Definition: motor.cc:386
virtual ~Motor(void)
Definition: motor.cc:107
virtual unsigned int iGetNumDof(void) const
Definition: motor.cc:147
Vec3 MulTV(const Vec3 &v) const
Definition: matvec3.cc:482
virtual std::ostream & Restart(std::ostream &out) const
Definition: motor.cc:119
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
DriveOwner M0
Definition: motor.h:76
DriveOwner dR
Definition: motor.h:74
doublereal dGetPhiElectric(doublereal Phi_m) const
Definition: motor.cc:338
doublereal dGetVoltage() const
Definition: motor.cc:314
integer p
Definition: motor.h:75
SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: motor.cc:267
const ElectricNode * pVoltage2
Definition: motor.h:69
virtual DofOrder::Order GetDofType(unsigned int i) const
Definition: motor.cc:153
Definition: elec.h:43
virtual integer iGetFirstRowIndex(void) const
Definition: node.cc:82
virtual integer iGetFirstMomentumIndex(void) const =0
static const int iNumPrivData
Definition: motor.h:87
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
virtual const Vec3 & GetWCurr(void) const
Definition: strnode.h:1030
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: motor.cc:159
#define ASSERT(expression)
Definition: colamd.c:977
Type
Definition: elec.h:46
Mat3x3 MulTM(const Mat3x3 &m) const
Definition: matvec3.cc:500
virtual void PutCoef(integer iRow, const doublereal &dCoef)=0
VectorExpression< VectorCrossExpr< VectorLhsExpr, VectorRhsExpr >, 3 > Cross(const VectorExpression< VectorLhsExpr, 3 > &u, const VectorExpression< VectorRhsExpr, 3 > &v)
Definition: matvec.h:3248
DriveCaller * pGetDriveCaller(void) const
Definition: drive.cc:658
static const struct Motor::PrivData rgPrivData[iNumPrivData]
Definition: motor.cc:69
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *h=0)
Definition: motor.cc:359
doublereal Phi_m
Definition: motor.h:85
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
virtual doublereal dGet(const doublereal &dVar) const =0
Mat3x3 Rn
Definition: motor.h:71
doublereal Phi_e
Definition: motor.h:85
doublereal dGetOmega() const
Definition: motor.cc:326
virtual void Put(integer iRow, const Vec3 &v)
Definition: vh.cc:93
Definition: elem.h:75
Motor(unsigned int uL, const DofOwner *pD, const StructNode *pN1, const StructNode *pN2, const ElectricNode *pV1, const ElectricNode *pV2, const Mat3x3 &Rn, doublereal dG, doublereal dl, DriveCaller *dR, doublereal i0, integer p, const DriveCaller *pM0, const DriveCaller *pM1, flag fOut)
Definition: motor.cc:84
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
doublereal dL
Definition: motor.h:73
virtual const Vec3 & GetgPCurr(void) const
Definition: strnode.h:994
doublereal dGet(const doublereal &dVar) const
Definition: drive.cc:664
doublereal dGetPhiMechanical() const
Definition: motor.cc:330
const StructNode * pStrNode2
Definition: motor.h:67
virtual integer iGetFirstIndex(void) const
Definition: dofown.h:127
GradientExpression< BinaryExpr< FuncAtan2, LhsExpr, RhsExpr > > atan2(const GradientExpression< LhsExpr > &u, const GradientExpression< RhsExpr > &v)
Definition: gradient.h:2962
double doublereal
Definition: colamd.c:52
long int integer
Definition: colamd.c:51
unsigned int GetLabel(void) const
Definition: withlab.cc:62
doublereal dGain
Definition: motor.h:72
virtual const doublereal & dGetX(void) const
Definition: node.h:386