/opensees-websocket/SRC/element/frictionBearing/TclSingleFPCommand.cpp

https://code.google.com/ · C++ · 517 lines · 440 code · 30 blank · 47 comment · 175 complexity · 9edf20687506d2c4ffc462344b9fe7b3 MD5 · raw file

  1. /* ****************************************************************** **
  2. ** OpenSees - Open System for Earthquake Engineering Simulation **
  3. ** Pacific Earthquake Engineering Research Center **
  4. ** **
  5. ** **
  6. ** (C) Copyright 1999, The Regents of the University of California **
  7. ** All Rights Reserved. **
  8. ** **
  9. ** Commercial use of this program without express permission of the **
  10. ** University of California, Berkeley, is strictly prohibited. See **
  11. ** file 'COPYRIGHT' in main directory for information on usage and **
  12. ** redistribution, and for a DISCLAIMER OF ALL WARRANTIES. **
  13. ** **
  14. ** Developed by: **
  15. ** Frank McKenna (fmckenna@ce.berkeley.edu) **
  16. ** Gregory L. Fenves (fenves@ce.berkeley.edu) **
  17. ** Filip C. Filippou (filippou@ce.berkeley.edu) **
  18. ** **
  19. ** ****************************************************************** */
  20. // $Revision$
  21. // $Date$
  22. // $URL$
  23. // Written: Andreas Schellenberg (andreas.schellenberg@gmx.net)
  24. // Created: 02/06
  25. // Revision: A
  26. //
  27. // Description: This file contains the function to parse the TCL input
  28. // for the singleFPBearing element.
  29. #include <TclModelBuilder.h>
  30. #include <stdlib.h>
  31. #include <string.h>
  32. #include <Domain.h>
  33. #include <ID.h>
  34. #include <Vector.h>
  35. #include <SingleFPSimple2d.h>
  36. #include <SingleFPSimple3d.h>
  37. #include <FrictionModel.h>
  38. #include <UniaxialMaterial.h>
  39. extern void printCommand(int argc, TCL_Char **argv);
  40. int TclModelBuilder_addSingleFPBearing(ClientData clientData, Tcl_Interp *interp, int argc,
  41. TCL_Char **argv, Domain *theTclDomain,
  42. TclModelBuilder *theTclBuilder, int eleArgStart)
  43. {
  44. // ensure the destructor has not been called
  45. if (theTclBuilder == 0) {
  46. opserr << "WARNING builder has been destroyed - singleFPBearing\n";
  47. return TCL_ERROR;
  48. }
  49. Element *theElement = 0;
  50. int ndm = theTclBuilder->getNDM();
  51. int ndf = theTclBuilder->getNDF();
  52. int tag;
  53. if (ndm == 2) {
  54. // check plane frame problem has 3 dof per node
  55. if (ndf != 3) {
  56. opserr << "WARNING invalid ndf: " << ndf;
  57. opserr << ", for plane problem need 3 - singleFPBearing\n";
  58. return TCL_ERROR;
  59. }
  60. // check the number of arguments is correct
  61. if ((argc-eleArgStart) < 12) {
  62. opserr << "WARNING insufficient arguments\n";
  63. printCommand(argc, argv);
  64. opserr << "Want: singleFPBearing eleTag iNode jNode frnMdlTag R h uy -P matTag -Mz matTag <-orient x1 x2 x3 y1 y2 y3> <-mass m> <-iter maxIter tol>\n";
  65. return TCL_ERROR;
  66. }
  67. // get the id and end nodes
  68. int iNode, jNode, frnMdlTag, matTag, argi, i, j;
  69. int recvMat = 0;
  70. double R, h, uy;
  71. double mass = 0.0;
  72. int maxIter = 20;
  73. double tol = 1E-8;
  74. if (Tcl_GetInt(interp, argv[1+eleArgStart], &tag) != TCL_OK) {
  75. opserr << "WARNING invalid singleFPBearing eleTag\n";
  76. return TCL_ERROR;
  77. }
  78. if (Tcl_GetInt(interp, argv[2+eleArgStart], &iNode) != TCL_OK) {
  79. opserr << "WARNING invalid iNode\n";
  80. opserr << "singleFPBearing element: " << tag << endln;
  81. return TCL_ERROR;
  82. }
  83. if (Tcl_GetInt(interp, argv[3+eleArgStart], &jNode) != TCL_OK) {
  84. opserr << "WARNING invalid jNode\n";
  85. opserr << "singleFPBearing element: " << tag << endln;
  86. return TCL_ERROR;
  87. }
  88. if (Tcl_GetInt(interp, argv[4+eleArgStart], &frnMdlTag) != TCL_OK) {
  89. opserr << "WARNING invalid frnMdlTag\n";
  90. opserr << "singleFPBearing element: " << tag << endln;
  91. return TCL_ERROR;
  92. }
  93. FrictionModel *theFrnMdl = OPS_getFrictionModel(frnMdlTag);
  94. if (theFrnMdl == 0) {
  95. opserr << "WARNING friction model not found\n";
  96. opserr << "frictionModel: " << frnMdlTag << endln;
  97. opserr << "singleFPBearing element: " << tag << endln;
  98. return TCL_ERROR;
  99. }
  100. if (Tcl_GetDouble(interp, argv[5+eleArgStart], &R) != TCL_OK) {
  101. opserr << "WARNING invalid R\n";
  102. opserr << "singleFPBearing element: " << tag << endln;
  103. return TCL_ERROR;
  104. }
  105. if (Tcl_GetDouble(interp, argv[6+eleArgStart], &h) != TCL_OK) {
  106. opserr << "WARNING invalid h\n";
  107. opserr << "singleFPBearing element: " << tag << endln;
  108. return TCL_ERROR;
  109. }
  110. if (Tcl_GetDouble(interp, argv[7+eleArgStart], &uy) != TCL_OK) {
  111. opserr << "WARNING invalid uy\n";
  112. opserr << "singleFPBearing element: " << tag << endln;
  113. return TCL_ERROR;
  114. }
  115. UniaxialMaterial *theMaterials[2];
  116. for (i = 8+eleArgStart; i < argc; i++) {
  117. if (i+1 < argc && strcmp(argv[i], "-P") == 0) {
  118. theMaterials[0] = 0;
  119. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  120. opserr << "WARNING invalid matTag\n";
  121. opserr << "singleFPBearing element: " << tag << endln;
  122. return TCL_ERROR;
  123. }
  124. theMaterials[0] = OPS_getUniaxialMaterial(matTag);
  125. if (theMaterials[0] == 0) {
  126. opserr << "WARNING material model not found\n";
  127. opserr << "uniaxialMaterial: " << matTag << endln;
  128. opserr << "singleFPBearing element: " << tag << endln;
  129. return TCL_ERROR;
  130. }
  131. recvMat++;
  132. }
  133. }
  134. for (i = 8+eleArgStart; i < argc; i++) {
  135. if (i+1 < argc && strcmp(argv[i], "-Mz") == 0) {
  136. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  137. opserr << "WARNING invalid matTag\n";
  138. opserr << "singleFPBearing element: " << tag << endln;
  139. return TCL_ERROR;
  140. }
  141. theMaterials[1] = OPS_getUniaxialMaterial(matTag);
  142. if (theMaterials[1] == 0) {
  143. opserr << "WARNING material model not found\n";
  144. opserr << "uniaxialMaterial: " << matTag << endln;
  145. opserr << "singleFPBearing element: " << tag << endln;
  146. return TCL_ERROR;
  147. }
  148. recvMat++;
  149. }
  150. }
  151. if (recvMat != 2) {
  152. opserr << "WARNING wrong number of materials\n";
  153. opserr << "got " << recvMat << " materials, but want 2 materials\n";
  154. opserr << "singleFPBearing element: " << tag << endln;
  155. return TCL_ERROR;
  156. }
  157. // check for optional arguments
  158. Vector x = 0;
  159. Vector y = 0;
  160. for (i = 8+eleArgStart; i < argc; i++) {
  161. if (strcmp(argv[i],"-orient") == 0) {
  162. j = i+1;
  163. int numOrient = 0;
  164. while (j < argc &&
  165. strcmp(argv[j],"-mass") != 0 &&
  166. strcmp(argv[j],"-iter") != 0) {
  167. numOrient++;
  168. j++;
  169. }
  170. if (numOrient == 6) {
  171. argi = i+1;
  172. x.resize(3);
  173. y.resize(3);
  174. double value;
  175. // read the x values
  176. for (j=0; j<3; j++) {
  177. if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
  178. opserr << "WARNING invalid -orient value\n";
  179. opserr << "singleFPBearing element: " << tag << endln;
  180. return TCL_ERROR;
  181. } else {
  182. argi++;
  183. x(j) = value;
  184. }
  185. }
  186. // read the y values
  187. for (j=0; j<3; j++) {
  188. if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
  189. opserr << "WARNING invalid -orient value\n";
  190. opserr << "singleFPBearing element: " << tag << endln;
  191. return TCL_ERROR;
  192. } else {
  193. argi++;
  194. y(j) = value;
  195. }
  196. }
  197. }
  198. else {
  199. opserr << "WARNING insufficient arguments after -orient flag\n";
  200. opserr << "singleFPBearing element: " << tag << endln;
  201. return TCL_ERROR;
  202. }
  203. }
  204. }
  205. for (int i = 8+eleArgStart; i < argc; i++) {
  206. if (i+1 < argc && strcmp(argv[i], "-mass") == 0) {
  207. if (Tcl_GetDouble(interp, argv[i+1], &mass) != TCL_OK) {
  208. opserr << "WARNING invalid mass\n";
  209. opserr << "singleFPBearing element: " << tag << endln;
  210. return TCL_ERROR;
  211. }
  212. }
  213. }
  214. for (int i = 8+eleArgStart; i < argc; i++) {
  215. if (i+1 < argc && strcmp(argv[i], "-iter") == 0) {
  216. if (Tcl_GetInt(interp, argv[i+1], &maxIter) != TCL_OK) {
  217. opserr << "WARNING invalid maxIter\n";
  218. opserr << "singleFPBearing element: " << tag << endln;
  219. return TCL_ERROR;
  220. }
  221. if (Tcl_GetDouble(interp, argv[i+2], &tol) != TCL_OK) {
  222. opserr << "WARNING invalid tol\n";
  223. opserr << "singleFPBearing element: " << tag << endln;
  224. return TCL_ERROR;
  225. }
  226. }
  227. }
  228. // now create the singleFPBearing
  229. theElement = new SingleFPSimple2d(tag, iNode, jNode, *theFrnMdl, R, h, uy, theMaterials, y, x, mass, maxIter, tol);
  230. if (theElement == 0) {
  231. opserr << "WARNING ran out of memory creating element\n";
  232. opserr << "singleFPBearing element: " << tag << endln;
  233. return TCL_ERROR;
  234. }
  235. // then add the singleFPBearing to the domain
  236. if (theTclDomain->addElement(theElement) == false) {
  237. opserr << "WARNING could not add element to the domain\n";
  238. opserr << "singleFPBearing element: " << tag << endln;
  239. delete theElement;
  240. return TCL_ERROR;
  241. }
  242. }
  243. else if (ndm == 3) {
  244. // check space frame problem has 6 dof per node
  245. if (ndf != 6) {
  246. opserr << "WARNING invalid ndf: " << ndf;
  247. opserr << ", for space problem need 6 - singleFPBearing \n";
  248. return TCL_ERROR;
  249. }
  250. // check the number of arguments is correct
  251. if ((argc-eleArgStart) < 16) {
  252. opserr << "WARNING insufficient arguments\n";
  253. printCommand(argc, argv);
  254. opserr << "Want: singleFPBearing eleTag iNode jNode frnMdlTag R h uy -P matTag -T matTag -My matTag -Mz matTag <-orient <x1 x2 x3> y1 y2 y3> <-mass m> <-iter maxIter tol>\n";
  255. return TCL_ERROR;
  256. }
  257. // get the id and end nodes
  258. int iNode, jNode, frnMdlTag, matTag, argi, i, j;
  259. int recvMat = 0;
  260. double R, h, uy;
  261. double mass = 0.0;
  262. int maxIter = 20;
  263. double tol = 1E-8;
  264. if (Tcl_GetInt(interp, argv[1+eleArgStart], &tag) != TCL_OK) {
  265. opserr << "WARNING invalid singleFPBearing eleTag\n";
  266. return TCL_ERROR;
  267. }
  268. if (Tcl_GetInt(interp, argv[2+eleArgStart], &iNode) != TCL_OK) {
  269. opserr << "WARNING invalid iNode\n";
  270. opserr << "singleFPBearing element: " << tag << endln;
  271. return TCL_ERROR;
  272. }
  273. if (Tcl_GetInt(interp, argv[3+eleArgStart], &jNode) != TCL_OK) {
  274. opserr << "WARNING invalid jNode\n";
  275. opserr << "singleFPBearing element: " << tag << endln;
  276. return TCL_ERROR;
  277. }
  278. if (Tcl_GetInt(interp, argv[4+eleArgStart], &frnMdlTag) != TCL_OK) {
  279. opserr << "WARNING invalid frnMdlTag\n";
  280. opserr << "singleFPBearing element: " << tag << endln;
  281. return TCL_ERROR;
  282. }
  283. FrictionModel *theFrnMdl = OPS_getFrictionModel(frnMdlTag);
  284. if (theFrnMdl == 0) {
  285. opserr << "WARNING friction model not found\n";
  286. opserr << "frictionModel: " << frnMdlTag << endln;
  287. opserr << "singleFPBearing element: " << tag << endln;
  288. return TCL_ERROR;
  289. }
  290. if (Tcl_GetDouble(interp, argv[5+eleArgStart], &R) != TCL_OK) {
  291. opserr << "WARNING invalid R\n";
  292. opserr << "singleFPBearing element: " << tag << endln;
  293. return TCL_ERROR;
  294. }
  295. if (Tcl_GetDouble(interp, argv[6+eleArgStart], &h) != TCL_OK) {
  296. opserr << "WARNING invalid h\n";
  297. opserr << "singleFPBearing element: " << tag << endln;
  298. return TCL_ERROR;
  299. }
  300. if (Tcl_GetDouble(interp, argv[7+eleArgStart], &uy) != TCL_OK) {
  301. opserr << "WARNING invalid uy\n";
  302. opserr << "singleFPBearing element: " << tag << endln;
  303. return TCL_ERROR;
  304. }
  305. UniaxialMaterial *theMaterials[4];
  306. for (i = 8+eleArgStart; i < argc; i++) {
  307. if (i+1 < argc && strcmp(argv[i], "-P") == 0) {
  308. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  309. opserr << "WARNING invalid axial matTag\n";
  310. opserr << "singleFPBearing element: " << tag << endln;
  311. return TCL_ERROR;
  312. }
  313. theMaterials[0] = OPS_getUniaxialMaterial(matTag);
  314. if (theMaterials[0] == 0) {
  315. opserr << "WARNING material model not found\n";
  316. opserr << "uniaxialMaterial: " << matTag << endln;
  317. opserr << "singleFPBearing element: " << tag << endln;
  318. return TCL_ERROR;
  319. }
  320. recvMat++;
  321. }
  322. }
  323. for (i = 8+eleArgStart; i < argc; i++) {
  324. if (i+1 < argc && strcmp(argv[i], "-T") == 0) {
  325. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  326. opserr << "WARNING invalid torsional matTag\n";
  327. opserr << "singleFPBearing element: " << tag << endln;
  328. return TCL_ERROR;
  329. }
  330. theMaterials[1] = OPS_getUniaxialMaterial(matTag);
  331. if (theMaterials[1] == 0) {
  332. opserr << "WARNING material model not found\n";
  333. opserr << "uniaxialMaterial: " << matTag << endln;
  334. opserr << "singleFPBearing element: " << tag << endln;
  335. return TCL_ERROR;
  336. }
  337. recvMat++;
  338. }
  339. }
  340. for (i = 8+eleArgStart; i < argc; i++) {
  341. if (i+1 < argc && strcmp(argv[i], "-My") == 0) {
  342. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  343. opserr << "WARNING invalid moment y matTag\n";
  344. opserr << "singleFPBearing element: " << tag << endln;
  345. return TCL_ERROR;
  346. }
  347. theMaterials[2] = OPS_getUniaxialMaterial(matTag);
  348. if (theMaterials[2] == 0) {
  349. opserr << "WARNING material model not found\n";
  350. opserr << "uniaxialMaterial: " << matTag << endln;
  351. opserr << "singleFPBearing element: " << tag << endln;
  352. return TCL_ERROR;
  353. }
  354. recvMat++;
  355. }
  356. }
  357. for (i = 8+eleArgStart; i < argc; i++) {
  358. if (i+1 < argc && strcmp(argv[i], "-Mz") == 0) {
  359. if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
  360. opserr << "WARNING invalid moment z matTag\n";
  361. opserr << "singleFPBearing element: " << tag << endln;
  362. return TCL_ERROR;
  363. }
  364. theMaterials[3] = OPS_getUniaxialMaterial(matTag);
  365. if (theMaterials[3] == 0) {
  366. opserr << "WARNING material model not found\n";
  367. opserr << "uniaxialMaterial: " << matTag << endln;
  368. opserr << "singleFPBearing element: " << tag << endln;
  369. return TCL_ERROR;
  370. }
  371. recvMat++;
  372. }
  373. }
  374. if (recvMat != 4) {
  375. opserr << "WARNING wrong number of materials\n";
  376. opserr << "got " << recvMat << " materials, but want 4 materials\n";
  377. opserr << "singleFPBearing element: " << tag << endln;
  378. return TCL_ERROR;
  379. }
  380. // check for optional arguments
  381. Vector x(0);
  382. Vector y(3); y(0) = 0.0; y(1) = 1.0; y(2) = 0.0;
  383. for (i = 8+eleArgStart; i < argc; i++) {
  384. if (strcmp(argv[i],"-orient") == 0) {
  385. j = i+1;
  386. int numOrient = 0;
  387. while (j < argc &&
  388. strcmp(argv[j],"-mass") != 0 &&
  389. strcmp(argv[j],"-iter") != 0) {
  390. numOrient++;
  391. j++;
  392. }
  393. if (numOrient == 3) {
  394. argi = i+1;
  395. double value;
  396. // read the y values
  397. for (j=0; j<3; j++) {
  398. if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
  399. opserr << "WARNING invalid -orient value\n";
  400. opserr << "singleFPBearing element: " << tag << endln;
  401. return TCL_ERROR;
  402. } else {
  403. argi++;
  404. y(j) = value;
  405. }
  406. }
  407. }
  408. else if (numOrient == 6) {
  409. argi = i+1;
  410. x.resize(3);
  411. double value;
  412. // read the x values
  413. for (j=0; j<3; j++) {
  414. if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
  415. opserr << "WARNING invalid -orient value\n";
  416. opserr << "singleFPBearing element: " << tag << endln;
  417. return TCL_ERROR;
  418. } else {
  419. argi++;
  420. x(j) = value;
  421. }
  422. }
  423. // read the y values
  424. for (j=0; j<3; j++) {
  425. if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
  426. opserr << "WARNING invalid -orient value\n";
  427. opserr << "singleFPBearing element: " << tag << endln;
  428. return TCL_ERROR;
  429. } else {
  430. argi++;
  431. y(j) = value;
  432. }
  433. }
  434. }
  435. else {
  436. opserr << "WARNING insufficient arguments after -orient flag\n";
  437. opserr << "singleFPBearing element: " << tag << endln;
  438. return TCL_ERROR;
  439. }
  440. }
  441. }
  442. for (i = 8+eleArgStart; i < argc; i++) {
  443. if (i+1 < argc && strcmp(argv[i], "-mass") == 0) {
  444. if (Tcl_GetDouble(interp, argv[i+1], &mass) != TCL_OK) {
  445. opserr << "WARNING invalid mass\n";
  446. opserr << "singleFPBearing element: " << tag << endln;
  447. return TCL_ERROR;
  448. }
  449. }
  450. }
  451. for (int i = 8+eleArgStart; i < argc; i++) {
  452. if (i+1 < argc && strcmp(argv[i], "-iter") == 0) {
  453. if (Tcl_GetInt(interp, argv[i+1], &maxIter) != TCL_OK) {
  454. opserr << "WARNING invalid maxIter\n";
  455. opserr << "singleFPBearing element: " << tag << endln;
  456. return TCL_ERROR;
  457. }
  458. if (Tcl_GetDouble(interp, argv[i+2], &tol) != TCL_OK) {
  459. opserr << "WARNING invalid tol\n";
  460. opserr << "singleFPBearing element: " << tag << endln;
  461. return TCL_ERROR;
  462. }
  463. }
  464. }
  465. // now create the singleFPBearing
  466. theElement = new SingleFPSimple3d(tag, iNode, jNode, *theFrnMdl, R, h, uy, theMaterials, y, x, mass, maxIter, tol);
  467. if (theElement == 0) {
  468. opserr << "WARNING ran out of memory creating element\n";
  469. opserr << "singleFPBearing element: " << tag << endln;
  470. return TCL_ERROR;
  471. }
  472. // then add the singleFPBearing to the domain
  473. if (theTclDomain->addElement(theElement) == false) {
  474. opserr << "WARNING could not add element to the domain\n";
  475. opserr << "singleFPBearing element: " << tag << endln;
  476. delete theElement;
  477. return TCL_ERROR;
  478. }
  479. }
  480. else {
  481. opserr << "WARNING singleFPBearing command only works when ndm is 2 or 3, ndm: ";
  482. opserr << ndm << endln;
  483. return TCL_ERROR;
  484. }
  485. // if get here we have sucessfully created the singleFPBearing and added it to the domain
  486. return TCL_OK;
  487. }