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
00031
00032
00033
00034
00035
00036
00037
00038 #include <TclModelBuilder.h>
00039
00040 #include <ElasticIsotropicMaterial.h>
00041 #include <ElasticIsotropic3D.h>
00042 #include <PressureDependentElastic3D.h>
00043 #include <ElasticCrossAnisotropic.h>
00044 #include <J2Plasticity.h>
00045
00046 #include <MultiaxialCyclicPlasticity.h>
00047
00048 #include <PlaneStressMaterial.h>
00049 #include <PlateFiberMaterial.h>
00050 #include <BeamFiberMaterial.h>
00051
00052 #include <PressureIndependMultiYield.h>
00053 #include <PressureDependMultiYield.h>
00054 #include <PressureDependMultiYield02.h>
00055 #include <FluidSolidPorousMaterial.h>
00056
00057 #include <string.h>
00058
00059 #include <Template3Dep.h>
00060 #include <NewTemplate3Dep.h>
00061 #include <FiniteDeformationElastic3D.h>
00062 #include <FiniteDeformationEP3D.h>
00063
00064 Template3Dep *
00065 TclModelBuilder_addTemplate3Dep(ClientData clientData, Tcl_Interp *interp, int argc,
00066 TCL_Char **argv, TclModelBuilder *theTclBuilder, int eleArgStart);
00067
00068 NewTemplate3Dep *
00069 TclModelBuilder_addNewTemplate3Dep(ClientData clientData, Tcl_Interp *interp, int argc,
00070 TCL_Char **argv, TclModelBuilder *theTclBuilder, int eleArgStart);
00071
00072 FiniteDeformationElastic3D *
00073 TclModelBuilder_addFiniteDeformationElastic3D(ClientData clientData, Tcl_Interp *interp, int argc,
00074 TCL_Char **argv, TclModelBuilder *theTclBuilder, int eleArgStart);
00075
00076 FiniteDeformationEP3D *
00077 TclModelBuilder_addFiniteDeformationEP3D(ClientData clientData, Tcl_Interp *interp, int argc,
00078 TCL_Char **argv, TclModelBuilder *theTclBuilder, int eleArgStart);
00079
00080 NDMaterial *
00081 TclModelBuilder_addFeapMaterial(ClientData clientData, Tcl_Interp *interp,
00082 int argc, TCL_Char **argv,
00083 TclModelBuilder *theTclBuilder);
00084
00085
00086 static void printCommand(int argc, TCL_Char **argv)
00087 {
00088 opserr << "Input command: ";
00089 for (int i=0; i<argc; i++)
00090 opserr << argv[i] << " ";
00091 opserr << endln;
00092 }
00093
00094 int
00095 TclModelBuilderNDMaterialCommand (ClientData clientData, Tcl_Interp *interp, int argc,
00096 TCL_Char **argv, TclModelBuilder *theTclBuilder)
00097 {
00098
00099 if (argc < 3) {
00100 opserr << "WARNING insufficient number of ND material arguments\n";
00101 opserr << "Want: nDMaterial type? tag? <specific material args>" << endln;
00102 return TCL_ERROR;
00103 }
00104
00105
00106 NDMaterial *theMaterial = 0;
00107
00108
00109
00110
00111
00112 if (strcmp(argv[1],"PressureDependentElastic3D") == 0) {
00113 if (argc < 6) {
00114 opserr << "WARNING insufficient arguments\n";
00115 printCommand(argc,argv);
00116 opserr << "Want: nDMaterial PressureDependentElastic3D tag? E? v? rho?" << endln;
00117 return TCL_ERROR;
00118 }
00119
00120 int tag = 0;
00121 double E = 0.0;
00122 double v = 0.0;
00123 double rho = 0.0;
00124 double expp = 0.0;
00125 double prp = 0.0;
00126 double pop = 0.0;
00127
00128 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00129 opserr << "WARNING invalid PressureDependentElastic3D tag" << endln;
00130 return TCL_ERROR;
00131 }
00132
00133 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) {
00134 opserr << "WARNING invalid E\n";
00135 opserr << "nDMaterial PressureDependentElastic3D: E" << tag << endln;
00136 return TCL_ERROR;
00137 }
00138
00139 if (Tcl_GetDouble(interp, argv[4], &v) != TCL_OK) {
00140 opserr << "WARNING invalid v\n";
00141 opserr << "nDMaterial PressureDependentElastic3D: v" << tag << endln;
00142 return TCL_ERROR;
00143 }
00144
00145 if (Tcl_GetDouble(interp, argv[5], &rho) != TCL_OK) {
00146 opserr << "WARNING invalid v\n";
00147 opserr << "nDMaterial PressureDependentElastic3D: rho" << tag << endln;
00148 return TCL_ERROR;
00149 }
00150
00152 if( argc == 6 )
00153 {
00154 theMaterial = new PressureDependentElastic3D (tag, E, v, rho);
00155
00156 }
00158 else if( argc == 7 )
00159 {
00160
00161 if (Tcl_GetDouble(interp, argv[6], &expp) != TCL_OK) {
00162 opserr << "WARNING invalid v\n";
00163 opserr << "nDMaterial PressureDependentElastic3D: " << tag << endln;
00164 return TCL_ERROR;
00165 }
00166 theMaterial = new PressureDependentElastic3D (tag, E, v, rho, expp);
00167
00168 }
00170 else if (argc == 8 )
00171 {
00172
00173 if (Tcl_GetDouble(interp, argv[6], &expp) != TCL_OK) {
00174 opserr << "WARNING invalid v\n";
00175 opserr << "nDMaterial PressureDependentElastic3D: expp" << tag << endln;
00176 return TCL_ERROR;
00177 }
00178
00179 if (Tcl_GetDouble(interp, argv[7], &prp) != TCL_OK) {
00180 opserr << "WARNING invalid v\n";
00181 opserr << "nDMaterial PressureDependentElastic3D: prp " << tag << endln;
00182 return TCL_ERROR;
00183 }
00184
00185 theMaterial = new PressureDependentElastic3D (tag, E, v, rho, expp, prp);
00186 }
00188 else if (argc >= 9 )
00189 {
00190
00191 if (Tcl_GetDouble(interp, argv[6], &expp) != TCL_OK) {
00192 opserr << "WARNING invalid v\n";
00193 opserr << "nDMaterial PressureDependentElastic3D: expp" << tag << endln;
00194 return TCL_ERROR;
00195 }
00196
00197 if (Tcl_GetDouble(interp, argv[7], &prp) != TCL_OK) {
00198 opserr << "WARNING invalid v\n";
00199 opserr << "nDMaterial PressureDependentElastic3D: prp" << tag << endln;
00200 return TCL_ERROR;
00201 }
00202
00203 if (Tcl_GetDouble(interp, argv[8], &pop) != TCL_OK) {
00204 opserr << "WARNING invalid v\n";
00205 opserr << "nDMaterial PressureDependentElastic3D: pop" << tag << endln;
00206 return TCL_ERROR;
00207 }
00208
00209 theMaterial = new PressureDependentElastic3D (tag, E, v, rho, expp, prp, pop);
00210 }
00211
00212 }
00213
00214
00215 else if ( strcmp(argv[1],"ElasticIsotropic3D") == 0 )
00216 {
00217 if (argc < 6) {
00218 opserr << "WARNING insufficient arguments\n";
00219 printCommand(argc,argv);
00220 opserr << "Want: nDMaterial ElasticIsotropic3D tag? E? v? <rho?>" << endln;
00221 return TCL_ERROR;
00222 }
00223
00224 int tag = 0;
00225 double E = 0.0;
00226 double v = 0.0;
00227 double rho = 0.0;
00228
00229 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00230 opserr << "WARNING invalid ElasticIsotropic3D tag" << endln;
00231 return TCL_ERROR;
00232 }
00233
00234 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) {
00235 opserr << "WARNING invalid E\n";
00236 opserr << "nDMaterial ElasticIsotropic3D: " << tag << endln;
00237 return TCL_ERROR;
00238 }
00239
00240 if (Tcl_GetDouble(interp, argv[4], &v) != TCL_OK) {
00241 opserr << "WARNING invalid v\n";
00242 opserr << "nDMaterial ElasticIsotropic3D: " << tag << endln;
00243 return TCL_ERROR;
00244 }
00245
00246
00247 if (argc > 5 && Tcl_GetDouble(interp, argv[5], &rho) != TCL_OK)
00248 {
00249 opserr << "WARNING invalid rho\n";
00250 opserr << "nDMaterial ElasticIsotropic: " << tag << endln;
00251 return TCL_ERROR;
00252 }
00253
00254 theMaterial = new ElasticIsotropic3D (tag, E, v, rho);
00255
00256 }
00257
00258 else if (strcmp(argv[1],"ElasticIsotropic") == 0) {
00259 if (argc < 5) {
00260 opserr << "WARNING insufficient arguments\n";
00261 printCommand(argc,argv);
00262 opserr << "Want: nDMaterial ElasticIsotropic tag? E? v? <rho?>" << endln;
00263 return TCL_ERROR;
00264 }
00265
00266 int tag;
00267 double E, v;
00268 double rho = 0.0;
00269
00270 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00271 opserr << "WARNING invalid ElasticIsotropic tag" << endln;
00272 return TCL_ERROR;
00273 }
00274
00275 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) {
00276 opserr << "WARNING invalid E\n";
00277 opserr << "nDMaterial ElasticIsotropic: " << tag << endln;
00278 return TCL_ERROR;
00279 }
00280
00281 if (Tcl_GetDouble(interp, argv[4], &v) != TCL_OK) {
00282 opserr << "WARNING invalid v\n";
00283 opserr << "nDMaterial ElasticIsotropic: " << tag << endln;
00284 return TCL_ERROR;
00285 }
00286
00287 if (argc > 5 && Tcl_GetDouble(interp, argv[5], &rho) != TCL_OK)
00288 {
00289 opserr << "WARNING invalid rho\n";
00290 opserr << "nDMaterial ElasticIsotropic: " << tag << endln;
00291 return TCL_ERROR;
00292 }
00293
00294 theMaterial = new ElasticIsotropicMaterial (tag, E, v, rho);
00295 }
00296
00297
00298 else if (strcmp(argv[1],"ElasticCrossAnisotropic") == 0) {
00299
00300 if (argc < 8) {
00301 opserr << "WARNING insufficient arguments\n";
00302 printCommand(argc,argv);
00303 opserr << "Want: nDMaterial ElasticCrossAnisotropic tag? Ehh? Ehv? nuhv? nuvv? Ghv? <rho?>" << endln;
00304 return TCL_ERROR;
00305 }
00306
00307 int tag;
00308 double Eh, Ev, nuhv, nuhh, Ghv;
00309 double rho = 0.0;
00310
00311 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00312 opserr << "WARNING invalid ElasticCrossAnisotropic tag" << endln;
00313 return TCL_ERROR;
00314 }
00315
00316 if (Tcl_GetDouble(interp, argv[3], &Eh) != TCL_OK) {
00317 opserr << "WARNING invalid Eh\n";
00318 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00319 return TCL_ERROR;
00320 }
00321
00322 if (Tcl_GetDouble(interp, argv[4], &Ev) != TCL_OK) {
00323 opserr << "WARNING invalid Ev\n";
00324 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00325 return TCL_ERROR;
00326 }
00327
00328 if (Tcl_GetDouble(interp, argv[5], &nuhv) != TCL_OK) {
00329 opserr << "WARNING invalid nuhv\n";
00330 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00331 return TCL_ERROR;
00332 }
00333
00334 if (Tcl_GetDouble(interp, argv[6], &nuhh) != TCL_OK) {
00335 opserr << "WARNING invalid nuhh\n";
00336 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00337 return TCL_ERROR;
00338 }
00339
00340 if (Tcl_GetDouble(interp, argv[7], &Ghv) != TCL_OK) {
00341 opserr << "WARNING invalid Ghv\n";
00342 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00343 return TCL_ERROR;
00344 }
00345
00346 if (argc > 8 && Tcl_GetDouble(interp, argv[8], &rho) != TCL_OK) {
00347 opserr << "WARNING invalid rho\n";
00348 opserr << "nDMaterial ElasticCrossAnisotropic: " << tag << endln;
00349 return TCL_ERROR;
00350 }
00351
00352
00353 theMaterial = new ElasticCrossAnisotropic(tag, Eh, Ev, nuhv, nuhh, Ghv, rho);
00354 }
00355
00356
00357
00358 else if ((strcmp(argv[1],"J2Plasticity") == 0) ||
00359 (strcmp(argv[1],"J2") == 0)) {
00360 if (argc < 9) {
00361 opserr << "WARNING insufficient arguments\n";
00362 printCommand(argc,argv);
00363 opserr << "Want: nDMaterial J2Plasticity tag? K? G? sig0? sigInf? delta? H? <eta?>" << endln;
00364 return TCL_ERROR;
00365 }
00366
00367 int tag;
00368 double K, G, sig0, sigInf, delta, H;
00369 double eta = 0.0;
00370
00371 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00372 opserr << "WARNING invalid J2Plasticity tag" << endln;
00373 return TCL_ERROR;
00374 }
00375
00376 if (Tcl_GetDouble(interp, argv[3], &K) != TCL_OK) {
00377 opserr << "WARNING invalid K\n";
00378 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00379 return TCL_ERROR;
00380 }
00381
00382 if (Tcl_GetDouble(interp, argv[4], &G) != TCL_OK) {
00383 opserr << "WARNING invalid G\n";
00384 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00385 return TCL_ERROR;
00386 }
00387
00388 if (Tcl_GetDouble(interp, argv[5], &sig0) != TCL_OK) {
00389 opserr << "WARNING invalid sig0\n";
00390 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00391 return TCL_ERROR;
00392 }
00393
00394 if (Tcl_GetDouble(interp, argv[6], &sigInf) != TCL_OK) {
00395 opserr << "WARNING invalid sigInf\n";
00396 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00397 return TCL_ERROR;
00398 }
00399
00400 if (Tcl_GetDouble(interp, argv[7], &delta) != TCL_OK) {
00401 opserr << "WARNING invalid delta\n";
00402 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00403 return TCL_ERROR;
00404 }
00405 if (Tcl_GetDouble(interp, argv[8], &H) != TCL_OK) {
00406 opserr << "WARNING invalid H\n";
00407 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00408 return TCL_ERROR;
00409 }
00410 if (argc > 9 && Tcl_GetDouble(interp, argv[9], &eta) != TCL_OK) {
00411 opserr << "WARNING invalid eta\n";
00412 opserr << "nDMaterial J2Plasticity: " << tag << endln;
00413 return TCL_ERROR;
00414 }
00415
00416 theMaterial = new J2Plasticity (tag, 0, K, G, sig0, sigInf,
00417 delta, H, eta);
00418 }
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429 else if ((strcmp(argv[1],"MultiaxialCyclicPlasticity") == 0) ||
00430 (strcmp(argv[1],"MCP") == 0)) {
00431 if (argc < 12) {
00432 opserr << "WARNING insufficient arguments\n";
00433 printCommand(argc,argv);
00434 opserr << "Want: nDMaterial MultiaxialCyclicPlasticity tag? rho? K? G? Su? Ho? h? m? beta? KCoeff? <eta?>" << endln;
00435 return TCL_ERROR;
00436 }
00437
00438 int tag;
00439 double K, G, rho, Su, Ho, h, m, beta, Kcoeff;
00440 double eta = 0.0;
00441
00442 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00443 opserr << "WARNING invalid MultiaxialCyclicPlasticity tag" << endln;
00444 return TCL_ERROR;
00445 }
00446
00447 if (Tcl_GetDouble(interp, argv[3], &rho) != TCL_OK) {
00448 opserr << "WARNING invalid rho\n";
00449 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00450 return TCL_ERROR;
00451 }
00452
00453 if (Tcl_GetDouble(interp, argv[4], &K) != TCL_OK) {
00454 opserr << "WARNING invalid K\n";
00455 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00456 return TCL_ERROR;
00457 }
00458
00459 if (Tcl_GetDouble(interp, argv[5], &G) != TCL_OK) {
00460 opserr << "WARNING invalid G\n";
00461 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00462 return TCL_ERROR;
00463 }
00464
00465
00466 if (Tcl_GetDouble(interp, argv[6], &Su) != TCL_OK) {
00467 opserr << "WARNING invalid alpha1\n";
00468 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00469 return TCL_ERROR;
00470 }
00471
00472 if (Tcl_GetDouble(interp, argv[7], &Ho) != TCL_OK) {
00473 opserr << "WARNING invalid Ho\n";
00474 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00475 return TCL_ERROR;
00476 }
00477
00478 if (Tcl_GetDouble(interp, argv[8], &h) != TCL_OK) {
00479 opserr << "WARNING invalid h\n";
00480 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00481 return TCL_ERROR;
00482 }
00483
00484 if (Tcl_GetDouble(interp, argv[9], &m) != TCL_OK) {
00485 opserr << "WARNING invalid m\n";
00486 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00487 return TCL_ERROR;
00488 }
00489
00490 if (Tcl_GetDouble(interp, argv[10], &beta) != TCL_OK) {
00491 opserr << "WARNING invalid beta\n";
00492 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00493 return TCL_ERROR;
00494 }
00495 if (Tcl_GetDouble(interp, argv[11], &Kcoeff) != TCL_OK) {
00496 opserr << "WARNING invalid Kcoeff\n";
00497 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00498 return TCL_ERROR;
00499 }
00500
00501
00502 if (argc > 12 && Tcl_GetDouble(interp, argv[12], &eta) != TCL_OK) {
00503 opserr << "WARNING invalid eta\n";
00504 opserr << "nDMaterial MultiaxialCyclicPlasticity: " << tag << endln;
00505 return TCL_ERROR;
00506 }
00507
00508 theMaterial = new MultiaxialCyclicPlasticity (tag, 0, rho, K, G, Su, Ho, h,m,
00509 beta, Kcoeff, eta);
00510 }
00511
00512
00513
00514 else if (strcmp(argv[1],"PressureIndependMultiYield") == 0) {
00515 const int numParam = 6;
00516 const int totParam = 10;
00517 int tag; double param[totParam];
00518 param[6] = 0.0;
00519 param[7] = 100.;
00520 param[8] = 0.0;
00521 param[9] = 20;
00522
00523 char * arg[] = {"nd", "rho", "refShearModul", "refBulkModul",
00524 "cohesi", "peakShearStra",
00525 "frictionAng (=0)", "refPress (=100)", "pressDependCoe (=0.0)",
00526 "numberOfYieldSurf (=20)"};
00527 if (argc < (3+numParam)) {
00528 opserr << "WARNING insufficient arguments\n";
00529 printCommand(argc,argv);
00530 opserr << "Want: nDMaterial PressureIndependMultiYield tag? " << arg[0];
00531 opserr << "? "<< "\n";
00532 opserr << arg[1] << "? "<< arg[2] << "? "<< arg[3] << "? "<< "\n";
00533 opserr << arg[4] << "? "<< arg[5] << "? "<< arg[6] << "? "<< "\n";
00534 opserr << arg[7] << "? "<< arg[8] << "? "<< arg[9] << "? "<<endln;
00535 return TCL_ERROR;
00536 }
00537
00538 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00539 opserr << "WARNING invalid PressureIndependMultiYield tag" << endln;
00540 return TCL_ERROR;
00541 }
00542
00543 for (int i=3; (i<argc && i<13); i++)
00544 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3]) != TCL_OK) {
00545 opserr << "WARNING invalid " << arg[i-3] << "\n";
00546 opserr << "nDMaterial PressureIndependMultiYield: " << tag << endln;
00547 return TCL_ERROR;
00548 }
00549
00550 static double * gredu = 0;
00551
00552 if (param[9] < 0 && param[9] > -40) {
00553 param[9] = -int(param[9]);
00554 gredu = new double[int(2*param[9])];
00555 for (int i=0; i<2*param[9]; i++)
00556 if (Tcl_GetDouble(interp, argv[i+13], &gredu[i]) != TCL_OK) {
00557 opserr << "WARNING invalid " << arg[i-3] << "\n";
00558 opserr << "nDMaterial PressureIndependMultiYield: " << tag << endln;
00559 return TCL_ERROR;
00560 }
00561 }
00562
00563 PressureIndependMultiYield * temp =
00564 new PressureIndependMultiYield (tag, param[0], param[1], param[2],
00565 param[3], param[4], param[5], param[6],
00566 param[7], param[8], param[9], gredu);
00567 theMaterial = temp;
00568
00569 if (gredu != 0) {
00570 delete [] gredu;
00571 gredu = 0;
00572 }
00573 }
00574
00575
00576 else if (strcmp(argv[1],"PressureDependMultiYield") == 0) {
00577 const int numParam = 15;
00578 const int totParam = 24;
00579 int tag;
00580 double param[totParam];
00581 param[15] = 20;
00582 param[16] = 0.6;
00583 param[17] = 0.9;
00584 param[18] = 0.02;
00585 param[19] = 0.7;
00586 param[20] = 101.;
00587 param[21] = .3;
00588 param[22] = 0.;
00589 param[23] = 1.;
00590
00591 char * arg[] = {"nd", "rho", "refShearModul",
00592 "refBulkModul", "frictionAng",
00593 "peakShearStra", "refPress", "pressDependCoe",
00594 "phaseTransformAngle", "contractionParam1",
00595 "dilationParam1", "dilationParam2",
00596 "liquefactionParam1", "liquefactionParam2",
00597 "liquefactionParam4", "numberOfYieldSurf (=20)",
00598 "e (=0.6)", "volLimit1 (=0.9)", "volLimit2 (=0.02)",
00599 "volLimit3 (=0.7)", "Atmospheric pressure (=101)", "cohesi (=.5)",
00600 "Hv (=0)", "Pv (=1.)" };
00601 if (argc < (3+numParam)) {
00602 opserr << "WARNING insufficient arguments\n";
00603 printCommand(argc,argv);
00604 opserr << "Want: nDMaterial PressureDependMultiYield tag? "<< arg[0];
00605 opserr << "? "<< "\n";
00606 opserr << arg[1] << "? "<< arg[2] << "? "<< arg[3] << "? "<< "\n";
00607 opserr << arg[4] << "? "<< arg[5] << "? "<< arg[6] << "? "<< "\n";
00608 opserr << arg[7] << "? "<< arg[8] << "? "<< arg[9] << "? "<< "\n";
00609 opserr << arg[10] << "? "<< arg[11] << "? "<< arg[12] << "? "<< "\n";
00610 opserr << arg[13] << "? "<< arg[14] << "? "<< arg[15] << "? "<< "\n";
00611 opserr << arg[16] << "? "<< arg[17] << "? "<< arg[18] << "? "<< "\n";
00612 opserr << arg[19] << "? "<< arg[20] << "? "<< arg[21] << "? "<< endln;
00613 return TCL_ERROR;
00614 }
00615
00616 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00617 opserr << "WARNING invalid PressureDependMultiYield tag" << endln;
00618 return TCL_ERROR;
00619 }
00620
00621 for (int i=3; (i<argc && i<19); i++)
00622 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3]) != TCL_OK) {
00623 opserr << "WARNING invalid " << arg[i-3] << "\n";
00624 opserr << "nDMaterial PressureDependMultiYield: " << tag << endln;
00625 return TCL_ERROR;
00626 }
00627
00628 static double * gredu = 0;
00629
00630 if (param[15] < 0 && param[15] > -40) {
00631 param[15] = -int(param[15]);
00632 gredu = new double[int(2*param[15])];
00633
00634 for (int i=0; i<2*param[15]; i++)
00635 if (Tcl_GetDouble(interp, argv[i+19], &gredu[i]) != TCL_OK) {
00636 opserr << "WARNING invalid " << arg[i-3] << "\n";
00637 opserr << "nDMaterial PressureIndependMultiYield: " << tag << endln;
00638 return TCL_ERROR;
00639 }
00640 }
00641
00642 if (gredu != 0) {
00643 for (int i=19+int(2*param[15]); i<argc; i++)
00644 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3-int(2*param[15])]) != TCL_OK) {
00645 opserr << "WARNING invalid " << arg[i-3-int(2*param[15])] << "\n";
00646 opserr << "nDMaterial PressureDependMultiYield: " << tag << endln;
00647 return TCL_ERROR;
00648 }
00649 } else {
00650 for (int i=19; i<argc; i++)
00651 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3]) != TCL_OK) {
00652 opserr << "WARNING invalid " << arg[i-3-int(2*param[15])] << "\n";
00653 opserr << "nDMaterial PressureDependMultiYield: " << tag << endln;
00654 return TCL_ERROR;
00655 }
00656 }
00657
00658 PressureDependMultiYield * temp =
00659 new PressureDependMultiYield (tag, param[0], param[1], param[2],
00660 param[3], param[4], param[5],
00661 param[6], param[7], param[8],
00662 param[9], param[10], param[11],
00663 param[12], param[13], param[14],
00664 param[15], gredu, param[16], param[17],
00665 param[18], param[19], param[20], param[21], param[22], param[23]);
00666
00667 theMaterial = temp;
00668 if (gredu != 0) {
00669 delete [] gredu;
00670 gredu = 0;
00671 }
00672 }
00673
00674
00675 else if (strcmp(argv[1],"PressureDependMultiYield02") == 0) {
00676 const int numParam = 13;
00677 const int totParam = 26;
00678 int tag;
00679 double param[totParam];
00680 param[numParam] = 20;
00681 param[numParam+1] = 5.0;
00682 param[numParam+2] = 3.;
00683 param[numParam+3] = 1.;
00684 param[numParam+4] = 0.;
00685 param[numParam+5] = 0.6;
00686 param[numParam+6] = 0.9;
00687 param[numParam+7] = 0.02;
00688 param[numParam+8] = 0.7;
00689 param[numParam+9] = 101.;
00690 param[numParam+10] = 0.1;
00691 param[numParam+11] = 0.;
00692 param[numParam+12] = 1.;
00693
00694 char * arg[] = {"nd", "rho", "refShearModul",
00695 "refBulkModul", "frictionAng",
00696 "peakShearStra", "refPress", "pressDependCoe",
00697 "phaseTransformAngle", "contractionParam1",
00698 "contractionParam3","dilationParam1","dilationParam3",
00699 "numberOfYieldSurf (=20)",
00700 "contractionParam2=5.0", "dilationParam2=3.0",
00701 "liquefactionParam1=1.0", "liquefactionParam2=0.0",
00702 "e (=0.6)", "volLimit1 (=0.9)", "volLimit2 (=0.02)",
00703 "volLimit3 (=0.7)", "Atmospheric pressure (=101)", "cohesi (=.1)",
00704 "Hv (=0)", "Pv (=1.)" };
00705 if (argc < (3+numParam)) {
00706 opserr << "WARNING insufficient arguments\n";
00707 printCommand(argc,argv);
00708 opserr << "Want: nDMaterial PressureDependMultiYield02 tag? "<< arg[0];
00709 opserr << "? "<< "\n";
00710 opserr << arg[1] << "? "<< arg[2] << "? "<< arg[3] << "? "<< "\n";
00711 opserr << arg[4] << "? "<< arg[5] << "? "<< arg[6] << "? "<< "\n";
00712 opserr << arg[7] << "? "<< arg[8] << "? "<< arg[9] << "? "<< "\n";
00713 opserr << arg[10] << "? "<< arg[11] << "? "<< arg[12] << "? "<< "\n";
00714 opserr << arg[13] << "? "<< arg[14] << "? "<< arg[15] << "? "<< "\n";
00715 opserr << arg[16] << "? "<< arg[17] << "? "<< arg[18] << "? "<< "\n";
00716 opserr << arg[19] << "? "<< arg[20] << "? "<< arg[21] << "? "<< "\n";
00717 opserr << arg[22] << "? "<< arg[23] << "? " << endln;
00718 return TCL_ERROR;
00719 }
00720
00721 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00722 opserr << "WARNING invalid PressureDependMultiYield02 tag" << endln;
00723 return TCL_ERROR;
00724 }
00725
00726 int in = 17;
00727 for (int i=3; (i<argc && i<in); i++)
00728 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3]) != TCL_OK) {
00729 opserr << "WARNING invalid " << arg[i-3] << "\n";
00730 opserr << "nDMaterial PressureDependMultiYield02: " << tag << endln;
00731 return TCL_ERROR;
00732 }
00733
00734 static double * gredu = 0;
00735
00736
00737 if (param[numParam] < 0 && param[numParam] > -100) {
00738 param[numParam] = -int(param[numParam]);
00739 gredu = new double[int(2*param[numParam])];
00740
00741 for (int i=0; i<2*param[numParam]; i++)
00742 if (Tcl_GetDouble(interp, argv[i+in], &gredu[i]) != TCL_OK) {
00743 opserr << "WARNING invalid " << arg[i-3] << "\n";
00744 opserr << "nDMaterial PressureIndependMultiYield: " << tag << endln;
00745 return TCL_ERROR;
00746 }
00747 }
00748
00749 if (gredu != 0) {
00750 for (int i=in+int(2*param[numParam]); i<argc; i++)
00751 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3-int(2*param[numParam])]) != TCL_OK) {
00752 opserr << "WARNING invalid " << arg[i-3-int(2*param[numParam])] << "\n";
00753 opserr << "nDMaterial PressureDependMultiYield02: " << tag << endln;
00754 return TCL_ERROR;
00755 }
00756 } else {
00757 for (int i=in; i<argc; i++)
00758 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3]) != TCL_OK) {
00759 opserr << "WARNING invalid " << arg[i-3-int(2*param[numParam])] << "\n";
00760 opserr << "nDMaterial PressureDependMultiYield02: " << tag << endln;
00761 return TCL_ERROR;
00762 }
00763 }
00764
00765
00766 PressureDependMultiYield02 * temp =
00767 new PressureDependMultiYield02 (tag, param[0], param[1], param[2],
00768 param[3], param[4], param[5],
00769 param[6], param[7], param[8],
00770 param[9], param[10], param[11],
00771 param[12], param[13], gredu, param[14],
00772 param[15], param[16], param[17],
00773 param[18], param[19], param[20], param[21],
00774 param[22], param[23], param[24], param[25]);
00775
00776 theMaterial = temp;
00777 if (gredu != 0) {
00778 delete [] gredu;
00779 gredu = 0;
00780 }
00781 }
00782
00783
00784 else if (strcmp(argv[1],"FluidSolidPorous") == 0) {
00785
00786 int tag; double param[4];
00787 char * arg[] = {"nd", "soilMatTag", "combinedBulkModul", "Atmospheric pressure"};
00788 if (argc < 6) {
00789 opserr << "WARNING insufficient arguments\n";
00790 printCommand(argc,argv);
00791 opserr << "Want: nDMaterial FluidSolidPorous tag? "<< arg[0];
00792 opserr << "? "<< "\n";
00793 opserr << arg[1] << "? "<< arg[2] << "? "<< endln;
00794 return TCL_ERROR;
00795 }
00796
00797 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00798 opserr << "WARNING invalid FluidSolidPorous tag" << endln;
00799 return TCL_ERROR;
00800 }
00801
00802 for (int i=3; i<6; i++)
00803 if (Tcl_GetDouble(interp, argv[i], ¶m[i-3] ) != TCL_OK) {
00804 opserr << "WARNING invalid " << arg[i-3] << "\n";
00805 opserr << "nDMaterial FluidSolidPorous: " << tag << endln;
00806 return TCL_ERROR;
00807 }
00808
00809 NDMaterial *soil = theTclBuilder->getNDMaterial(param[1]);
00810 if (soil == 0) {
00811 opserr << "WARNING FluidSolidPorous: couldn't get soil material ";
00812 opserr << "tagged: " << param[1] << "\n";
00813 return TCL_ERROR;
00814 }
00815
00816 param[3] = 101.;
00817 if (argc == 7) {
00818 if (Tcl_GetDouble(interp, argv[6], ¶m[3] ) != TCL_OK) {
00819 opserr << "WARNING invalid " << arg[3] << "\n";
00820 opserr << "nDMaterial FluidSolidPorous: " << tag << endln;
00821 return TCL_ERROR;
00822 }
00823 }
00824
00825 theMaterial = new FluidSolidPorousMaterial (tag, param[0], *soil,
00826 param[2],param[3]);
00827 }
00828
00829 else if (strcmp(argv[1],"Template3Dep") == 0) {
00830 theMaterial = TclModelBuilder_addTemplate3Dep(clientData, interp, argc, argv,
00831 theTclBuilder, 2);
00832 }
00833
00834 else if (strcmp(argv[1],"NewTemplate3Dep") == 0) {
00835 theMaterial = TclModelBuilder_addNewTemplate3Dep(clientData, interp, argc, argv,
00836 theTclBuilder, 2);
00837 }
00838
00839 else if (strcmp(argv[1],"FiniteDeformationElastic3D") == 0 ||
00840 strcmp(argv[1],"FDElastic3D" ) == 0) {
00841 theMaterial = TclModelBuilder_addFiniteDeformationElastic3D(clientData, interp, argc, argv,
00842 theTclBuilder, 1);
00843 }
00844
00845 else if (strcmp(argv[1],"FiniteDeformationEP3D") == 0 ||
00846 strcmp(argv[1],"FDEP3D" ) == 0) {
00847 theMaterial = TclModelBuilder_addFiniteDeformationEP3D(clientData, interp, argc, argv,
00848 theTclBuilder, 2);
00849 }
00850
00851
00852 else if (strcmp(argv[1],"PlaneStressMaterial") == 0 ||
00853 strcmp(argv[1],"PlaneStress") == 0) {
00854 if (argc < 4) {
00855 opserr << "WARNING insufficient arguments\n";
00856 printCommand(argc,argv);
00857 opserr << "Want: nDMaterial PlaneStress tag? matTag?" << endln;
00858 return TCL_ERROR;
00859 }
00860
00861 int tag, matTag;
00862
00863 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00864 opserr << "WARNING invalid nDMaterial PlaneStress tag" << endln;
00865 return TCL_ERROR;
00866 }
00867
00868 if (Tcl_GetInt (interp, argv[3], &matTag) != TCL_OK) {
00869 opserr << "WARNING invalid matTag" << endln;
00870 opserr << "PlaneStress: " << matTag << endln;
00871 return TCL_ERROR;
00872 }
00873
00874 NDMaterial *threeDMaterial = theTclBuilder->getNDMaterial(matTag);
00875 if (threeDMaterial == 0) {
00876 opserr << "WARNING nD material does not exist\n";
00877 opserr << "nD material: " << matTag;
00878 opserr << "\nPlaneStress nDMaterial: " << tag << endln;
00879 return TCL_ERROR;
00880 }
00881
00882 theMaterial = new PlaneStressMaterial( tag, *threeDMaterial );
00883 }
00884
00885
00886 else if (strcmp(argv[1],"PlateFiberMaterial") == 0 ||
00887 strcmp(argv[1],"PlateFiber") == 0) {
00888 if (argc < 4) {
00889 opserr << "WARNING insufficient arguments\n";
00890 printCommand(argc,argv);
00891 opserr << "Want: nDMaterial PlateFiber tag? matTag?" << endln;
00892 return TCL_ERROR;
00893 }
00894
00895 int tag, matTag;
00896
00897 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00898 opserr << "WARNING invalid nDMaterial PlateFiber tag" << endln;
00899 return TCL_ERROR;
00900 }
00901
00902 if (Tcl_GetInt (interp, argv[3], &matTag) != TCL_OK) {
00903 opserr << "WARNING invalid matTag" << endln;
00904 opserr << "PlateFiber: " << matTag << endln;
00905 return TCL_ERROR;
00906 }
00907
00908 NDMaterial *threeDMaterial = theTclBuilder->getNDMaterial(matTag);
00909 if (threeDMaterial == 0) {
00910 opserr << "WARNING nD material does not exist\n";
00911 opserr << "nD material: " << matTag;
00912 opserr << "\nPlateFiber nDMaterial: " << tag << endln;
00913 return TCL_ERROR;
00914 }
00915
00916 theMaterial = new PlateFiberMaterial( tag, *threeDMaterial );
00917 }
00918
00919 else if (strcmp(argv[1],"BeamFiberMaterial") == 0 ||
00920 strcmp(argv[1],"BeamFiber") == 0) {
00921 if (argc < 4) {
00922 opserr << "WARNING insufficient arguments\n";
00923 printCommand(argc,argv);
00924 opserr << "Want: nDMaterial BeamFiber tag? matTag?" << endln;
00925 return TCL_ERROR;
00926 }
00927
00928 int tag, matTag;
00929
00930 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) {
00931 opserr << "WARNING invalid nDMaterial BeamFiber tag" << endln;
00932 return TCL_ERROR;
00933 }
00934
00935 if (Tcl_GetInt (interp, argv[3], &matTag) != TCL_OK) {
00936 opserr << "WARNING invalid matTag" << endln;
00937 opserr << "BeamFiber: " << matTag << endln;
00938 return TCL_ERROR;
00939 }
00940
00941 NDMaterial *threeDMaterial = theTclBuilder->getNDMaterial(matTag);
00942 if (threeDMaterial == 0) {
00943 opserr << "WARNING nD material does not exist\n";
00944 opserr << "nD material: " << matTag;
00945 opserr << "\nBeamFiber nDMaterial: " << tag << endln;
00946 return TCL_ERROR;
00947 }
00948
00949 theMaterial = new BeamFiberMaterial( tag, *threeDMaterial );
00950 }
00951
00952 else if (strcmp(argv[1],"Bidirectional") == 0) {
00953 opserr << "nDMaterial Bidirectional is now a section model, please "
00954 << "change to \'section Bidirectional\'" << endln;
00955 return TCL_ERROR;
00956 }
00957
00958 else {
00959 theMaterial = TclModelBuilder_addFeapMaterial(clientData,
00960 interp,
00961 argc,
00962 argv,
00963 theTclBuilder);
00964 }
00965
00966 if (theMaterial == 0) {
00967 opserr << "WARNING count not create nDMaterial: " << argv[1];
00968 return TCL_ERROR;
00969 }
00970
00971
00972 if (theTclBuilder->addNDMaterial(*theMaterial) < 0) {
00973 opserr << "WARNING could not add material to the domain\n";
00974 opserr << *theMaterial << endln;
00975 delete theMaterial;
00976 return TCL_ERROR;
00977 }
00978
00979 return TCL_OK;
00980 }
00981
00982