00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include <ArrayOfTaggedObjects.h>
00031
00032 #include <LimitStateMaterial.h>
00033 #include <AxialCurve.h>
00034 #include <ThreePointCurve.h>
00035 #include <ShearCurve.h>
00036
00037
00038 #include <string.h>
00039
00040 static TaggedObjectStorage *theLimitCurves = 0;
00041 static Domain *theDomain = 0;
00042
00043 int
00044 Tcl_AddLimitCurve(ClientData clientData, Tcl_Interp *interp, int argc, TCL_Char **argv);
00045
00046
00047
00048
00049
00050
00051 int
00052 Tcl_AddLimitCurveCommand(Tcl_Interp *theInterp, Domain *theTclDomain)
00053 {
00054 Tcl_CreateCommand(theInterp, "limitCurve",
00055 Tcl_AddLimitCurve,
00056 (ClientData)NULL, NULL);
00057 theDomain = theTclDomain;
00058 return 0;
00059 }
00060
00061 int
00062 Tcl_RemoveLimitCurveCommand(Tcl_Interp *theInterp)
00063 {
00064 if (theLimitCurves != 0) {
00065 theLimitCurves->clearAll();
00066 delete theLimitCurves;
00067 theLimitCurves = 0;
00068 }
00069
00070 return Tcl_DeleteCommand(theInterp, "limitCurve");
00071 }
00072
00073
00074
00075
00076
00077
00078 int
00079 AddLimitCurve(LimitCurve &theCurve)
00080 {
00081 if (theLimitCurves == 0) {
00082 theLimitCurves = new ArrayOfTaggedObjects(32);
00083 if (theLimitCurves == 0) {
00084 opserr << "AddLimitCurve() - failed to add limit curve: " << theCurve;
00085 }
00086 }
00087 bool result = theLimitCurves->addComponent(&theCurve);
00088 if (result == true)
00089 return 0;
00090 else {
00091 opserr << "AddLimitCurve() - failed to add limit curve: " << theCurve;
00092 return -1;
00093 }
00094 }
00095
00096
00097 LimitCurve *
00098 GetLimitCurve(int tag)
00099 {
00100 if (theLimitCurves == 0)
00101 return 0;
00102
00103 TaggedObject *mc = theLimitCurves->getComponentPtr(tag);
00104 if (mc == 0)
00105 return 0;
00106
00107
00108 LimitCurve *result = (LimitCurve *)mc;
00109 return result;
00110 }
00111
00112 static void printCommand(int argc, TCL_Char **argv)
00113 {
00114 opserr << "Input command: ";
00115 for (int i=0; i<argc; i++)
00116 opserr << argv[i] << " ";
00117 opserr << endln;
00118 }
00119
00120
00121
00122
00123
00124 int
00125 Tcl_AddLimitCurve(ClientData clientData, Tcl_Interp *interp, int argc, TCL_Char **argv)
00126 {
00127
00128
00129 if (argc < 8) {
00130 opserr << "WARNING insufficient number of limit curve arguments\n";
00131 opserr << "Want: limitCurve type? tag? <specific curve args>" << endln;
00132 return TCL_ERROR;
00133 }
00134
00135
00136 LimitCurve *theCurve = 0;
00137
00138
00139
00141
00143 if (strcmp(argv[1],"Axial") == 0) {
00144 if (argc != 9 && argc != 12 && argc != 14 && argc != 15) {
00145 opserr << "WARNING invalid number of arguments\n";
00146
00147 opserr << "Want: limitCurve Axial tag? eleTag? Fsw? Kdeg? Fres? defType? forType?" << endln;
00148 opserr << "<ndI? ndJ? dof? perpDirn? delta? eleRemove?>" << endln;
00149 return TCL_ERROR;
00150 }
00151
00152 int tag;
00153 int eleTag;
00154 double Fsw;
00155
00156
00157 double Kdeg;
00158 double Fres;
00159 int defType, forType;
00160 int ndI = 0;
00161 int ndJ = 0;
00162 int dof = 0;
00163 int perpDirn = 0;
00164 int eleRemove = 0;
00165 double delta = 0.0;
00166
00167 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00168 opserr << "WARNING invalid Axial LimitCurve tag" << endln;
00169 return TCL_ERROR;
00170 }
00171
00172 if (Tcl_GetInt(interp, argv[3], &eleTag) != TCL_OK) {
00173 opserr << "WARNING invalid element tag for associated beam-column element (eleTag)\n";
00174 opserr << "LimitCurve Axial: " << tag << endln;
00175 return TCL_ERROR;
00176 }
00177
00178 if (Tcl_GetDouble(interp,argv[4], &Fsw) != TCL_OK) {
00179 opserr << "WARNING invalid Fsw\n";
00180 opserr << "LimitCurve Axial: " << tag << endln;
00181 return TCL_ERROR;
00182 }
00183
00184
00185
00186 if (Tcl_GetDouble(interp,argv[5], &Kdeg) != TCL_OK) {
00187 opserr << "WARNING invalid degrading slope Kdeg\n";
00188 opserr << "LimitCurve Axial: " << tag << endln;
00189 return TCL_ERROR;
00190 }
00191
00192 if (Tcl_GetDouble(interp,argv[6], &Fres) != TCL_OK) {
00193 opserr << "WARNING invalid residual capacity Fres\n";
00194 opserr << "LimitCurve Axial: " << tag << endln;
00195 return TCL_ERROR;
00196 }
00197
00198
00199 if (Tcl_GetInt(interp,argv[7], &defType) != TCL_OK) {
00200 opserr << "WARNING invalid deformation type defType\n";
00201 opserr << "LimitCurve Axial: " << tag << endln;
00202 return TCL_ERROR;
00203 }
00204
00205 if (Tcl_GetInt(interp,argv[8], &forType) != TCL_OK) {
00206 opserr << "WARNING invalid force type forType\n";
00207 opserr << "LimitCurve Axial: " << tag << endln;
00208 return TCL_ERROR;
00209 }
00210
00211 if (defType == 2)
00212 {
00213 if (Tcl_GetInt(interp,argv[9], &ndI) != TCL_OK) {
00214 opserr << "WARNING invalid node I\n";
00215 opserr << "LimitCurve Axial: " << tag << endln;
00216 return TCL_ERROR;
00217 }
00218
00219 if (Tcl_GetInt(interp,argv[10], &ndJ) != TCL_OK) {
00220 opserr << "WARNING invalid node J\n";
00221 opserr << "LimitCurve Axial: " << tag << endln;
00222 return TCL_ERROR;
00223 }
00224
00225 if (Tcl_GetInt(interp,argv[11], &dof) != TCL_OK) {
00226 opserr << "WARNING invalid degree of freedom for drift\n";
00227 opserr << "LimitCurve Axial: " << tag << endln;
00228 return TCL_ERROR;
00229 }
00230
00231 if (Tcl_GetInt(interp,argv[12], &perpDirn) != TCL_OK) {
00232 opserr << "WARNING invalid direction for column length\n";
00233 opserr << "LimitCurve Axial: " << tag << endln;
00234 return TCL_ERROR;
00235 }
00236 }
00237
00238
00239 if (argc >= 14) {
00240
00241 if (Tcl_GetDouble(interp,argv[13], &delta) != TCL_OK) {
00242 opserr << "WARNING invalid shift in drift surface (delta)\n";
00243 opserr << "LimitCurve Axial: " << tag << endln;
00244 return TCL_ERROR;
00245 }
00246 }
00247 if (argc >= 15) {
00248
00249 if (Tcl_GetInt(interp,argv[14], &eleRemove) != TCL_OK) {
00250 opserr << "WARNING invalid element removal option\n";
00251 opserr << "LimitCurve Axial: " << tag << endln;
00252 return TCL_ERROR;
00253 }
00254 }
00255
00256
00257
00258
00259 theCurve = new AxialCurve(interp, tag, eleTag, theDomain, Fsw,
00260 Kdeg, Fres, defType, forType, ndI, ndJ, dof-1, perpDirn-1,
00261 delta, eleRemove);
00262 }
00263
00265
00267 else if (strcmp(argv[1],"ThreePoint") == 0) {
00268 if (argc < 14 || argc > 18) {
00269 opserr << "WARNING insufficient arguments\n";
00270
00271 opserr << "Want: limitCurve ThreePoint tag? eleTag? x1? y1? x2? y2? x3? y3?";
00272 opserr << "Kdeg? Fres? defType? forType?" << endln;
00273 opserr << "<ndI? ndJ? dof? perpDirn?>" << endln;
00274 return TCL_ERROR;
00275 }
00276
00277 int tag;
00278 int eleTag;
00279 double Kdeg;
00280 double Fres;
00281 int defType, forType;
00282 double x1, y1;
00283 double x2, y2;
00284 double x3, y3;
00285 int ndI = 0;
00286 int ndJ = 0;
00287 int dof = 0;
00288 int perpDirn = 0;
00289
00290
00291 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00292 opserr << "WARNING invalid limitCurve ThreePoint tag" << endln;
00293 return TCL_ERROR;
00294 }
00295
00296 if (Tcl_GetInt(interp, argv[3], &eleTag) != TCL_OK) {
00297 opserr << "WARNING invalid element tag for associated beam-column element (eleTag)\n";
00298 opserr << "LimitCurve ThreePoint: " << tag << endln;
00299 return TCL_ERROR;
00300 }
00301
00302 if (Tcl_GetDouble(interp, argv[4], &x1) != TCL_OK) {
00303 opserr << "WARNING invalid x1\n";
00304 opserr << "limitCurve ThreePoint: " << tag << endln;
00305 return TCL_ERROR;
00306 }
00307
00308 if (Tcl_GetDouble(interp, argv[5], &y1) != TCL_OK) {
00309 opserr << "WARNING invalid y1\n";
00310 opserr << "limitCurve ThreePoint: " << tag << endln;
00311 return TCL_ERROR;
00312 }
00313
00314 if (Tcl_GetDouble(interp, argv[6], &x2) != TCL_OK) {
00315 opserr << "WARNING invalid x2\n";
00316 opserr << "limitCurve ThreePoint: " << tag << endln;
00317 return TCL_ERROR;
00318 }
00319
00320 if (Tcl_GetDouble(interp, argv[7], &y2) != TCL_OK) {
00321 opserr << "WARNING invalid y2\n";
00322 opserr << "limitCurve ThreePoint: " << tag << endln;
00323 return TCL_ERROR;
00324 }
00325
00326 if (Tcl_GetDouble(interp, argv[8], &x3) != TCL_OK) {
00327 opserr << "WARNING invalid x3\n";
00328 opserr << "limitCurve ThreePoint: " << tag << endln;
00329 return TCL_ERROR;
00330 }
00331
00332 if (Tcl_GetDouble(interp, argv[9], &y3) != TCL_OK) {
00333 opserr << "WARNING invalid y3\n";
00334 opserr << "limitCurve ThreePoint: " << tag << endln;
00335 return TCL_ERROR;
00336 }
00337
00338 if (Tcl_GetDouble(interp,argv[10], &Kdeg) != TCL_OK) {
00339 opserr << "WARNING invalid degrading slope Kdeg\n";
00340 opserr << "LimitCurve ThreePoint: " << tag << endln;
00341 return TCL_ERROR;
00342 }
00343
00344 if (Tcl_GetDouble(interp,argv[11], &Fres) != TCL_OK) {
00345 opserr << "WARNING invalid residual capacity Fres\n";
00346 opserr << "LimitCurve ThreePoint: " << tag << endln;
00347 return TCL_ERROR;
00348 }
00349
00350 if (Tcl_GetInt(interp,argv[12], &defType) != TCL_OK) {
00351 opserr << "WARNING invalid deformation type defType\n";
00352 opserr << "LimitCurve ThreePoint: " << tag << endln;
00353 return TCL_ERROR;
00354 }
00355
00356 if (Tcl_GetInt(interp,argv[13], &forType) != TCL_OK) {
00357 opserr << "WARNING invalid force type forType\n";
00358 opserr << "LimitCurve ThreePoint: " << tag << endln;
00359 return TCL_ERROR;
00360 }
00361
00362 if (defType == 2)
00363 {
00364 if (Tcl_GetInt(interp,argv[14], &ndI) != TCL_OK) {
00365 opserr << "WARNING invalid node I\n";
00366 opserr << "LimitCurve ThreePoint: " << tag << endln;
00367 return TCL_ERROR;
00368 }
00369
00370 if (Tcl_GetInt(interp,argv[15], &ndJ) != TCL_OK) {
00371 opserr << "WARNING invalid node J\n";
00372 opserr << "LimitCurve ThreePoint: " << tag << endln;
00373 return TCL_ERROR;
00374 }
00375
00376 if (Tcl_GetInt(interp,argv[16], &dof) != TCL_OK) {
00377 opserr << "WARNING invalid degree of freedom for drift\n";
00378 opserr << "LimitCurve ThreePoint: " << tag << endln;
00379 return TCL_ERROR;
00380 }
00381
00382 if (Tcl_GetInt(interp,argv[17], &perpDirn) != TCL_OK) {
00383 opserr << "WARNING invalid direction for column length\n";
00384 opserr << "LimitCurve ThreePoint: " << tag << endln;
00385 return TCL_ERROR;
00386 }
00387
00388
00389 }
00390
00391
00392
00393
00394 theCurve = new ThreePointCurve(tag, eleTag, theDomain,
00395 x1, y1, x2, y2, x3, y3, Kdeg, Fres, defType, forType,
00396 ndI, ndJ, dof-1, perpDirn-1);
00397 }
00398
00400
00402 else if (strcmp(argv[1],"Shear") == 0) {
00403 if (argc < 14 || argc > 19) {
00404 opserr << "WARNING insufficient arguments\n";
00405
00406 opserr << "Want: limitCurve Shear tag? eleTag? rho? fc? b? h? d? Fsw? ";
00407 opserr << "Kdeg? Fres? defType? forType?" << endln;
00408 opserr << "<ndI? ndJ? dof? perpDirn? delta?>" << endln;
00409 return TCL_ERROR;
00410 }
00411
00412 int tag;
00413 int eleTag;
00414 double Kdeg;
00415 double Fres;
00416 int defType, forType;
00417 double rho;
00418 double fc;
00419 double b, h, d;
00420 int ndI = 0;
00421 int ndJ = 0;
00422 int dof = 0;
00423 int perpDirn = 0;
00424 double Fsw = 0.0;
00425
00426 double delta =0.0;
00427
00428
00429 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00430 opserr << "WARNING invalid limitCurve Shear tag" << endln;
00431 return TCL_ERROR;
00432 }
00433
00434 if (Tcl_GetInt(interp, argv[3], &eleTag) != TCL_OK) {
00435 opserr << "WARNING invalid element tag for associated beam-column element (eleTag)\n";
00436 opserr << "LimitCurve Shear: " << tag << endln;
00437 return TCL_ERROR;
00438 }
00439
00440 if (Tcl_GetDouble(interp, argv[4], &rho) != TCL_OK) {
00441 opserr << "WARNING invalid trans reinf ratio\n";
00442 opserr << "limitCurve Shear: " << tag << endln;
00443 return TCL_ERROR;
00444 }
00445
00446 if (Tcl_GetDouble(interp, argv[5], &fc) != TCL_OK) {
00447 opserr << "WARNING invalid concrete strength\n";
00448 opserr << "limitCurve Shear: " << tag << endln;
00449 return TCL_ERROR;
00450 }
00451
00452 if (Tcl_GetDouble(interp, argv[6], &b) != TCL_OK) {
00453 opserr << "WARNING invalid b\n";
00454 opserr << "limitCurve Shear: " << tag << endln;
00455 return TCL_ERROR;
00456 }
00457
00458 if (Tcl_GetDouble(interp, argv[7], &h) != TCL_OK) {
00459 opserr << "WARNING invalid h\n";
00460 opserr << "limitCurve Shear: " << tag << endln;
00461 return TCL_ERROR;
00462 }
00463
00464 if (Tcl_GetDouble(interp, argv[8], &d) != TCL_OK) {
00465 opserr << "WARNING invalid d\n";
00466 opserr << "limitCurve Shear: " << tag << endln;
00467 return TCL_ERROR;
00468 }
00469
00470 if (Tcl_GetDouble(interp, argv[9], &Fsw) != TCL_OK) {
00471 opserr << "WARNING invalid Fsw\n";
00472 opserr << "limitCurve Shear: " << tag << endln;
00473 return TCL_ERROR;
00474 }
00475
00476
00477 if (Tcl_GetDouble(interp,argv[10], &Kdeg) != TCL_OK) {
00478 opserr << "WARNING invalid degrading slope Kdeg\n";
00479 opserr << "LimitCurve Shear: " << tag << endln;
00480 return TCL_ERROR;
00481 }
00482
00483 if (Tcl_GetDouble(interp,argv[11], &Fres) != TCL_OK) {
00484 opserr << "WARNING invalid residual capacity Fres\n";
00485 opserr << "LimitCurve Shear: " << tag << endln;
00486 return TCL_ERROR;
00487 }
00488
00489 if (Tcl_GetInt(interp,argv[12], &defType) != TCL_OK) {
00490 opserr << "WARNING invalid deformation type defType\n";
00491 opserr << "LimitCurve Shear: " << tag << endln;
00492 return TCL_ERROR;
00493 }
00494
00495 if (Tcl_GetInt(interp,argv[13], &forType) != TCL_OK) {
00496 opserr << "WARNING invalid force type forType\n";
00497 opserr << "LimitCurve Shear: " << tag << endln;
00498 return TCL_ERROR;
00499 }
00500
00501 if (defType == 2)
00502 {
00503 if (Tcl_GetInt(interp,argv[14], &ndI) != TCL_OK) {
00504 opserr << "WARNING invalid node I\n";
00505 opserr << "LimitCurve Shear: " << tag << endln;
00506 return TCL_ERROR;
00507 }
00508
00509 if (Tcl_GetInt(interp,argv[15], &ndJ) != TCL_OK) {
00510 opserr << "WARNING invalid node J\n";
00511 opserr << "LimitCurve Shear: " << tag << endln;
00512 return TCL_ERROR;
00513 }
00514
00515 if (Tcl_GetInt(interp,argv[16], &dof) != TCL_OK) {
00516 opserr << "WARNING invalid degree of freedom for drift\n";
00517 opserr << "LimitCurve Shear: " << tag << endln;
00518 return TCL_ERROR;
00519 }
00520
00521 if (Tcl_GetInt(interp,argv[17], &perpDirn) != TCL_OK) {
00522 opserr << "WARNING invalid direction for column length\n";
00523 opserr << "LimitCurve Shear: " << tag << endln;
00524 return TCL_ERROR;
00525 }
00526
00527 }
00528
00529 if (argc == 19)
00530 {
00531 if (Tcl_GetDouble(interp,argv[18], &delta) != TCL_OK) {
00532 opserr << "WARNING invalid shift in drift surface (delta)\n";
00533 opserr << "LimitCurve Shear: " << tag << endln;
00534 return TCL_ERROR;
00535 }
00536 }
00537
00538
00539
00540
00541
00542
00543 theCurve = new ShearCurve(tag, eleTag, theDomain,
00544 rho, fc, b, h, d, Fsw, Kdeg, Fres, defType, forType,
00545 ndI, ndJ, dof-1, perpDirn-1, delta);
00546 }
00547
00548
00549
00550 else {
00551 opserr << "WARNING unknown type of limitCurve: " << argv[1];
00552 opserr << "\nValid types: Axial, ThreePoint, Shear" << endln;
00553 return TCL_ERROR;
00554 }
00555
00556
00557 if (theCurve == 0) {
00558 opserr << "WARNING ran out of memory creating limitCurve\n";
00559 opserr << argv[1] << endln;
00560 return TCL_ERROR;
00561 }
00562
00563
00564 if (AddLimitCurve(*theCurve) < 0) {
00565 opserr << "WARNING could not add limitCurve to the domain\n";
00566 opserr << *theCurve << endln;
00567 delete theCurve;
00568 return TCL_ERROR;
00569 }
00570
00571 return TCL_OK;
00572 }
00573
00574
00575
00576
00577
00578
00579 UniaxialMaterial *
00580 Tcl_AddLimitStateMaterial(ClientData clientData, Tcl_Interp *interp, int argc, TCL_Char **argv)
00581 {
00582 if (strcmp(argv[1],"LimitState") != 0)
00583 return 0;
00584
00585 UniaxialMaterial *theMaterial = 0;
00586
00587 if (argc != 20 && argc != 19 && argc != 16 && argc != 15 && argc != 22 && argc != 23) {
00588 opserr << "WARNING insufficient arguments\n";
00589 printCommand(argc,argv);
00590 opserr << "Want: uniaxialMaterial LimitState tag? mom1p? rot1p? mom2p? rot2p? mom3p? rot3p? "
00591 << "\nmom1n? rot1n? mom2n? rot2n? mom3n? rot3n? pinchX? pinchY? damfc1? damfc2? beta? "
00592 << "\n<curveTag? curveType? degrade?>";
00593 return theMaterial;
00594 }
00595
00596 int tag;
00597 double mom1p, mom2p, mom3p;
00598 double rot1p, rot2p, rot3p;
00599 double mom1n, mom2n, mom3n;
00600 double rot1n, rot2n, rot3n;
00601 double pinchX, pinchY;
00602 double damfc1, damfc2;
00603 double beta = 0.0;
00604 int curveTag;
00605 int curveType;
00606 int degrade = 0;
00607
00608 int i = 2;
00609
00610 if (Tcl_GetInt(interp, argv[i++], &tag) != TCL_OK) {
00611 opserr << "WARNING invalid uniaxialMaterial LimitState tag" << endln;
00612 return theMaterial;
00613 }
00614
00615 if (Tcl_GetDouble(interp, argv[i++], &mom1p) != TCL_OK) {
00616 opserr << "WARNING invalid mom1p\n";
00617 opserr << "LimitState material: " << tag << endln;
00618 return theMaterial;
00619 }
00620
00621 if (Tcl_GetDouble(interp, argv[i++], &rot1p) != TCL_OK) {
00622 opserr << "WARNING invalid rot1p\n";
00623 opserr << "LimitState material: " << tag << endln;
00624 return theMaterial;
00625 }
00626
00627 if (Tcl_GetDouble(interp, argv[i++], &mom2p) != TCL_OK) {
00628 opserr << "WARNING invalid mom2p\n";
00629 opserr << "LimitState material: " << tag << endln;
00630 return theMaterial;
00631 }
00632
00633 if (Tcl_GetDouble(interp, argv[i++], &rot2p) != TCL_OK) {
00634 opserr << "WARNING invalid rot2p\n";
00635 opserr << "LimitState material: " << tag << endln;
00636 return theMaterial;
00637 }
00638
00639 if (argc > 16) {
00640 if (Tcl_GetDouble(interp, argv[i++], &mom3p) != TCL_OK) {
00641 opserr << "WARNING invalid mom3p\n";
00642 opserr << "LimitState material: " << tag << endln;
00643 return theMaterial;
00644 }
00645
00646 if (Tcl_GetDouble(interp, argv[i++], &rot3p) != TCL_OK) {
00647 opserr << "WARNING invalid rot3p\n";
00648 opserr << "LimitState material: " << tag << endln;
00649 return theMaterial;
00650 }
00651 }
00652
00653 if (Tcl_GetDouble(interp, argv[i++], &mom1n) != TCL_OK) {
00654 opserr << "WARNING invalid mom1n\n";
00655 opserr << "LimitState material: " << tag << endln;
00656 return theMaterial;
00657 }
00658
00659 if (Tcl_GetDouble(interp, argv[i++], &rot1n) != TCL_OK) {
00660 opserr << "WARNING invalid rot1n\n";
00661 opserr << "LimitState material: " << tag << endln;
00662 return theMaterial;
00663 }
00664
00665 if (Tcl_GetDouble(interp, argv[i++], &mom2n) != TCL_OK) {
00666 opserr << "WARNING invalid mom2n\n";
00667 opserr << "LimitState material: " << tag << endln;
00668 return theMaterial;
00669 }
00670
00671 if (Tcl_GetDouble(interp, argv[i++], &rot2n) != TCL_OK) {
00672 opserr << "WARNING invalid rot2n\n";
00673 opserr << "LimitState material: " << tag << endln;
00674 return theMaterial;
00675 }
00676
00677 if (argc > 16) {
00678 if (Tcl_GetDouble(interp, argv[i++], &mom3n) != TCL_OK) {
00679 opserr << "WARNING invalid mom3n\n";
00680 opserr << "LimitState material: " << tag << endln;
00681 return theMaterial;
00682 }
00683
00684 if (Tcl_GetDouble(interp, argv[i++], &rot3n) != TCL_OK) {
00685 opserr << "WARNING invalid rot3n\n";
00686 opserr << "LimitState material: " << tag << endln;
00687 return theMaterial;
00688 }
00689 }
00690
00691 if (Tcl_GetDouble(interp, argv[i++], &pinchX) != TCL_OK) {
00692 opserr << "WARNING invalid pinchX\n";
00693 opserr << "LimitState material: " << tag << endln;
00694 return theMaterial;
00695 }
00696
00697 if (Tcl_GetDouble(interp, argv[i++], &pinchY) != TCL_OK) {
00698 opserr << "WARNING invalid pinchY\n";
00699 opserr << "LimitState material: " << tag << endln;
00700 return theMaterial;
00701 }
00702
00703 if (Tcl_GetDouble(interp, argv[i++], &damfc1) != TCL_OK) {
00704 opserr << "WARNING invalid damfc1\n";
00705 opserr << "LimitState material: " << tag << endln;
00706 return theMaterial;
00707 }
00708
00709 if (Tcl_GetDouble(interp, argv[i++], &damfc2) != TCL_OK) {
00710 opserr << "WARNING invalid damfc2\n";
00711 opserr << "LimitState material: " << tag << endln;
00712 return theMaterial;
00713 }
00714
00715 if (argc == 20 || argc == 16 || argc >= 22 ) {
00716 if (Tcl_GetDouble(interp, argv[i++], &beta) != TCL_OK) {
00717 opserr << "WARNING invalid beta\n";
00718 opserr << "LimitState material: " << tag << endln;
00719 return theMaterial;
00720 }
00721 }
00722
00723 if (argc == 22 || argc == 23) {
00724 if (Tcl_GetInt(interp, argv[i++], &curveTag) != TCL_OK) {
00725 opserr << "WARNING invalid tag for LimitCurve (curveTag)\n";
00726 opserr << "LimitState material: " << tag << endln;
00727 return theMaterial;
00728 }
00729
00730 LimitCurve *theCurve = GetLimitCurve(curveTag);
00731
00732 if (theCurve == 0) {
00733 opserr << "WARNING limit curve does not exist\n";
00734 opserr << "limit curve: " << curveTag;
00735 opserr << "\nLimitStateMaterial: " << tag << endln;
00736 return theMaterial;
00737 }
00738
00739 if (Tcl_GetInt(interp, argv[i++], &curveType) != TCL_OK) {
00740 opserr << "WARNING invalid curveType\n";
00741 opserr << "LimitState material: " << tag << endln;
00742 return theMaterial;
00743 }
00744
00745 if (argc == 23) {
00746 if (Tcl_GetInt(interp, argv[i++], °rade) != TCL_OK) {
00747 opserr << "WARNING invalid degrade option\n";
00748 opserr << "LimitState material: " << tag << endln;
00749 return theMaterial;
00750 }
00751 }
00752
00753 theMaterial = new LimitStateMaterial (tag,
00754 mom1p, rot1p, mom2p, rot2p, mom3p, rot3p,
00755 mom1n, rot1n, mom2n, rot2n, mom3n, rot3n,
00756 pinchX, pinchY, damfc1, damfc2, beta,
00757 *theCurve, curveType, degrade);
00758 }
00759
00760
00761 if (argc == 20 || argc == 19)
00762 theMaterial = new LimitStateMaterial (tag,
00763 mom1p, rot1p, mom2p, rot2p, mom3p, rot3p,
00764 mom1n, rot1n, mom2n, rot2n, mom3n, rot3n,
00765 pinchX, pinchY, damfc1, damfc2, beta);
00766
00767 else if (argc == 16 || argc == 15)
00768 theMaterial = new LimitStateMaterial (tag,
00769 mom1p, rot1p, mom2p, rot2p,
00770 mom1n, rot1n, mom2n, rot2n,
00771 pinchX, pinchY, damfc1, damfc2, beta);
00772
00773 return theMaterial;
00774 }
00775