155 virtual std::ostream&
DescribeDof(std::ostream& out,
156 const char *prefix =
"",
bool bInitial =
false)
const;
157 virtual void DescribeDof(std::vector<std::string>& desc,
158 bool bInitial =
false,
int i = -1)
const;
159 virtual std::ostream&
DescribeEq(std::ostream& out,
160 const char *prefix =
"",
bool bInitial =
false)
const;
161 virtual void DescribeEq(std::vector<std::string>& desc,
162 bool bInitial =
false,
int i = -1)
const;
187 std::ostream&
Restart(std::ostream& out)
const;
209 { 0.92388, 0.70711, 0.38268, -0.38268, -0.70711, -0.92388, -1.00000, -0.92388, -0.70711, -0.38268, -0.00000, 0.38268, 0.70711, 0.92388 },
210 { 0.38268, 0.70711, 0.92388, 0.92388, 0.70711, 0.38268, 0.00000, -0.38268, -0.70711, -0.92388, -1.00000, -0.92388, -0.70711, -0.38268 }
216 static bool bIRa(
false);
238 "Module: nonsmooth-node\n"
239 "Author: Matteo Fancello <matteo.fancello@gmail.com>\n"
240 " Pierangelo Masarati <masarati@aero.polimi.it>\n"
241 "Organization: Dipartimento di Ingegneria Aerospaziale\n"
242 " Politecnico di Milano\n"
243 " http://www.aero.polimi.it/\n"
245 " All rights reserved\n"
247 " Defines a unilateral constraint in form of a contact\n"
248 " between a node and one or more planes, optionally with friction.\n"
250 " # in the \"control data\" block: increase by 1 the count of \"loadable elements\"\n"
252 " # in the \"elements\" block: add a user-defined element according to the syntax\n"
254 " <element_label> , nonsmooth node ,\n"
255 " [ frictional , { yes | no | (bool) <frictional> } , ]\n"
256 " (StructDispNode) <NonsmoothNODELABEL> ,\n"
257 " mass , (real) <mass> , radius , (real) <radius> ,\n"
258 " planes , (int) <number_of_planes> ,\n"
259 " <PlaneDefiningNODELABEL> ,\n"
261 " (Vec3) <relative_plane_position> ,\n"
262 " rotation orientation ,\n"
263 " (OrientationMatrix) <rel_rot_orientation_1> ,\n"
264 " restitution , (real) <rest_coeff>\n"
265 " [ , frictional coefficient , <mu> ]\n"
266 " [ , <other planes> ]\n"
267 " [ , constraint type , { position | velocity | both } ] # default: both\n"
268 " [ , theta , <theta> ] [ , gamma , <gamma> ]\n"
269 " [ , LCP solver , <solver> ]\n"
270 " [ , tolerance , <tolerance> ][ , max iterations , <num_iter> ]\n"
271 " # these options depend on LCP solver support, see\n"
272 " # http://siconos.gforge.inria.fr/Numerics/LCPSolvers.html\n"
273 " [ , limit iterations , <niterations> ]\n"
274 " [ , limit LCP iterations , <niterations> ]\n"
275 " [ , verbose , { yes | no | (bool) <verbose> } ] ;\n"
277 " <solver> ::= lexico lemke # the default\n"
290 " 1: element label\n"
291 " 2-4: impulse on NonSmooth node in global ref. frame\n"
292 " 5-7: position of NonSmooth node in global ref. frame\n"
293 " 8-10: velocity of Nonsmooth node in global ref. frame\n"
294 " 11-13: Lambda: constr. reaction between mbs node and NS node\n"
295 " 14: p: norm of the impulse reaction in global ref. frame\n"
296 " 15: Ia: number of active constraints in this step\n"
298 " if verbose, also:\n"
299 " 16-18: Mu: constraint relaxation factor\n"
300 " 19: LCPsolver status: 0 -> convergence, 1 -> iter=maxiter, >1 -> fail\n"
301 " (only for some solvers)\n"
302 " 20: LCPsolver resulting_error\n"
303 " (only for some solvers)\n"
318 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"mass\" expected at line "
324 if (
NS_data.
mass_ns <= std::numeric_limits<doublereal>::epsilon()) {
325 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"mass\" too small at line "
331 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"radius\" expected at line "
339 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"planes\" expected at line "
353 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"position\" expected at line "
360 if (!HP.
IsKeyWord(
"rotation" "orientation")) {
361 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"rotation orientation \" expected at line "
369 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): \"restitution \" expected at line "
376 if (HP.
IsKeyWord(
"friction" "coefficient")) {
381 silent_cerr(
"ModuleNonsmoothNode(" << uLabel <<
"): no friction coefficient for plane #" << i <<
" of " <<
NS_data.
Np <<
" at line "
396 silent_cerr(
"ModuleNonsmoothNode: invalid constraint_type"
442 silent_cerr(
"ModuleNonsmoothNode(" <<
GetLabel() <<
"): invalid lcp solver type"
459 if (HP.
IsKeyWord(
"limit" "iterations")) {
464 if (HP.
IsKeyWord(
"limit" "LCP" "iterations")) {
484 silent_cout(
"ModuleNonsmoothNode(" <<
GetLabel() <<
")" << std::endl
485 <<
" initial nonsmooth node position " <<
m_pNode->
GetXCurr() << std::endl
486 <<
" Plane_point " << Plane_point << std::endl
487 <<
" normal " <<
NS_data.
constr[i].H_kp1.GetVec(3) << std::endl
488 <<
" Gap " << Gap << std::endl
489 <<
" RFnode " <<
NS_data.
constr[i].AttNode->GetRCurr() << std::endl);
493 silent_cerr(
"ModuleNonsmoothNode(" <<
GetLabel() <<
"): "
494 "unilateral constraint " << i <<
" violated before simulation; Gap=" << Gap << std::endl);
516 silent_cout(
"ModuleNonsmoothNode(" <<
GetLabel() <<
"): initial nonsmooth node position " <<
NS_data.
Xns_kp1 << std::endl);
524 IRa.
Resize(2, omegan - 2);
525 for (
int r = 0; r < 2; r++) {
526 for (
int c = 0;
c < omegan - 2;
c++) {
531 IRat.
Resize(omegan - 2, 2);
532 for (
int r = 0; r < omegan - 2; r++) {
533 for (
int c = 0;
c < 2;
c++) {
539 for (
int r = 0; r < 2; r++) {
540 for (
int c = 0;
c < 2;
c++) {
665 WM.
PutItem(1, iNode1FirstMomentumIndex + 1, iFirstIndex + 1, 1.);
666 WM.
PutItem(2, iNode1FirstMomentumIndex + 2, iFirstIndex + 2, 1.);
667 WM.
PutItem(3, iNode1FirstMomentumIndex + 3, iFirstIndex + 3, 1.);
669 WM.
PutItem(4, iFirstIndex + 1, iNode1FirstPositionIndex + 1, 1.);
670 WM.
PutItem(5, iFirstIndex + 2, iNode1FirstPositionIndex + 2, 1.);
671 WM.
PutItem(6, iFirstIndex + 3, iNode1FirstPositionIndex + 3, 1.);
677 WM.
PutItem(1, iNode1FirstMomentumIndex + 1, iFirstIndex + 1, 1.);
678 WM.
PutItem(2, iNode1FirstMomentumIndex + 2, iFirstIndex + 2, 1.);
679 WM.
PutItem(3, iNode1FirstMomentumIndex + 3, iFirstIndex + 3, 1.);
681 WM.
PutItem(4, iFirstIndex + 1, iNode1FirstPositionIndex + 1, 1.);
682 WM.
PutItem(5, iFirstIndex + 2, iNode1FirstPositionIndex + 2, 1.);
683 WM.
PutItem(6, iFirstIndex + 3, iNode1FirstPositionIndex + 3, 1.);
689 WM.
PutItem(1, iNode1FirstMomentumIndex + 1, iFirstIndex + 1, 1.);
690 WM.
PutItem(2, iNode1FirstMomentumIndex + 2, iFirstIndex + 2, 1.);
691 WM.
PutItem(3, iNode1FirstMomentumIndex + 3, iFirstIndex + 3, 1.);
693 WM.
PutItem(4, iFirstIndex + 1, iNode1FirstPositionIndex + 1, dCoef);
694 WM.
PutItem(5, iFirstIndex + 2, iNode1FirstPositionIndex + 2, dCoef);
695 WM.
PutItem(6, iFirstIndex + 3, iNode1FirstPositionIndex + 3, dCoef);
696 WM.
PutItem(7, iFirstIndex + 1, iFirstIndex + 4, 1.);
697 WM.
PutItem(8, iFirstIndex + 2, iFirstIndex + 5, 1.);
698 WM.
PutItem(9, iFirstIndex + 3, iFirstIndex + 6, 1.);
700 WM.
PutItem(10, iFirstIndex + 4, iNode1FirstPositionIndex + 1, 1.);
701 WM.
PutItem(11, iFirstIndex + 5, iNode1FirstPositionIndex + 2, 1.);
702 WM.
PutItem(12, iFirstIndex + 6, iNode1FirstPositionIndex + 3, 1.);
755 <<
" NS_data.Xns_kp1={" <<
NS_data.
Xns_kp1 <<
"} DX={" << DX1 <<
"}" << std::endl
756 <<
" NS_data.Vns_kp1={" <<
NS_data.
Vns_kp1 <<
"} DV={" << DV1 <<
"}" << std::endl
766 WorkVec.
PutItem(4, iFirstIndex + 1, DX1(1)/dCoef);
767 WorkVec.
PutItem(5, iFirstIndex + 2, DX1(2)/dCoef);
768 WorkVec.
PutItem(6, iFirstIndex + 3, DX1(3)/dCoef);
776 WorkVec.
PutItem(4, iFirstIndex + 1, DV1(1));
777 WorkVec.
PutItem(5, iFirstIndex + 2, DV1(2));
778 WorkVec.
PutItem(6, iFirstIndex + 3, DV1(3));
783 Mu =
Vec3(XCurr, iFirstIndex + 4);
790 WorkVec.
PutItem(4, iFirstIndex + 1, DX1(1));
791 WorkVec.
PutItem(5, iFirstIndex + 2, DX1(2));
792 WorkVec.
PutItem(6, iFirstIndex + 3, DX1(3));
793 WorkVec.
PutItem(7, iFirstIndex + 4, DV1(1));
794 WorkVec.
PutItem(8, iFirstIndex + 5, DV1(2));
795 WorkVec.
PutItem(9, iFirstIndex + 6, DV1(3));
800 silent_cout(
"ModuleNonsmoothNode(" <<
GetLabel() <<
") workvec:" << std::endl << WorkVec << std::endl);
841 return out <<
"# ModuleNonsmoothNode: not implemented" << std::endl;
927 for (
int i = 0; i < NS.
Np; i++) {
932 Vec3 Plane_point = NS.
constr[i].AttNode->GetXCurr() + NS.
constr[i].AttNode->GetRCurr() * NS.
constr[i].Point;
936 if (NS.
constr[i].Gap <= 0.) {
961 Vec3 VfreeRel = vfree_kp1 - NS.
constr[0].AttNode->GetVCurr();
966 Mat3xN Hfull_kp1(Ia.size());
967 Mat3xN Hfull_k(Ia.size());
969 for (
unsigned i = 0; i < Ia.size(); i++) {
970 Hfull_kp1.
PutVec(i + 1, NS.
constr[Ia[i]].H_kp1.GetVec(3));
971 Hfull_k.PutVec(i + 1, NS.
constr[Ia[i]].H_k.GetVec(3));
974 MatNx3 Hfull_kp1T(Ia.size());
976 MatNx3 Hfull_kT(Ia.size());
980 MatNxN W_delassus(Ia.size(), 0.);
981 W_delassus.
Mult(HTW, Hfull_kp1);
984 double W_passed[Ia.size()*Ia.size()];
986 for (
unsigned i = 1; i < Ia.size() + 1; i++) {
987 for (
unsigned j = 1; j < Ia.size() + 1; j++) {
988 W_passed[indice] = W_delassus(j, i);
993 double bLCP_new[Ia.size()];
994 for (
unsigned i = 0; i < Ia.size(); i++) {
995 bLCP_new[i] = Hfull_kp1T.GetVec(i + 1) * VfreeRel + Hfull_kT.GetVec(i + 1) * VnskRel * NS.
constr[Ia[i]].e_rest;
998 VecN P(Ia.size(), 0.);
999 VecN U(Ia.size(), 0.);
1006 p_kp1 = Hfull_kp1 * P;
1055 std::vector<int> Ia;
1056 for (
int i = 0; i < NS.
Np; i++) {
1061 Vec3 Plane_point = NS.
constr[i].AttNode->GetXCurr() + NS.
constr[i].AttNode->GetRCurr() * NS.
constr[i].Point;
1065 if (NS.
constr[i].Gap <= 0.) {
1089 Vec3 VfreeRel = vfree_kp1 - NS.
constr[0].AttNode->GetVCurr();
1091 if (Ia.size() > 0) {
1107 for (
unsigned i = 0; i < Ia.size(); i++) {
1108 en(1, i + 1) = NS.
constr[Ia[i]].e_rest;
1110 H_NN.
Put(1, i + 1, NS.
constr[Ia[i]].H_kp1.GetVec(3));
1111 H_TT.
Put(1, 2*i + 1, NS.
constr[Ia[i]].H_kp1.GetVec(1));
1112 H_TT.
Put(1, 2*i + 2, NS.
constr[Ia[i]].H_kp1.GetVec(2));
1113 H_NNt.
PutT(i + 1, 1, NS.
constr[Ia[i]].H_kp1.GetVec(3));
1114 H_TTt.
PutT(2*i + 1, 1, NS.
constr[Ia[i]].H_kp1.GetVec(1));
1115 H_TTt.
PutT(2*i + 2, 1, NS.
constr[Ia[i]].H_kp1.GetVec(2));
1117 I_P.
Put(2*(i + 1 - 1) + 1, 2*(i + 1 - 1) + 1, IPa);
1118 I_R.
Put(2*(i + 1 - 1) + 1, (omegan - 2)*(i + 1 - 1) + 1, IRa);
1119 I_Rt.
Put((omegan - 2)*(i + 1 - 1) + 1, 2*(i + 1 - 1) + 1, IRat);
1122 mu_Piw(1, 1) = NS.
constr[Ia[i]].mu;
1123 mu_Piw(2, 1) = NS.
constr[Ia[i]].mu;
1127 for (
int in = 1; in < omegan - 2 + 1; in++) {
1128 mu_Riw(in, 1) = NS.
constr[Ia[i]].mu;
1131 mu_P.
Put(2*(i + 1 - 1) + 1, i + 1, mu_Piw);
1132 mu_R.
Put((omegan - 2)*(i + 1 - 1) + 1, i + 1, mu_Riw);
1135 Htot.
Put(1, 1, H_TT);
1136 Htot.
Put(1, 2*ac + 1, H_NN);
1139 v_free.
Put(1, 1, VfreeRel);
1142 U_Nfree.
MatMul(H_NNt, v_free);
1143 U_Tfree.
MatMul(H_TTt, v_free);
1146 iMhat.
Put(1, 1, invMhat);
1149 WNNl.
MatMul(H_NNt, iMhat);
1154 WTTl.
MatMul(H_TTt, iMhat);
1159 WNTl.
MatMul(H_NNt, iMhat);
1164 WTNl.
MatMul(H_TTt, iMhat);
1170 for (
int ipmti = 1; ipmti < 2*ac + 1; ipmti++) {
1171 IPmT(ipmti, ipmti) = 1;
1175 int ProbDim = (3 + omegan - 2)*ac;
1186 WNT_IPmT.
MatMul(WNT, IPmT);
1188 WNT_IPmT_muP.
MatMul(WNT_IPmT, mu_P);
1190 mlcp11.
Put(1, 1, WNN);
1191 mlcp11.
Add(1, 1, WNT_IPmT_muP);
1192 mlcp12.
Sub(1, 1, WNT_IPmT);
1195 WTT_IPmT.
MatMul(WTT, IPmT);
1197 WTT_IPmT_muP.
MatMul(WTT_IPmT, mu_P);
1198 WTT_IPmT_muP.
Add(1, 1, WTN);
1199 mlcp21.
Sub(1, 1, WTT_IPmT_muP);
1201 mlcp22.
Put(1, 1, WTT);
1203 mlcp23.
Sub(1, 1, I_R);
1206 I_Rt_mu_P.
MatMul(I_Rt, mu_P);
1208 mlcp31.
Add(1, 1, mu_R);
1209 mlcp31.
Sub(1, 1, I_Rt_mu_P);
1210 mlcp32.
Add(1, 1, I_Rt);
1212 Mlcp.
Put(1, 1, mlcp11);
1213 Mlcp.
Put(1, ac + 1, mlcp12);
1214 Mlcp.
Put(ac + 1, 1, mlcp21);
1215 Mlcp.
Put(ac + 1, ac + 1, mlcp22);
1216 Mlcp.
Put(ac + 1, 3*ac + 1, mlcp23);
1217 Mlcp.
Put(3*ac + 1, 1, mlcp31);
1218 Mlcp.
Put(3*ac + 1, ac + 1, mlcp32);
1225 VnskMinusVplane.
Put(1, NS.
Vns_k - NS.
constr[0].AttNode->GetVCurr());
1230 for (
int ien = 1; ien < ac + 1; ien++) {
1231 qlcp1(ien, 1) = U_N(ien)*en(1, ien);
1234 qlcp1.
Add(1, 1, U_Nfree);
1235 qlcp.
Put(1, 1, qlcp1);
1236 qlcp.
Sub(ac + 1, 1, U_Tfree);
1241 std::cout<<
" H_NN" << std::endl << H_NN << std::endl;
1242 std::cout<<
" H_TT" << std::endl << H_TT << std::endl;
1243 std::cout<<
" I_P" << std::endl << I_P << std::endl;
1244 std::cout<<
" I_R" << std::endl << I_R << std::endl;
1245 std::cout<<
" I_Rt" << std::endl << I_Rt << std::endl;
1246 std::cout<<
" mu_P" << std::endl << mu_P << std::endl;
1247 std::cout<<
" mu_R" << std::endl << mu_R << std::endl;
1248 std::cout<<
" WNN" << std::endl << WNN << std::endl;
1249 std::cout<<
" WNT" << std::endl << WNT << std::endl;
1250 std::cout<<
" WTN" << std::endl << WTN << std::endl;
1251 std::cout<<
" WTT" << std::endl << WTT << std::endl;
1252 std::cout<<
" IPmT" << std::endl << IPmT << std::endl;
1257 double Pkp1[ProbDim];
1258 double Unkp1[ProbDim];
1262 memset(Pkp1, 0,
sizeof(Pkp1));
1263 memset(Unkp1, 0,
sizeof(Unkp1));
1275 for (
int i = 1; i <= ac; i++) {
1276 PN(i) = Pkp1[i - 1];
1278 for (
int i = ac + 1; i <= 3*ac; i++) {
1279 sigmaP(i - ac) = Pkp1[i - 1];
1283 for (
int i = 1; i <= 2*ac; i++) {
1286 for (
int i = 2*ac + 1; i <= 3*ac; i++) {
1287 Ptot(i) = PN(i - (2*ac));
1345 NS.
pkp1 = p_kp1.Norm();
1357 if (!
SetUDE(
"nonsmooth" "node", rf)) {
1359 silent_cerr(
"module-nonsmooth-node: "
1360 "module_init(" << module_name <<
") "
1361 "failed" << std::endl);
flag fReadOutput(MBDynParser &HP, const T &t) const
void PutT(integer iRow, integer iCol, const FullMatrixHandler &source)
Mat3x3 GetRotRel(const ReferenceFrame &rf)
void MatMul(const FullMatrixHandler &m1, const FullMatrixHandler &m2)
Constraining constraint_type
void mbdyn_siconos_LCP_call(int sizep, double W_NN[], double bLCP[], double Pkp1[], double wlem[], solver_parameters &solparam)
const Vec3 Zero3(0., 0., 0.)
virtual bool bToBeOutput(void) const
#define MBDYN_EXCEPT_ARGS
virtual void ResizeReset(integer)
virtual integer GetInt(integer iDefval=0)
SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
doublereal Norm(void) const
void Put(integer iRow, integer iCol, const FullMatrixHandler &source)
virtual const Vec3 & GetXPrev(void) const
virtual void AfterPredict(VectorHandler &X, VectorHandler &XP)
virtual unsigned int iGetNumDof(void) const
const Mat3x3 Eye3(1., 0., 0., 0., 1., 0., 0., 0., 1.)
int iGetNumConnectedNodes(void) const
static FullMatrixHandler IRat
void Add(integer iRow, integer iCol, const FullMatrixHandler &source)
const DriveHandler * pGetDrvHdl(void) const
void ResizeReset(integer iNewRow, integer iNewCol)
virtual bool bGetGravity(const Vec3 &X, Vec3 &Acc) const
virtual DofOrder::Order GetDofType(unsigned int) const
virtual void Output(OutputHandler &OH) const
std::vector< Hint * > Hints
const MatNxN & Mult(const MatNx3 &m, const Mat3xN &n)
virtual void Resize(integer iNewRows, integer iNewCols)
void GetConnectedNodes(std::vector< const Node * > &connectedNodes) const
virtual unsigned int iGetInitialNumDof(void) const
solver_parameters solparam
virtual void PutItem(integer iSubRow, integer iRow, const doublereal &dCoef)
unsigned int iGetNumPrivData(void) const
virtual bool GetYesNoOrBool(bool bDefval=false)
const MatNx3 & Transpose(const Mat3xN &n)
std::vector< plane > constr
const MatNx3 & RightMult(const MatNx3 &n, const Mat3x3 &m)
void PutItem(integer iSubIt, integer iRow, integer iCol, const doublereal &dCoef)
const DataManager * m_pDM
ModuleNonsmoothNode(unsigned uLabel, const DofOwner *pDO, DataManager *pDM, MBDynParser &HP)
integer iGetStep(void) const
const doublereal * pGetVec(void) const
Vec3 GetPosRel(const ReferenceFrame &rf)
static FullMatrixHandler IPa
virtual bool IsKeyWord(const char *sKeyWord)
virtual void Put(integer iRow, const Vec3 &v)
VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
std::ostream & Loadable(void) const
doublereal dGetTimeStep(void) const
void mbs_get_force_frictional(NS_subsys &)
virtual const Vec3 & GetVPrev(void) const
virtual void AfterConvergence(const VectorHandler &X, const VectorHandler &XP)
static const doublereal dIRa[2][omegan-2]
static const doublereal dIPa[2][omegan-2]
SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
void mbs_get_force(NS_subsys &)
virtual std::ostream & DescribeEq(std::ostream &out, const char *prefix="", bool bInitial=false) const
virtual integer iGetFirstMomentumIndex(void) const =0
virtual integer iGetFirstPositionIndex(void) const
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
#define ASSERT(expression)
std::ostream & Restart(std::ostream &out) const
virtual const Vec3 & GetXCurr(void) const
void Sub(integer iRow, integer iCol, const FullMatrixHandler &source)
const StructDispNode * m_pNode
virtual ~ModuleNonsmoothNode(void)
static std::stack< cleanup * > c
const StructNode * AttNode
const doublereal * pdGetMat(void) const
void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph)
virtual void InitialWorkSpaceDim(integer *piNumRows, integer *piNumCols) const
bool SetUDE(const std::string &s, UserDefinedElemRead *rude)
VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
void PutVec(integer iCol, const Vec3 &v)
virtual const Vec3 & GetVCurr(void) const
int module_init(const char *module_name, void *pdm, void *php)
This function registers our user defined element for the math parser.
SparseSubMatrixHandler & SetSparse(void)
virtual void SetOutputFlag(flag f=flag(1))
virtual integer iGetFirstIndex(void) const
virtual HighParser::ErrOut GetLineData(void) const
unsigned int GetLabel(void) const
Node * ReadNode(MBDynParser &HP, Node::Type type) const
virtual VectorHandler & MatVecMul(VectorHandler &out, const VectorHandler &in) const
virtual std::ostream & DescribeDof(std::ostream &out, const char *prefix="", bool bInitial=false) const
static FullMatrixHandler IRa
virtual doublereal GetReal(const doublereal &dDefval=0.0)