TclModelBuilderUniaxialMaterialCommand.cppGo to the documentation of this file.00001 /* ****************************************************************** ** 00002 ** OpenSees - Open System for Earthquake Engineering Simulation ** 00003 ** Pacific Earthquake Engineering Research Center ** 00004 ** ** 00005 ** ** 00006 ** (C) Copyright 1999, The Regents of the University of California ** 00007 ** All Rights Reserved. ** 00008 ** ** 00009 ** Commercial use of this program without express permission of the ** 00010 ** University of California, Berkeley, is strictly prohibited. See ** 00011 ** file 'COPYRIGHT' in main directory for information on usage and ** 00012 ** redistribution, and for a DISCLAIMER OF ALL WARRANTIES. ** 00013 ** ** 00014 ** Developed by: ** 00015 ** Frank McKenna (fmckenna@ce.berkeley.edu) ** 00016 ** Gregory L. Fenves (fenves@ce.berkeley.edu) ** 00017 ** Filip C. Filippou (filippou@ce.berkeley.edu) ** 00018 ** ** 00019 ** ****************************************************************** */ 00020 00021 // $Revision: 1.38 $ 00022 // $Date: 2006/09/01 00:51:43 $ 00023 // $Source: /usr/local/cvs/OpenSees/SRC/material/uniaxial/TclModelBuilderUniaxialMaterialCommand.cpp,v $ 00024 00025 00026 // Written: fmk, MHS 00027 // Created: 07/99 00028 // 00029 // Description: This file contains the function invoked when the user invokes 00030 // the uniaxialMaterial command in the interpreter. 00031 // 00032 // What: "@(#) TclModelBuilderUniaxialMaterialCommand.C, revA" 00033 00034 #include <TclModelBuilder.h> 00035 00036 #include <ElasticMaterial.h> // fmk 00037 #include <ElasticPPMaterial.h> // fmk 00038 #include <ParallelMaterial.h> // fmk 00039 #include <HardeningMaterial.h> // MHS 00040 #include <Steel01.h> // MHS 00041 #include <Steel02.h> // FF 00042 #include <Steel03.h> // KM 00043 #include <Concrete01.h> // MHS 00044 #include <Concrete02.h> // MHS 00045 #include <Concrete04.h> 00046 #include <HystereticMaterial.h> // MHS 00047 #include <EPPGapMaterial.h> // Mackie 00048 #include <ViscousMaterial.h> // Sasani 00049 #include <PathIndependentMaterial.h> // MHS 00050 #include <MinMaxMaterial.h> // MHS 00051 #include <FatigueMaterial.h> // Patxi 00052 #include <SeriesMaterial.h> // MHS 00053 #include <ENTMaterial.h> // MHS 00054 #include <CableMaterial.h> // CC 00055 #include <BoucWenMaterial.h> // Terje 00056 #include <Pinching4Material.h> // NM 00057 #include <BarSlipMaterial.h> // NM 00058 #include <Bond_SP01.h> // JZ 00059 00060 #include <Domain.h> // RWB bringing in Domain for PyLiq 00061 #include <PySimple1.h> // RWB 00062 #include <PyLiq1.h> // RWB 00063 #include <TzSimple1.h> // RWB 00064 #include <TzLiq1.h> // RWB 00065 00066 #include <Vector.h> 00067 #include <string.h> 00068 00069 00070 #ifdef _LIMITSTATEMATERIAL 00071 extern UniaxialMaterial * 00072 Tcl_AddLimitStateMaterial(ClientData clientData, Tcl_Interp *interp, int argc, TCL_Char **argv); 00073 #endif 00074 00075 00076 #include <packages.h> 00077 00078 00079 00080 typedef struct uniaxialPackageCommand { 00081 char *funcName; 00082 int (*funcPtr)(ClientData clientData, Tcl_Interp *interp, int argc, 00083 TCL_Char **argv, TclModelBuilder *); 00084 struct uniaxialPackageCommand *next; 00085 } UniaxialPackageCommand; 00086 00087 static UniaxialPackageCommand *theUniaxialPackageCommands = NULL; 00088 00089 static void printCommand(int argc, TCL_Char **argv) 00090 { 00091 opserr << "Input command: "; 00092 for (int i=0; i<argc; i++) 00093 opserr << argv[i] << " "; 00094 opserr << endln; 00095 } 00096 00097 00098 // external functions 00099 00100 int 00101 TclCommand_ReinforcingSteel(ClientData clientData, Tcl_Interp *interp, int argc, 00102 TCL_Char **argv, TclModelBuilder *theTclBuilder); 00103 00104 00105 UniaxialMaterial * 00106 TclModelBuilder_addFedeasMaterial(ClientData clientData, Tcl_Interp *interp, int argc, 00107 TCL_Char **argv, TclModelBuilder *theTclBuilder); 00108 00109 UniaxialMaterial * 00110 TclModelBuilder_addDrainMaterial(ClientData clientData, Tcl_Interp *interp, int argc, 00111 TCL_Char **argv, TclModelBuilder *theTclBuilder); 00112 00113 UniaxialMaterial * 00114 TclModelBuilder_addSnapMaterial(ClientData clientData, Tcl_Interp *interp, int argc, 00115 TCL_Char **argv, TclModelBuilder *theTclBuilder); 00116 00117 UniaxialMaterial * 00118 TclModelBuilder_addPyTzQzMaterial(ClientData clientData, Tcl_Interp *interp, int argc, 00119 TCL_Char **argv, TclModelBuilder *theTclBuilder, Domain *theDomain); 00120 00121 /* 00122 int 00123 TclCommand_KinematicHardening(ClientData clientData, Tcl_Interp *interp, int argc, 00124 TCL_Char **argv, TclModelBuilder *theTclBuilder); 00125 */ 00126 00127 int 00128 TclModelBuilderUniaxialMaterialCommand (ClientData clientData, Tcl_Interp *interp, int argc, 00129 TCL_Char **argv, TclModelBuilder *theTclBuilder, Domain *theDomain) 00130 { 00131 // Make sure there is a minimum number of arguments 00132 if (argc < 3) { 00133 opserr << "WARNING insufficient number of uniaxial material arguments\n"; 00134 opserr << "Want: uniaxialMaterial type? tag? <specific material args>" << endln; 00135 return TCL_ERROR; 00136 } 00137 00138 // Pointer to a uniaxial material that will be added to the model builder 00139 UniaxialMaterial *theMaterial = 0; 00140 00141 // Check argv[2] for uniaxial material type 00142 if (strcmp(argv[1],"Elastic") == 0) { 00143 if (argc < 4 || argc > 5) { 00144 opserr << "WARNING invalid number of arguments\n"; 00145 printCommand(argc,argv); 00146 opserr << "Want: uniaxialMaterial Elastic tag? E? <eta?>" << endln; 00147 return TCL_ERROR; 00148 } 00149 00150 int tag; 00151 double E; 00152 double eta = 0.0; 00153 00154 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00155 opserr << "WARNING invalid uniaxialMaterial Elastic tag" << endln; 00156 return TCL_ERROR; 00157 } 00158 00159 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) { 00160 opserr << "WARNING invalid E\n"; 00161 opserr << "uniaxiaMaterial Elastic: " << tag << endln; 00162 return TCL_ERROR; 00163 } 00164 00165 if (argc == 5) { 00166 if (Tcl_GetDouble(interp,argv[4], &eta) != TCL_OK) { 00167 opserr << "WARNING invalid eta\n"; 00168 opserr << "uniaxialMaterial Elastic: " << tag << endln; 00169 return TCL_ERROR; 00170 } 00171 } 00172 00173 // Parsing was successful, allocate the material 00174 theMaterial = new ElasticMaterial(tag, E, eta); 00175 //dum << tag " << tag << " E " << E << " eta " << eta <<endln; 00176 00177 } else if (strcmp(argv[1], "ReinforcingSteel") == 0) { 00178 return TclCommand_ReinforcingSteel(clientData,interp,argc,argv,theTclBuilder); 00179 } 00180 00181 else if (strcmp(argv[1],"ENT") == 0) { 00182 if (argc < 4) { 00183 opserr << "WARNING invalid number of arguments\n"; 00184 printCommand(argc,argv); 00185 opserr << "Want: uniaxialMaterial ENT tag? E?" << endln; 00186 return TCL_ERROR; 00187 } 00188 00189 int tag; 00190 double E; 00191 00192 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00193 opserr << "WARNING invalid uniaxialMaterial ENT tag" << endln; 00194 return TCL_ERROR; 00195 } 00196 00197 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) { 00198 opserr << "WARNING invalid E\n"; 00199 opserr << "uniaxiaMaterial ENT: " << tag << endln; 00200 return TCL_ERROR; 00201 } 00202 00203 // Parsing was successful, allocate the material 00204 theMaterial = new ENTMaterial(tag, E); 00205 00206 } 00207 00208 else if (strcmp(argv[1],"ElasticPP") == 0) { 00209 if (argc < 5) { 00210 opserr << "WARNING insufficient arguments\n"; 00211 printCommand(argc,argv); 00212 opserr << "Want: uniaxialMaterial ElasticPP tag? E? epsy?" << endln; 00213 return TCL_ERROR; 00214 } 00215 00216 int tag; 00217 double E, ep; 00218 00219 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00220 opserr << "WARNING invalid uniaxialMaterial ElasticPP tag" << endln; 00221 return TCL_ERROR; 00222 } 00223 00224 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) { 00225 opserr << "WARNING invalid E\n"; 00226 opserr << "uniaxialMaterial ElasticPP: " << tag << endln; 00227 return TCL_ERROR; 00228 } 00229 00230 if (Tcl_GetDouble(interp, argv[4], &ep) != TCL_OK) { 00231 opserr << "WARNING invalid epsy\n"; 00232 opserr << "uniaxialMaterial ElasticPP: " << tag << endln; 00233 return TCL_ERROR; 00234 } 00235 00236 // read in additional parameters eyn and ezero 00237 if (argc > 6) { 00238 double eyn, ez; 00239 if (Tcl_GetDouble(interp, argv[5], &eyn) != TCL_OK) { 00240 opserr << "WARNING invalid eyn\n"; 00241 opserr << "uniaxialMaterial ElasticPP: " << tag << endln; 00242 return TCL_ERROR; 00243 } 00244 if (Tcl_GetDouble(interp, argv[6], &ez) != TCL_OK) { 00245 opserr << "WARNING invalid ez\n"; 00246 opserr << "uniaxialMaterial ElasticPP: " << tag << endln; 00247 return TCL_ERROR; 00248 } 00249 theMaterial = new ElasticPPMaterial(tag, E, ep, eyn, ez); 00250 } else { 00251 // Parsing was successful, allocate the material 00252 theMaterial = new ElasticPPMaterial(tag, E, ep); 00253 } 00254 } 00255 00256 else if (strcmp(argv[1],"ElasticPPGap") == 0) { 00257 if (argc < 6) { 00258 opserr << "WARNING insufficient arguments\n"; 00259 printCommand(argc,argv); 00260 opserr << "Want: uniaxialMaterial ElasticPPGap tag? E? fy? gap? <eta?> <damage>" << endln; 00261 return TCL_ERROR; 00262 } 00263 00264 int tag; 00265 int damage = 0; 00266 double eta = 0.0; 00267 double E, fy, gap; 00268 00269 00270 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00271 opserr << "WARNING invalid uniaxialMaterial ElasticPPGap 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 << "uniaxialMaterial ElasticPPGap: " << tag << endln; 00278 return TCL_ERROR; 00279 } 00280 00281 if (Tcl_GetDouble(interp, argv[4], &fy) != TCL_OK) { 00282 opserr << "WARNING invalid fy\n"; 00283 opserr << "uniaxialMaterial ElasticPPGap: " << tag << endln; 00284 return TCL_ERROR; 00285 } 00286 00287 if (Tcl_GetDouble(interp, argv[5], &gap) != TCL_OK) { 00288 opserr << "WARNING invalid gap\n"; 00289 opserr << "uniaxialMaterial ElasticPPGap: " << tag << endln; 00290 return TCL_ERROR; 00291 } 00292 00293 if (argc > 6 && strcmp(argv[6],"damage") == 0) 00294 damage = 1; 00295 else if (argc > 7 && strcmp(argv[7],"damage") == 0) { 00296 damage = 1; 00297 if (Tcl_GetDouble(interp, argv[6], &eta) != TCL_OK) { 00298 opserr << "WARNING invalid eta\n"; 00299 opserr << "uniaxialMaterial ElasticPPGap: " << tag << endln; 00300 return TCL_ERROR; 00301 } 00302 } 00303 00304 // Parsing was successful, allocate the material 00305 theMaterial = new EPPGapMaterial(tag, E, fy, gap, eta, damage); 00306 00307 } 00308 00309 else if (strcmp(argv[1],"Hardening") == 0) { 00310 if (argc < 7) { 00311 opserr << "WARNING insufficient arguments\n"; 00312 printCommand(argc,argv); 00313 opserr << "Want: uniaxialMaterial Hardening tag? E? sigmaY? H_iso? H_kin? <eta?>" << endln; 00314 return TCL_ERROR; 00315 } 00316 00317 int tag; 00318 double E, sigmaY, Hiso, Hkin; 00319 double eta = 0.0; 00320 00321 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00322 opserr << "WARNING invalid uniaxialMaterial Hardening tag" << endln; 00323 return TCL_ERROR; 00324 } 00325 00326 if (Tcl_GetDouble(interp, argv[3], &E) != TCL_OK) { 00327 opserr << "WARNING invalid E\n"; 00328 opserr << "uniaxialMaterial Hardening: " << tag << endln; 00329 return TCL_ERROR; 00330 } 00331 00332 if (Tcl_GetDouble(interp, argv[4], &sigmaY) != TCL_OK) { 00333 opserr << "WARNING invalid sigmaY\n"; 00334 opserr << "uniaxialMaterial Hardening: " << tag << endln; 00335 return TCL_ERROR; 00336 } 00337 00338 if (Tcl_GetDouble(interp, argv[5], &Hiso) != TCL_OK) { 00339 opserr << "WARNING invalid H_iso\n"; 00340 opserr << "uniaxialMaterial Hardening: " << tag << endln; 00341 return TCL_ERROR; 00342 } 00343 00344 if (Tcl_GetDouble(interp, argv[6], &Hkin) != TCL_OK) { 00345 opserr << "WARNING invalid H_kin\n"; 00346 opserr << "uniaxialMaterial Hardening: " << tag << endln; 00347 return TCL_ERROR; 00348 } 00349 00350 if (argc > 7 && Tcl_GetDouble(interp, argv[7], &eta) != TCL_OK) { 00351 opserr << "WARNING invalid eta\n"; 00352 opserr << "uniaxialMaterial Hardening: " << tag << endln; 00353 return TCL_ERROR; 00354 } 00355 00356 // Parsing was successful, allocate the material 00357 theMaterial = new HardeningMaterial (tag, E, sigmaY, Hiso, Hkin, eta); 00358 } 00359 00360 else if (strcmp(argv[1],"BoucWen") == 0) { 00361 if (argc < 12) { 00362 opserr << "WARNING insufficient arguments\n"; 00363 printCommand(argc,argv); 00364 opserr << "Want: uniaxialMaterial BoucWen tag? alpha? ko? n? gamma?" << endln 00365 << " beta? Ao? deltaA? deltaNu? deltaEta?" << endln; 00366 return TCL_ERROR; 00367 } 00368 00369 int tag; 00370 double alpha, ko, n, gamma, beta, Ao, deltaA, deltaNu, deltaEta; 00371 00372 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00373 opserr << "WARNING invalid uniaxialMaterial BoucWen tag" << endln; 00374 return TCL_ERROR; 00375 } 00376 if (Tcl_GetDouble(interp, argv[3], &alpha) != TCL_OK) { 00377 opserr << "WARNING invalid alpha\n"; 00378 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00379 return TCL_ERROR; 00380 } 00381 if (Tcl_GetDouble(interp, argv[4], &ko) != TCL_OK) { 00382 opserr << "WARNING invalid ko\n"; 00383 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00384 return TCL_ERROR; 00385 } 00386 if (Tcl_GetDouble(interp, argv[5], &n) != TCL_OK) { 00387 opserr << "WARNING invalid n\n"; 00388 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00389 return TCL_ERROR; 00390 } 00391 if (Tcl_GetDouble(interp, argv[6], &gamma) != TCL_OK) { 00392 opserr << "WARNING invalid gamma\n"; 00393 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00394 return TCL_ERROR; 00395 } 00396 if (Tcl_GetDouble(interp, argv[7], &beta) != TCL_OK) { 00397 opserr << "WARNING invalid beta\n"; 00398 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00399 return TCL_ERROR; 00400 } 00401 if (Tcl_GetDouble(interp, argv[8], &Ao) != TCL_OK) { 00402 opserr << "WARNING invalid Ao\n"; 00403 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00404 return TCL_ERROR; 00405 } 00406 if (Tcl_GetDouble(interp, argv[9], &deltaA) != TCL_OK) { 00407 opserr << "WARNING invalid deltaA\n"; 00408 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00409 return TCL_ERROR; 00410 } 00411 if (Tcl_GetDouble(interp, argv[10], &deltaNu) != TCL_OK) { 00412 opserr << "WARNING invalid deltaNu\n"; 00413 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00414 return TCL_ERROR; 00415 } 00416 if (Tcl_GetDouble(interp, argv[11], &deltaEta) != TCL_OK) { 00417 opserr << "WARNING invalid deltaEta\n"; 00418 opserr << "uniaxialMaterial BoucWen: " << tag << endln; 00419 return TCL_ERROR; 00420 } 00421 00422 // Check if the user has given a tolerance for the Newton scheme 00423 double tolerance = 1.0e-8; 00424 if (argc > 12) { 00425 if (Tcl_GetDouble(interp, argv[12], &tolerance) != TCL_OK) { 00426 opserr << "WARNING invalid tolerance\n"; 00427 opserr << "uniaxialMaterial BoucWen: " << tolerance << endln; 00428 return TCL_ERROR; 00429 } 00430 } 00431 00432 // Check if the user has given a maxNumIter for the Newton scheme 00433 int maxNumIter = 20; 00434 if (argc > 13) { 00435 if (Tcl_GetInt(interp, argv[13], &maxNumIter) != TCL_OK) { 00436 opserr << "WARNING invalid maxNumIter\n"; 00437 opserr << "uniaxialMaterial BoucWen: " << maxNumIter << endln; 00438 return TCL_ERROR; 00439 } 00440 } 00441 00442 // Parsing was successful, allocate the material 00443 theMaterial = new BoucWenMaterial(tag, alpha, ko, n, gamma, beta, 00444 Ao, deltaA, deltaNu, deltaEta,tolerance,maxNumIter); 00445 } 00446 00447 else if (strcmp(argv[1],"Parallel") == 0) { 00448 if (argc < 4) { 00449 opserr << "WARNING insufficient arguments\n"; 00450 printCommand(argc,argv); 00451 opserr << "Want: uniaxialMaterial Parallel tag? tag1? tag2? ..."; 00452 opserr << " <-min min?> <-max max?>" << endln; 00453 return TCL_ERROR; 00454 } 00455 00456 int tag; 00457 00458 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00459 opserr << "WARNING invalid uniaxialMaterial Parallel tag" << endln; 00460 return TCL_ERROR; 00461 } 00462 00463 int numMaterials = argc-3; 00464 00465 if (numMaterials == 0) { 00466 opserr << "WARNING no component material(s) provided\n"; 00467 opserr << "uniaxialMaterial Parallel: " << tag << endln; 00468 return TCL_ERROR; 00469 } 00470 00471 // Create an array to hold pointers to component materials 00472 UniaxialMaterial **theMats = new UniaxialMaterial *[numMaterials]; 00473 00474 // For each material get the tag and ensure it exists in model already 00475 for (int i=0; i<numMaterials; i++) { 00476 int tagI; 00477 if (Tcl_GetInt(interp, argv[i+3], &tagI) != TCL_OK) { 00478 opserr << "WARNING invalid component tag\n"; 00479 opserr << "uniaxialMaterial Parallel: " << tag << endln; 00480 return TCL_ERROR; 00481 } 00482 00483 UniaxialMaterial *theMat = theTclBuilder->getUniaxialMaterial(tagI); 00484 00485 if (theMat == 0) { 00486 opserr << "WARNING component material does not exist\n"; 00487 opserr << "Component material: " << argv[i+3]; 00488 opserr << "\nuniaxialMaterial Parallel: " << tag << endln; 00489 delete [] theMats; 00490 return TCL_ERROR; 00491 } 00492 else 00493 theMats[i] = theMat; 00494 } 00495 00496 // Parsing was successful, allocate the material 00497 theMaterial = new ParallelMaterial(tag, numMaterials, theMats); 00498 00499 // Deallocate the temporary pointers 00500 delete [] theMats; 00501 } 00502 00503 else if (strcmp(argv[1],"Series") == 0) { 00504 if (argc < 4) { 00505 opserr << "WARNING insufficient arguments\n"; 00506 printCommand(argc,argv); 00507 opserr << "Want: uniaxialMaterial Series tag? tag1? tag2? ..." << endln; 00508 return TCL_ERROR; 00509 } 00510 00511 int tag; 00512 00513 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00514 opserr << "WARNING invalid uniaxialMaterial Series tag" << endln; 00515 return TCL_ERROR; 00516 } 00517 00518 int numMaterials = argc - 3; 00519 UniaxialMaterial **theMats = new UniaxialMaterial *[numMaterials]; 00520 00521 // For each material get the tag and ensure it exists in model already 00522 for (int i = 3; i < argc; i++) { 00523 int tagI; 00524 if (Tcl_GetInt(interp, argv[i], &tagI) != TCL_OK) { 00525 opserr << "WARNING invalid component tag\n"; 00526 opserr << "uniaxialMaterial Series: " << tag << endln; 00527 delete [] theMats; 00528 return TCL_ERROR; 00529 } 00530 00531 UniaxialMaterial *theMat = theTclBuilder->getUniaxialMaterial(tagI); 00532 00533 if (theMat == 0) { 00534 opserr << "WARNING component material does not exist\n"; 00535 opserr << "Component material: " << tagI; 00536 opserr << "\nuniaxialMaterial Series: " << tag << endln; 00537 delete [] theMats; 00538 return TCL_ERROR; 00539 } 00540 else 00541 theMats[i-3] = theMat; 00542 } 00543 00544 // Parsing was successful, allocate the material 00545 theMaterial = new SeriesMaterial(tag, numMaterials, theMats); 00546 00547 // Deallocate the temporary pointers 00548 delete [] theMats; 00549 } 00550 00551 else if (strcmp(argv[1],"Steel01") == 0) { 00552 // Check that there is the minimum number of arguments 00553 if (argc < 6) { 00554 opserr << "WARNING insufficient arguments\n"; 00555 printCommand(argc,argv); 00556 opserr << "Want: uniaxialMaterial Steel01 tag? fy? E0? b?"; 00557 opserr << " <a1? a2? a3? a4?>" << endln; 00558 return TCL_ERROR; 00559 } 00560 00561 int tag; 00562 00563 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00564 opserr << "WARNING invalid uniaxialMaterial Steel01 tag" << endln; 00565 return TCL_ERROR; 00566 } 00567 00568 // Read required Steel01 material parameters 00569 double fy, E, b; 00570 00571 if (Tcl_GetDouble(interp, argv[3], &fy) != TCL_OK) { 00572 opserr << "WARNING invalid fy\n"; 00573 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00574 return TCL_ERROR; 00575 } 00576 00577 if (Tcl_GetDouble(interp, argv[4], &E) != TCL_OK) { 00578 opserr << "WARNING invalid E0\n"; 00579 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00580 return TCL_ERROR; 00581 } 00582 00583 if (Tcl_GetDouble(interp, argv[5], &b) != TCL_OK) { 00584 opserr << "WARNING invalid b\n"; 00585 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00586 return TCL_ERROR; 00587 } 00588 00589 // Read optional Steel01 material parameters 00590 double a1, a2, a3, a4; 00591 00592 if (argc > 6) { 00593 if (argc < 10) { 00594 opserr << "WARNING insufficient number of hardening parameters\n"; 00595 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00596 return TCL_ERROR; 00597 } 00598 00599 if (Tcl_GetDouble(interp, argv[6], &a1) != TCL_OK) { 00600 opserr << "WARNING invalid a1\n"; 00601 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00602 return TCL_ERROR; 00603 } 00604 00605 if (Tcl_GetDouble(interp, argv[7], &a2) != TCL_OK) { 00606 opserr << "WARNING invalid a2\n"; 00607 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00608 return TCL_ERROR; 00609 } 00610 00611 if (Tcl_GetDouble(interp, argv[8], &a3) != TCL_OK) { 00612 opserr << "WARNING invalid a3\n"; 00613 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00614 return TCL_ERROR; 00615 } 00616 00617 if (Tcl_GetDouble(interp, argv[9], &a4) != TCL_OK) { 00618 opserr << "WARNING invalid a4\n"; 00619 opserr << "uniaxialMaterial Steel01: " << tag << endln; 00620 return TCL_ERROR; 00621 } 00622 00623 // Parsing was successful, allocate the material 00624 theMaterial = new Steel01 (tag, fy, E, b, a1, a2, a3, a4); 00625 } 00626 else 00627 // Parsing was successful, allocate the material 00628 theMaterial = new Steel01 (tag, fy, E, b); 00629 } 00630 00631 else if (strcmp(argv[1],"Steel2") == 0 || strcmp(argv[1],"Steel02") == 0) { 00632 if (argc < 6) { 00633 opserr << "WARNING invalid number of arguments\n"; 00634 printCommand(argc,argv); 00635 opserr << "Want: uniaxialMaterial Steel02 tag? fy? E? b? <R0? cR1? cR2? <a1? a2? a3? a4?>>" << endln; 00636 return 0; 00637 } 00638 00639 double fy, E, b; 00640 double R0, cR1, cR2; 00641 double a1, a2, a3, a4; 00642 00643 int tag; 00644 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00645 opserr << "WARNING invalid tag\n"; 00646 printCommand(argc, argv); 00647 return 0; 00648 } 00649 if (Tcl_GetDouble(interp, argv[3], &fy) != TCL_OK) { 00650 opserr << "WARNING invalid fy\n"; 00651 printCommand(argc, argv); 00652 return 0; 00653 } 00654 if (Tcl_GetDouble(interp, argv[4], &E) != TCL_OK) { 00655 opserr << "WARNING invalid E\n"; 00656 printCommand(argc, argv); 00657 return 0; 00658 } 00659 if (Tcl_GetDouble(interp, argv[5], &b) != TCL_OK) { 00660 opserr << "WARNING invalid b\n"; 00661 printCommand(argc, argv); 00662 return 0; 00663 } 00664 if (argc > 8) { 00665 if (Tcl_GetDouble(interp, argv[6], &R0) != TCL_OK) { 00666 opserr << "WARNING invalid R0\n"; 00667 printCommand(argc, argv); 00668 return 0; 00669 } 00670 if (Tcl_GetDouble(interp, argv[7], &cR1) != TCL_OK) { 00671 opserr << "WARNING invalid cR1\n"; 00672 printCommand(argc, argv); 00673 return 0; 00674 } 00675 if (Tcl_GetDouble(interp, argv[8], &cR2) != TCL_OK) { 00676 opserr << "WARNING invalid cR2\n"; 00677 printCommand(argc, argv); 00678 return 0; 00679 } 00680 if (argc > 12) { 00681 if (Tcl_GetDouble(interp, argv[9], &a1) != TCL_OK) { 00682 opserr << "WARNING invalid a1\n"; 00683 printCommand(argc, argv); 00684 return 0; 00685 } 00686 if (Tcl_GetDouble(interp, argv[10], &a2) != TCL_OK) { 00687 opserr << "WARNING invalid a2\n"; 00688 printCommand(argc, argv); 00689 return 0; 00690 } 00691 if (Tcl_GetDouble(interp, argv[11], &a3) != TCL_OK) { 00692 opserr << "WARNING invalid a3\n"; 00693 printCommand(argc, argv); 00694 return 0; 00695 } 00696 if (Tcl_GetDouble(interp, argv[12], &a4) != TCL_OK) { 00697 opserr << "WARNING invalid a4\n"; 00698 printCommand(argc, argv); 00699 return 0; 00700 } 00701 theMaterial = new Steel02(tag, fy, E, b, R0, cR1, cR2, a1, a2, a3, a4); 00702 } 00703 else 00704 theMaterial = new Steel02(tag, fy, E, b, R0, cR1, cR2); 00705 } 00706 else 00707 theMaterial = new Steel02(tag, fy, E, b); 00708 00709 } 00710 00711 00712 else if (strcmp(argv[1],"Steel03") == 0) { 00713 // Check that there is the minimum number of arguments 00714 if (argc < 9) { 00715 opserr << "WARNING insufficient arguments\n"; 00716 printCommand(argc,argv); 00717 opserr << "Want: uniaxialMaterial Steel03 tag? fy? E0? b? r? cR1 cR2?"; 00718 opserr << " <a1? a2? a3? a4?>" << endln; 00719 return TCL_ERROR; 00720 } 00721 00722 int tag; 00723 00724 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00725 opserr << "WARNING invalid uniaxialMaterial Steel03 tag" << endln; 00726 return TCL_ERROR; 00727 } 00728 00729 00730 // Read required Steel01 material parameters 00731 double fy, E, b, r, cR1, cR2; 00732 00733 if (Tcl_GetDouble(interp, argv[3], &fy) != TCL_OK) { 00734 opserr << "WARNING invalid fy\n"; 00735 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00736 return TCL_ERROR; 00737 } 00738 00739 00740 if (Tcl_GetDouble(interp, argv[4], &E) != TCL_OK) { 00741 opserr << "WARNING invalid E0\n"; 00742 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00743 return TCL_ERROR; 00744 } 00745 00746 if (Tcl_GetDouble(interp, argv[5], &b) != TCL_OK) { 00747 opserr << "WARNING invalid b\n"; 00748 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00749 return TCL_ERROR; 00750 } 00751 00752 if (Tcl_GetDouble(interp, argv[6], &r) != TCL_OK) { 00753 opserr << "WARNING invalid r\n"; 00754 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00755 return TCL_ERROR; 00756 } 00757 00758 00759 if (Tcl_GetDouble(interp, argv[7], &cR1) != TCL_OK) { 00760 opserr << "WARNING invalid cR1\n"; 00761 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00762 return TCL_ERROR; 00763 } 00764 00765 00766 if (Tcl_GetDouble(interp, argv[8], &cR2) != TCL_OK) { 00767 opserr << "WARNING invalid cR2\n"; 00768 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00769 return TCL_ERROR; 00770 } 00771 00772 // Read optional Steel01 material parameters 00773 double a1, a2, a3, a4; 00774 if (argc > 9) { 00775 if (argc < 13) { 00776 opserr << "WARNING insufficient number of hardening parameters\n"; 00777 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00778 return TCL_ERROR; 00779 } 00780 00781 if (Tcl_GetDouble(interp, argv[9], &a1) != TCL_OK) { 00782 opserr << "WARNING invalid a1\n"; 00783 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00784 return TCL_ERROR; 00785 } 00786 00787 if (Tcl_GetDouble(interp, argv[10], &a2) != TCL_OK) { 00788 opserr << "WARNING invalid a2\n"; 00789 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00790 return TCL_ERROR; 00791 } 00792 00793 if (Tcl_GetDouble(interp, argv[11], &a3) != TCL_OK) { 00794 opserr << "WARNING invalid a3\n"; 00795 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00796 return TCL_ERROR; 00797 } 00798 00799 00800 if (Tcl_GetDouble(interp, argv[12], &a4) != TCL_OK) { 00801 opserr << "WARNING invalid a4\n"; 00802 opserr << "uniaxialMaterial Steel03: " << tag << endln; 00803 return TCL_ERROR; 00804 } 00805 00806 00807 // Parsing was successful, allocate the material 00808 theMaterial = new Steel03 (tag, fy, E, b, r, cR1, cR2, a1, a2, a3, a4); 00809 } 00810 else 00811 // Parsing was successful, allocate the material 00812 theMaterial = new Steel03 (tag, fy, E, b, r, cR1, cR2); 00813 00814 } 00815 00816 00817 00818 else if (strcmp(argv[1],"Concrete01") == 0) { 00819 if (argc < 7) { 00820 opserr << "WARNING insufficient arguments\n"; 00821 printCommand(argc,argv); 00822 opserr << "Want: uniaxialMaterial Concrete01 tag? fpc? epsc0? fpcu? epscu?" << endln; 00823 return TCL_ERROR; 00824 } 00825 00826 int tag; 00827 00828 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00829 opserr << "WARNING invalid uniaxialMaterial Concrete01 tag" << endln; 00830 return TCL_ERROR; 00831 } 00832 00833 // Read required Concrete01 material parameters 00834 double fpc, epsc0, fpcu, epscu; 00835 00836 if (Tcl_GetDouble(interp, argv[3], &fpc) != TCL_OK) { 00837 opserr << "WARNING invalid fpc\n"; 00838 opserr << "Concrete01 material: " << tag << endln; 00839 return TCL_ERROR; 00840 } 00841 00842 if (Tcl_GetDouble(interp, argv[4], &epsc0) != TCL_OK) { 00843 opserr << "WARNING invalid epsc0\n"; 00844 opserr << "Concrete01 material: " << tag << endln; 00845 return TCL_ERROR; 00846 } 00847 00848 if (Tcl_GetDouble(interp, argv[5], &fpcu) != TCL_OK) { 00849 opserr << "WARNING invalid fpcu\n"; 00850 opserr << "Concrete01 material: " << tag << endln; 00851 return TCL_ERROR; 00852 } 00853 00854 if (Tcl_GetDouble(interp, argv[6], &epscu) != TCL_OK) { 00855 opserr << "WARNING invalid epscu\n"; 00856 opserr << "Concrete01 material: " << tag << endln; 00857 return TCL_ERROR; 00858 } 00859 00860 // Parsing was successful, allocate the material 00861 theMaterial = new Concrete01(tag, fpc, epsc0, fpcu, epscu); 00862 } 00863 00864 else if (strcmp(argv[1],"Concrete2") == 0 || strcmp(argv[1],"Concrete02") == 0) { 00865 if (argc < 10) { 00866 opserr << "WARNING invalid number of arguments\n"; 00867 printCommand(argc,argv); 00868 opserr << "Want: uniaxialMaterial Concrete02 tag? fpc? epsc0? fpcu? epscu? rat? ft? Ets?" << endln; 00869 return 0; 00870 } 00871 00872 double fpc, epsc0, fpcu, epscu; 00873 double rat, ft, Ets; 00874 int tag; 00875 00876 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 00877 opserr << "WARNING invalid uniaxialMaterial Concrete02 tag" << endln; 00878 return TCL_ERROR; 00879 } 00880 00881 if (Tcl_GetDouble(interp, argv[3], &fpc) != TCL_OK) { 00882 opserr << "WARNING invalid fpc\n"; 00883 printCommand(argc, argv); 00884 return 0; 00885 } 00886 00887 if (Tcl_GetDouble(interp, argv[4], &epsc0) != TCL_OK) { 00888 opserr << "WARNING invalid epsc0\n"; 00889 printCommand(argc, argv); 00890 return 0; 00891 } 00892 00893 if (Tcl_GetDouble(interp, argv[5], &fpcu) != TCL_OK) { 00894 opserr << "WARNING invalid fpcu\n"; 00895 printCommand(argc, argv); 00896 return 0; 00897 } 00898 00899 if (Tcl_GetDouble(interp, argv[6], &epscu) != TCL_OK) { 00900 opserr << "WARNING invalid epscu\n"; 00901 printCommand(argc, argv); 00902 return 0; 00903 } 00904 00905 if (Tcl_GetDouble(interp, argv[7], &rat) != TCL_OK) { 00906 opserr << "WARNING invalid rat\n"; 00907 printCommand(argc, argv); 00908 return 0; 00909 } 00910 00911 if (Tcl_GetDouble(interp, argv[8], &ft) != TCL_OK) { 00912 opserr << "WARNING invalid ft\n"; 00913 printCommand(argc, argv); 00914 return 0; 00915 } 00916 00917 if (Tcl_GetDouble(interp, argv[9], &Ets) != TCL_OK) { 00918 opserr << "WARNING invalid Ets\n"; 00919 printCommand(argc, argv); 00920 return 0; 00921 } 00922 00923 theMaterial = new Concrete02(tag, fpc, epsc0, fpcu, epscu, rat, ft, Ets); 00924 } 00925 00926 00927 00928 else if (strcmp(argv[1],"Hysteretic") == 0) { 00929 if (argc != 20 && argc != 19 && argc != 16 && argc != 15) { 00930 opserr << "WARNING insufficient arguments\n"; 00931 printCommand(argc,argv); 00932 opserr << "Want: uniaxialMaterial Hysteretic tag? mom1p? rot1p? mom2p? rot2p? <mom3p? rot3p?> " 00933 << "\nmom1n? rot1n? mom2n? rot2n? <mom3n? rot3n?> pinchX? pinchY? damfc1? damfc2? <beta?>"; 00934 return TCL_ERROR; 00935 } 00936 00937 int tag; 00938 double mom1p, mom2p, mom3p; 00939 double rot1p, rot2p, rot3p; 00940 double mom1n, mom2n, mom3n; 00941 double rot1n, rot2n, rot3n; 00942 double pinchX, pinchY; 00943 double damfc1, damfc2; 00944 double beta = 0.0; 00945 00946 int i = 2; 00947 00948 if (Tcl_GetInt(interp, argv[i++], &tag) != TCL_OK) { 00949 opserr << "WARNING invalid uniaxialMaterial Hysteretic tag" << endln; 00950 return TCL_ERROR; 00951 } 00952 00953 if (Tcl_GetDouble(interp, argv[i++], &mom1p) != TCL_OK) { 00954 opserr << "WARNING invalid mom1p\n"; 00955 opserr << "Hysteretic material: " << tag << endln; 00956 return TCL_ERROR; 00957 } 00958 00959 if (Tcl_GetDouble(interp, argv[i++], &rot1p) != TCL_OK) { 00960 opserr << "WARNING invalid rot1p\n"; 00961 opserr << "Hysteretic material: " << tag << endln; 00962 return TCL_ERROR; 00963 } 00964 00965 if (Tcl_GetDouble(interp, argv[i++], &mom2p) != TCL_OK) { 00966 opserr << "WARNING invalid mom2p\n"; 00967 opserr << "Hysteretic material: " << tag << endln; 00968 return TCL_ERROR; 00969 } 00970 00971 if (Tcl_GetDouble(interp, argv[i++], &rot2p) != TCL_OK) { 00972 opserr << "WARNING invalid rot2p\n"; 00973 opserr << "Hysteretic material: " << tag << endln; 00974 return TCL_ERROR; 00975 } 00976 00977 if (argc > 16) { 00978 if (Tcl_GetDouble(interp, argv[i++], &mom3p) != TCL_OK) { 00979 opserr << "WARNING invalid mom3p\n"; 00980 opserr << "Hysteretic material: " << tag << endln; 00981 return TCL_ERROR; 00982 } 00983 00984 if (Tcl_GetDouble(interp, argv[i++], &rot3p) != TCL_OK) { 00985 opserr << "WARNING invalid rot3p\n"; 00986 opserr << "Hysteretic material: " << tag << endln; 00987 return TCL_ERROR; 00988 } 00989 } 00990 00991 if (Tcl_GetDouble(interp, argv[i++], &mom1n) != TCL_OK) { 00992 opserr << "WARNING invalid mom1n\n"; 00993 opserr << "Hysteretic material: " << tag << endln; 00994 return TCL_ERROR; 00995 } 00996 00997 if (Tcl_GetDouble(interp, argv[i++], &rot1n) != TCL_OK) { 00998 opserr << "WARNING invalid rot1n\n"; 00999 opserr << "Hysteretic material: " << tag << endln; 01000 return TCL_ERROR; 01001 } 01002 01003 if (Tcl_GetDouble(interp, argv[i++], &mom2n) != TCL_OK) { 01004 opserr << "WARNING invalid mom2n\n"; 01005 opserr << "Hysteretic material: " << tag << endln; 01006 return TCL_ERROR; 01007 } 01008 01009 if (Tcl_GetDouble(interp, argv[i++], &rot2n) != TCL_OK) { 01010 opserr << "WARNING invalid rot2n\n"; 01011 opserr << "Hysteretic material: " << tag << endln; 01012 return TCL_ERROR; 01013 } 01014 01015 if (argc > 16) { 01016 if (Tcl_GetDouble(interp, argv[i++], &mom3n) != TCL_OK) { 01017 opserr << "WARNING invalid mom3n\n"; 01018 opserr << "Hysteretic material: " << tag << endln; 01019 return TCL_ERROR; 01020 } 01021 01022 if (Tcl_GetDouble(interp, argv[i++], &rot3n) != TCL_OK) { 01023 opserr << "WARNING invalid rot3n\n"; 01024 opserr << "Hysteretic material: " << tag << endln; 01025 return TCL_ERROR; 01026 } 01027 } 01028 01029 if (Tcl_GetDouble(interp, argv[i++], &pinchX) != TCL_OK) { 01030 opserr << "WARNING invalid pinchX\n"; 01031 opserr << "Hysteretic material: " << tag << endln; 01032 return TCL_ERROR; 01033 } 01034 01035 if (Tcl_GetDouble(interp, argv[i++], &pinchY) != TCL_OK) { 01036 opserr << "WARNING invalid pinchY\n"; 01037 opserr << "Hysteretic material: " << tag << endln; 01038 return TCL_ERROR; 01039 } 01040 01041 if (Tcl_GetDouble(interp, argv[i++], &damfc1) != TCL_OK) { 01042 opserr << "WARNING invalid damfc1\n"; 01043 opserr << "Hysteretic material: " << tag << endln; 01044 return TCL_ERROR; 01045 } 01046 01047 if (Tcl_GetDouble(interp, argv[i++], &damfc2) != TCL_OK) { 01048 opserr << "WARNING invalid damfc2\n"; 01049 opserr << "Hysteretic material: " << tag << endln; 01050 return TCL_ERROR; 01051 } 01052 01053 if (argc == 20 || argc == 16) { 01054 if (Tcl_GetDouble(interp, argv[i++], &beta) != TCL_OK) { 01055 opserr << "WARNING invalid beta\n"; 01056 opserr << "Hysteretic material: " << tag << endln; 01057 return TCL_ERROR; 01058 } 01059 } 01060 01061 // Parsing was successful, allocate the material 01062 01063 if (argc > 16) 01064 theMaterial = new HystereticMaterial (tag, 01065 mom1p, rot1p, mom2p, rot2p, mom3p, rot3p, 01066 mom1n, rot1n, mom2n, rot2n, mom3n, rot3n, 01067 pinchX, pinchY, damfc1, damfc2, beta); 01068 01069 else 01070 theMaterial = new HystereticMaterial (tag, 01071 mom1p, rot1p, mom2p, rot2p, 01072 mom1n, rot1n, mom2n, rot2n, 01073 pinchX, pinchY, damfc1, damfc2, beta); 01074 } 01075 01076 else if (strcmp(argv[1],"Concrete04") == 0) { 01077 // opserr << argc << endln; 01078 if (argc != 10 && argc != 9 && argc != 7) { 01079 opserr << "WARNING insufficient arguments\n"; 01080 printCommand(argc,argv); 01081 opserr << "Want: uniaxialMaterial Concrete04 tag? fpc? epsc0? epscu? Ec0? <ft? etu? <beta?> >" << endln; 01082 return TCL_ERROR; 01083 } 01084 01085 int tag; 01086 01087 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 01088 opserr << "WARNING invalid uniaxialMaterial Concrete04 tag" 01089 << endln; 01090 return TCL_ERROR; 01091 } 01092 01093 // Read required Concrete04 material parameters 01094 double fpc, epsc0, ft, epscu, Ec0, etu, beta; 01095 01096 if (Tcl_GetDouble(interp, argv[3], &fpc) != TCL_OK) { 01097 opserr << "WARNING invalid fpc\n"; 01098 opserr << "Concrete04 material: " << tag << endln; 01099 return TCL_ERROR; 01100 } 01101 01102 if (Tcl_GetDouble(interp, argv[4], &epsc0) != TCL_OK) { 01103 opserr << "WARNING invalid epsc0\n"; 01104 opserr << "Concrete04 material: " << tag << endln; 01105 return TCL_ERROR; 01106 } 01107 01108 if (Tcl_GetDouble(interp, argv[5], &epscu) != TCL_OK) { 01109 opserr << "WARNING invalid epscu\n"; 01110 opserr << "Concrete04 material: " << tag << endln; 01111 return TCL_ERROR; 01112 } 01113 01114 if (Tcl_GetDouble(interp, argv[6], &Ec0) != TCL_OK) { 01115 opserr << "WARNING invalid Ec0\n"; 01116 opserr << "Concrete04 material: " << tag << endln; 01117 return TCL_ERROR; 01118 } 01119 if (argc == 9 || argc == 10) { 01120 if (Tcl_GetDouble(interp, argv[7], &ft) != TCL_OK) { 01121 opserr << "WARNING invalid ft\n"; 01122 opserr << "Concrete04 material: " << tag << endln; 01123 return TCL_ERROR; 01124 } 01125 if (Tcl_GetDouble(interp, argv[8], &etu) != TCL_OK) { 01126 opserr << "WARNING invalid etu\n"; 01127 opserr << "Concrete04 material: " << tag << endln; 01128 return TCL_ERROR; 01129 } 01130 } 01131 if (argc == 10) { 01132 if (Tcl_GetDouble(interp, argv[9], &beta) != TCL_OK) { 01133 opserr << "WARNING invalid beta\n"; 01134 opserr << "Concrete04 material: " << tag << endln; 01135 return TCL_ERROR; 01136 } 01137 } 01138 01139 01140 // Parsing was successful, allocate the material 01141 if (argc == 10) { 01142 theMaterial = new Concrete04(tag, fpc, epsc0, epscu, Ec0, 01143 ft, etu, beta); 01144 } 01145 else if (argc == 9) { 01146 theMaterial = new Concrete04(tag, fpc, epsc0, epscu, Ec0, 01147 ft, etu); 01148 } 01149 else if (argc == 7) { 01150 theMaterial = new Concrete04(tag, fpc, epsc0, epscu, Ec0); 01151 } 01152 } 01153 01154 else if (strcmp(argv[1],"Viscous") == 0) { 01155 if (argc < 5) 01156 { 01157 opserr << "WARNING insufficient arguments\n"; 01158 printCommand(argc,argv); 01159 opserr << "Want: uniaxialMaterial Viscous tag? C? alpha?" << endln; 01160 return TCL_ERROR; 01161 } 01162 01163 int tag; 01164 double C, a; 01165 01166 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) 01167 { 01168 opserr << "WARNING invalid tag\n"; 01169 opserr << "Viscous material: " << tag << endln; 01170 return TCL_ERROR; 01171 } 01172 if (Tcl_GetDouble(interp, argv[3], &C) != TCL_OK) 01173 { 01174 opserr << "WARNING invalid C\n"; 01175 opserr << "Viscous material: " << tag << endln; 01176 return TCL_ERROR; 01177 } 01178 if (Tcl_GetDouble(interp, argv[4], &a) != TCL_OK) 01179 { 01180 opserr << "WARNING invalid alpha\n"; 01181 opserr << "Viscous material: " << tag << endln; 01182 return TCL_ERROR; 01183 } 01184 01185 theMaterial = new ViscousMaterial (tag, C, a); 01186 } 01187 01188 else if (strcmp(argv[1],"PathIndependent") == 0) { 01189 if (argc < 4) 01190 { 01191 opserr << "WARNING insufficient arguments\n"; 01192 printCommand(argc,argv); 01193 opserr << "Want: uniaxialMaterial PathIndependent tag? matTag?" << endln; 01194 return TCL_ERROR; 01195 } 01196 01197 int tag, matTag; 01198 01199 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) 01200 { 01201 opserr << "WARNING invalid tag\n"; 01202 opserr << "PathIndependent material: " << tag << endln; 01203 return TCL_ERROR; 01204 } 01205 01206 if (Tcl_GetInt(interp, argv[3], &matTag) != TCL_OK) 01207 { 01208 opserr << "WARNING invalid matTag\n"; 01209 opserr << "PathIndependent material: " << tag << endln; 01210 return TCL_ERROR; 01211 } 01212 01213 UniaxialMaterial *material = theTclBuilder->getUniaxialMaterial(matTag); 01214 01215 if (material == 0) { 01216 opserr << "WARNING material does not exist\n"; 01217 opserr << "material: " << matTag; 01218 opserr << "\nuniaxialMaterial PathIndependent: " << tag << endln; 01219 return TCL_ERROR; 01220 } 01221 01222 theMaterial = new PathIndependentMaterial (tag, *material); 01223 } 01224 01225 else if (strcmp(argv[1],"MinMax") == 0) { 01226 if (argc < 4) { 01227 opserr << "WARNING insufficient arguments\n"; 01228 printCommand(argc,argv); 01229 opserr << "Want: uniaxialMaterial MinMax tag? matTag?"; 01230 opserr << " <-min min?> <-max max?>" << endln; 01231 return TCL_ERROR; 01232 } 01233 01234 int tag, matTag; 01235 01236 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 01237 opserr << "WARNING invalid uniaxialMaterial MinMax tag" << endln; 01238 return TCL_ERROR; 01239 } 01240 01241 if (Tcl_GetInt(interp, argv[3], &matTag) != TCL_OK) { 01242 opserr << "WARNING invalid component tag\n"; 01243 opserr << "uniaxialMaterial MinMax: " << tag << endln; 01244 return TCL_ERROR; 01245 } 01246 01247 // Search for min and max strains 01248 double epsmin = NEG_INF_STRAIN; 01249 double epsmax = POS_INF_STRAIN; 01250 01251 for (int j = 4; j < argc; j++) { 01252 if (strcmp(argv[j],"-min") == 0) { 01253 if ((j+1) >= argc || Tcl_GetDouble (interp, argv[j+1], &epsmin) != TCL_OK) { 01254 opserr << "WARNING invalid min\n"; 01255 opserr << "uniaxialMaterial MinMax: " << tag << endln; 01256 return TCL_ERROR; 01257 } 01258 j++; 01259 } 01260 if (strcmp(argv[j],"-max") == 0) { 01261 if ((j+1) >= argc || Tcl_GetDouble (interp, argv[j+1], &epsmax) != TCL_OK) { 01262 opserr << "WARNING invalid max\n"; 01263 opserr << "uniaxialMaterial MinMax: " << tag << endln; 01264 return TCL_ERROR; 01265 } 01266 j++; 01267 } 01268 } 01269 01270 UniaxialMaterial *theMat = theTclBuilder->getUniaxialMaterial(matTag); 01271 01272 if (theMat == 0) { 01273 opserr << "WARNING component material does not exist\n"; 01274 opserr << "Component material: " << matTag; 01275 opserr << "\nuniaxialMaterial MinMax: " << tag << endln; 01276 return TCL_ERROR; 01277 } 01278 01279 // Parsing was successful, allocate the material 01280 theMaterial = new MinMaxMaterial(tag, *theMat, epsmin, epsmax); 01281 01282 } 01283 01284 else if (strcmp(argv[1],"Fatigue") == 0) { 01285 if (argc < 4) { 01286 opserr << "WARNING insufficient arguments\n"; 01287 printCommand(argc,argv); 01288 opserr << "Want: uniaxialMaterial Fatigue tag? matTag?"; 01289 opserr << " <-D_max dmax?> <-e0 e0?> <-m m?>" << endln; 01290 opserr << " <-min min?> <-max max?>" << endln; 01291 return TCL_ERROR; 01292 } 01293 01294 int tag, matTag; 01295 01296 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 01297 opserr << "WARNING invalid uniaxialMaterial Fatigue tag" << endln; 01298 return TCL_ERROR; 01299 } 01300 01301 if (Tcl_GetInt(interp, argv[3], &matTag) != TCL_OK) { 01302 opserr << "WARNING invalid component tag\n"; 01303 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01304 return TCL_ERROR; 01305 } 01306 01307 double Dmax = 1.0; 01308 double E0 = 0.191; 01309 double m = -0.458; 01310 double epsmin = NEG_INF_STRAIN; 01311 double epsmax = POS_INF_STRAIN; 01312 01313 for (int j = 4; j < argc; j++) { 01314 if (strcmp(argv[j],"-Dmax") == 0) { 01315 if ((j+1 >= argc) || 01316 (Tcl_GetDouble (interp, argv[j+1], &Dmax) != TCL_OK)) { 01317 opserr << "WARNING invalid -Dmax"; 01318 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01319 return TCL_ERROR; 01320 } 01321 } else if (strcmp(argv[j],"-E0") == 0) { 01322 if ((j+1 >= argc) || 01323 (Tcl_GetDouble (interp, argv[j+1], &E0) != TCL_OK)) { 01324 opserr << "WARNING invalid -E0"; 01325 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01326 return TCL_ERROR; 01327 } 01328 } else if (strcmp(argv[j],"-m") == 0) { 01329 if ((j+1 >= argc) || 01330 (Tcl_GetDouble (interp, argv[j+1], &m) != TCL_OK)) { 01331 opserr << "WARNING invalid -m"; 01332 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01333 return TCL_ERROR; 01334 } 01335 } else if (strcmp(argv[j],"-min") == 0) { 01336 if ((j+1 >= argc) || 01337 (Tcl_GetDouble (interp, argv[j+1], &epsmin) != TCL_OK)) { 01338 opserr << "WARNING invalid -min "; 01339 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01340 return TCL_ERROR; 01341 } 01342 } else if (strcmp(argv[j],"-max") == 0) { 01343 if ((j+1 >= argc) || 01344 (Tcl_GetDouble (interp, argv[j+1], &epsmax) != TCL_OK)) { 01345 opserr << "WARNING invalid -max"; 01346 opserr << "uniaxialMaterial Fatigue: " << tag << endln; 01347 return TCL_ERROR; 01348 } 01349 } 01350 j++; 01351 } 01352 01353 01354 UniaxialMaterial *theMat = theTclBuilder->getUniaxialMaterial(matTag); 01355 01356 if (theMat == 0) { 01357 opserr << "WARNING component material does not exist\n"; 01358 opserr << "Component material: " << matTag; 01359 opserr << "\nuniaxialMaterial Fatigue: " << tag << endln; 01360 return TCL_ERROR; 01361 } 01362 01363 // Parsing was successful, allocate the material 01364 theMaterial = new FatigueMaterial(tag, *theMat, Dmax, E0, 01365 m, epsmin, epsmax); 01366 01367 } 01368 else if (strcmp(argv[1],"Cable") == 0) 01369 { 01370 if (argc != 7) { 01371 opserr << "WARNING invalid number of arguments\n"; 01372 printCommand(argc,argv); 01373 opserr << "Want: uniaxialMaterial Cable tag? Prestress? E? effUnitWeight? L_element?>" << endln; 01374 return TCL_ERROR; 01375 } 01376 01377 int tag; 01378 double Ps, E, unitWeight, L_element; 01379 01380 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 01381 opserr << "WARNING invalid uniaxialMaterial Cable tag" << endln; 01382 return TCL_ERROR; 01383 } 01384 01385 if (Tcl_GetDouble(interp, argv[3], &Ps) != TCL_OK) { 01386 opserr << "WARNING invalid Prestress\n"; 01387 opserr << "uniaxiaMaterial Cable: " << tag << endln; 01388 return TCL_ERROR; 01389 } 01390 01391 if (Tcl_GetDouble(interp, argv[4], &E) != TCL_OK) { 01392 opserr << "WARNING invalid E\n"; 01393 opserr << "uniaxiaMaterial Cable: " << tag << endln; 01394 return TCL_ERROR; 01395 } 01396 01397 if (Tcl_GetDouble(interp, argv[5], &unitWeight) != TCL_OK) { 01398 opserr << "WARNING invalid unit weight\n"; 01399 opserr << "uniaxiaMaterial Cable: " << tag << endln; 01400 return TCL_ERROR; 01401 } 01402 01403 if (Tcl_GetDouble(interp, argv[6], &L_element) != TCL_OK) { 01404 opserr << "WARNING invalid uniaxialMaterial Cable Length " << endln; 01405 return TCL_ERROR; 01406 } 01407 01408 01409 theMaterial = new CableMaterial(tag, Ps, E, unitWeight, L_element); 01410 } 01411 01412 else if (strcmp(argv[1],"Pinching4") == 0) { 01413 if (argc != 42 && argc != 31 ) { 01414 opserr << "WARNING insufficient arguments\n"; 01415 printCommand(argc,argv); 01416 opserr << "Want: uniaxialMaterial Pinching4 tag? stress1p? strain1p? stress2p? strain2p? stress3p? strain3p? stress4p? strain4p? " 01417 << "\n<stress1n? strain1n? stress2n? strain2n? stress3n? strain3n? stress4n? strain4n?> rDispP? rForceP? uForceP? " 01418 << "\n<rDispN? rForceN? uForceN?> gammaK1? gammaK2? gammaK3? gammaK4? gammaKLimit? gammaD1? gammaD2? gammaD3? gammaD4? " 01419 << "\ngammaDLimit? gammaF1? gammaF2? gammaF3? gammaF4? gammaFLimit? gammaE? CycleOrEnergyDamage? "; 01420 return TCL_ERROR; 01421 } 01422 01423 int tag, tDmg; 01424 double stress1p, stress2p, stress3p, stress4p; 01425 double strain1p, strain2p, strain3p, strain4p; 01426 double stress1n, stress2n, stress3n, stress4n; 01427 double strain1n, strain2n, strain3n, strain4n; 01428 double rDispP, rForceP, uForceP, rDispN, rForceN, uForceN; 01429 double gammaK1, gammaK2, gammaK3, gammaK4, gammaKLimit; 01430 double gammaD1, gammaD2, gammaD3, gammaD4, gammaDLimit; 01431 double gammaF1, gammaF2, gammaF3, gammaF4, gammaFLimit; 01432 double gammaE; 01433 01434 int i = 2; 01435 01436 if (Tcl_GetInt(interp, argv[i++], &tag) != TCL_OK) { 01437 opserr << "WARNING invalid uniaxialMaterial Pinching4 tag" << endln; 01438 return TCL_ERROR; 01439 } 01440 01441 if (Tcl_GetDouble(interp, argv[i++], &stress1p) != TCL_OK) { 01442 opserr << "WARNING invalid stress1p\n"; 01443 opserr << "Pinching4 material: " << tag << endln; 01444 return TCL_ERROR; 01445 } 01446 01447 if (Tcl_GetDouble(interp, argv[i++], &strain1p) != TCL_OK) { 01448 opserr << "WARNING invalid strain1p\n"; 01449 opserr << "Pinching4 material: " << tag << endln; 01450 return TCL_ERROR; 01451 } 01452 01453 if (Tcl_GetDouble(interp, argv[i++], &stress2p) != TCL_OK) { 01454 opserr << "WARNING invalid stress2p\n"; 01455 opserr << "Pinching4 material: " << tag << endln; 01456 return TCL_ERROR; 01457 } 01458 01459 if (Tcl_GetDouble(interp, argv[i++], &strain2p) != TCL_OK) { 01460 opserr << "WARNING invalid strain2p\n"; 01461 opserr << "Pinching4 material: " << tag << endln; 01462 return TCL_ERROR; 01463 } 01464 01465 if (Tcl_GetDouble(interp, argv[i++], &stress3p) != TCL_OK) { 01466 opserr << "WARNING invalid stress3p\n"; 01467 opserr << "Pinching4 material: " << tag << endln; 01468 return TCL_ERROR; 01469 } 01470 01471 if (Tcl_GetDouble(interp, argv[i++], &strain3p) != TCL_OK) { 01472 opserr << "WARNING invalid strain3p\n"; 01473 opserr << "Pinching4 material: " << tag << endln; 01474 return TCL_ERROR; 01475 } 01476 01477 if (Tcl_GetDouble(interp, argv[i++], &stress4p) != TCL_OK) { 01478 opserr << "WARNING invalid stress4p\n"; 01479 opserr << "Pinching4 material: " << tag << endln; 01480 return TCL_ERROR; 01481 } 01482 01483 if (Tcl_GetDouble(interp, argv[i++], &strain4p) != TCL_OK) { 01484 opserr << "WARNING invalid strain4p\n"; 01485 opserr << "Pinching4 material: " << tag << endln; 01486 return TCL_ERROR; 01487 } 01488 01489 if (argc == 42) { 01490 if (Tcl_GetDouble(interp, argv[i++], &stress1n) != TCL_OK) { 01491 opserr << "WARNING invalid stress1n\n"; 01492 opserr << "Pinching4 material: " << tag << endln; 01493 return TCL_ERROR; 01494 } 01495 01496 if (Tcl_GetDouble(interp, argv[i++], &strain1n) != TCL_OK) { 01497 opserr << "WARNING invalid strain1n\n"; 01498 opserr << "Pinching4 material: " << tag << endln; 01499 return TCL_ERROR; 01500 } 01501 01502 if (Tcl_GetDouble(interp, argv[i++], &stress2n) != TCL_OK) { 01503 opserr << "WARNING invalid stress2n\n"; 01504 opserr << "Pinching4 material: " << tag << endln; 01505 return TCL_ERROR; 01506 } 01507 01508 if (Tcl_GetDouble(interp, argv[i++], &strain2n) != TCL_OK) { 01509 opserr << "WARNING invalid strain2n\n"; 01510 opserr << "Pinching4 material: " << tag << endln; 01511 return TCL_ERROR; 01512 } 01513 01514 if (Tcl_GetDouble(interp, argv[i++], &stress3n) != TCL_OK) { 01515 opserr << "WARNING invalid stress3n\n"; 01516 opserr << "Pinching4 material: " << tag << endln; 01517 return TCL_ERROR; 01518 } 01519 01520 if (Tcl_GetDouble(interp, argv[i++], &strain3n) != TCL_OK) { 01521 opserr << "WARNING invalid strain3n\n"; 01522 opserr << "Pinching4 material: " << tag << endln; 01523 return TCL_ERROR; 01524 } 01525 01526 if (Tcl_GetDouble(interp, argv[i++], &stress4n) != TCL_OK) { 01527 opserr << "WARNING invalid stress4n\n"; 01528 opserr << "Pinching4 material: " << tag << endln; 01529 return TCL_ERROR; 01530 } 01531 01532 if (Tcl_GetDouble(interp, argv[i++], &strain4n) != TCL_OK) { 01533 opserr << "WARNING invalid strain4n\n"; 01534 opserr << "Pinching4 material: " << tag << endln; 01535 return TCL_ERROR; 01536 } 01537 01538 } 01539 01540 01541 if (Tcl_GetDouble(interp, argv[i++], &rDispP) != TCL_OK) { 01542 opserr << "WARNING invalid rDispP\n"; 01543 opserr << "Pinching4 material: " << tag << endln; 01544 return TCL_ERROR; 01545 } 01546 01547 if (Tcl_GetDouble(interp, argv[i++], &rForceP) != TCL_OK) { 01548 opserr << "WARNING invalid rForceP\n"; 01549 opserr << "Pinching4 material: " << tag << endln; 01550 return TCL_ERROR; 01551 } 01552 01553 if (Tcl_GetDouble(interp, argv[i++], &uForceP) != TCL_OK) { 01554 opserr << "WARNING invalid uForceP\n"; 01555 opserr << "Pinching4 material: " << tag << endln; 01556 return TCL_ERROR; 01557 } 01558 01559 if (argc == 42) { 01560 if (Tcl_GetDouble(interp, argv[i++], &rDispN) != TCL_OK) { 01561 opserr << "WARNING invalid rDispN\n"; 01562 opserr << "Pinching4 material: " << tag << endln; 01563 return TCL_ERROR; 01564 } 01565 01566 if (Tcl_GetDouble(interp, argv[i++], &rForceN) != TCL_OK) { 01567 opserr << "WARNING invalid rForceN\n"; 01568 opserr << "Pinching4 material: " << tag << endln; 01569 return TCL_ERROR; 01570 } 01571 01572 if (Tcl_GetDouble(interp, argv[i++], &uForceN) != TCL_OK) { 01573 opserr << "WARNING invalid uForceN\n"; 01574 opserr << "Pinching4 material: " << tag << endln; 01575 return TCL_ERROR; 01576 } 01577 } 01578 01579 if (Tcl_GetDouble(interp, argv[i++], &gammaK1) != TCL_OK) { 01580 opserr << "WARNING invalid gammaK1\n"; 01581 opserr << "Pinching4 material: " << tag << endln; 01582 return TCL_ERROR; 01583 } 01584 if (Tcl_GetDouble(interp, argv[i++], &gammaK2) != TCL_OK) { 01585 opserr << "WARNING invalid gammaK2\n"; 01586 opserr << "Pinching4 material: " << tag << endln; 01587 return TCL_ERROR; 01588 } 01589 if (Tcl_GetDouble(interp, argv[i++], &gammaK3) != TCL_OK) { 01590 opserr << "WARNING invalid gammaK3\n"; 01591 opserr << "Pinching4 material: " << tag << endln; 01592 return TCL_ERROR; 01593 } 01594 if (Tcl_GetDouble(interp, argv[i++], &gammaK4) != TCL_OK) { 01595 opserr << "WARNING invalid gammaK4\n"; 01596 opserr << "Pinching4 material: " << tag << endln; 01597 return TCL_ERROR; 01598 } 01599 if (Tcl_GetDouble(interp, argv[i++], &gammaKLimit) != TCL_OK) { 01600 opserr << "WARNING invalid gammaKLimit\n"; 01601 opserr << "Pinching4 material: " << tag << endln; 01602 return TCL_ERROR; 01603 } 01604 if (Tcl_GetDouble(interp, argv[i++], &gammaD1) != TCL_OK) { 01605 opserr << "WARNING invalid gammaD1\n"; 01606 opserr << "Pinching4 material: " << tag << endln; 01607 return TCL_ERROR; 01608 } 01609 if (Tcl_GetDouble(interp, argv[i++], &gammaD2) != TCL_OK) { 01610 opserr << "WARNING invalid gammaD2\n"; 01611 opserr << "Pinching4 material: " << tag << endln; 01612 return TCL_ERROR; 01613 } 01614 if (Tcl_GetDouble(interp, argv[i++], &gammaD3) != TCL_OK) { 01615 opserr << "WARNING invalid gammaD3\n"; 01616 opserr << "Pinching4 material: " << tag << endln; 01617 return TCL_ERROR; 01618 } 01619 if (Tcl_GetDouble(interp, argv[i++], &gammaD4) != TCL_OK) { 01620 opserr << "WARNING invalid gammaD4\n"; 01621 opserr << "Pinching4 material: " << tag << endln; 01622 return TCL_ERROR; 01623 } 01624 if (Tcl_GetDouble(interp, argv[i++], &gammaDLimit) != TCL_OK) { 01625 opserr << "WARNING invalid gammaDLimit\n"; 01626 opserr << "Pinching4 material: " << tag << endln; 01627 return TCL_ERROR; 01628 } 01629 if (Tcl_GetDouble(interp, argv[i++], &gammaF1) != TCL_OK) { 01630 opserr << "WARNING invalid gammaF1\n"; 01631 opserr << "Pinching4 material: " << tag << endln; 01632 return TCL_ERROR; 01633 } 01634 if (Tcl_GetDouble(interp, argv[i++], &gammaF2) != TCL_OK) { 01635 opserr << "WARNING invalid gammaF2\n"; 01636 opserr << "Pinching4 material: " << tag << endln; 01637 return TCL_ERROR; 01638 } 01639 if (Tcl_GetDouble(interp, argv[i++], &gammaF3) != TCL_OK) { 01640 opserr << "WARNING invalid gammaF3\n"; 01641 opserr << "Pinching4 material: " << tag << endln; 01642 return TCL_ERROR; 01643 } 01644 if (Tcl_GetDouble(interp, argv[i++], &gammaF4) != TCL_OK) { 01645 opserr << "WARNING invalid gammaF4\n"; 01646 opserr << "Pinching4 material: " << tag << endln; 01647 return TCL_ERROR; 01648 } 01649 if (Tcl_GetDouble(interp, argv[i++], &gammaFLimit) != TCL_OK) { 01650 opserr << "WARNING invalid gammaFLimit\n"; 01651 opserr << "Pinching4 material: " << tag << endln; 01652 return TCL_ERROR; 01653 } 01654 01655 if (Tcl_GetDouble(interp, argv[i++], &gammaE) != TCL_OK) { 01656 opserr << "WARNING invalid gammaE\n"; 01657 opserr << "Pinching4 material: " << tag << endln; 01658 return TCL_ERROR; 01659 } 01660 01661 int y; 01662 y = i; 01663 01664 if ((strcmp(argv[y],"cycle") == 0) || (strcmp(argv[y],"Cycle") == 0) || (strcmp(argv[y],"DamageCycle") == 0) || (strcmp(argv[y],"damageCycle") == 0)) 01665 { tDmg = 1; } 01666 else if ((strcmp(argv[y],"energy") == 0) || (strcmp(argv[y],"Energy") == 0) || (strcmp(argv[y],"DamageEnergy") == 0) || (strcmp(argv[y],"damageEnergy") == 0)) 01667 { tDmg = 0; } 01668 else 01669 { 01670 opserr << "WARNING invalid type of damage calculation specified\n"; 01671 opserr << "Pinching4 material: " << tag << endln; 01672 return TCL_ERROR; 01673 } 01674 01675 // allocate the pinching material 01676 if (argc == 42) { 01677 theMaterial = new Pinching4Material (tag, 01678 stress1p, strain1p, stress2p, strain2p, stress3p, strain3p, stress4p, strain4p, 01679 stress1n, strain1n, stress2n, strain2n, stress3n, strain3n, stress4n, strain4n, 01680 rDispP, rForceP, uForceP, rDispN, rForceN, uForceN, 01681 gammaK1, gammaK2, gammaK3, gammaK4, gammaKLimit, 01682 gammaD1, gammaD2, gammaD3, gammaD4, gammaDLimit, 01683 gammaF1, gammaF2, gammaF3, gammaF4, gammaFLimit, gammaE, tDmg); 01684 } 01685 if (argc == 31) { 01686 theMaterial = new Pinching4Material (tag, 01687 stress1p, strain1p, stress2p, strain2p, stress3p, strain3p, stress4p, strain4p, 01688 rDispP, rForceP, uForceP, 01689 gammaK1, gammaK2, gammaK3, gammaK4, gammaKLimit, 01690 gammaD1, gammaD2, gammaD3, gammaD4, gammaDLimit, 01691 gammaF1, gammaF2, gammaF3, gammaF4, gammaFLimit, gammaE, tDmg); 01692 } 01693 } 01694 01695 else if (strcmp(argv[1],"BarSlip") == 0) 01696 { 01697 if (argc != 17 && argc != 15) 01698 { 01699 opserr << "WARNING insufficient arguments\n"; 01700 printCommand(argc,argv); 01701 opserr << "Want: uniaxialMaterial BarSlip tag? fc? fy? Es? fu? Eh? db? ld? nb? width? depth? bsflag? type? <damage? unit?>" << endln; 01702 return TCL_ERROR; 01703 } 01704 01705 int tag, nb, bsf, typ, dmg, unt; 01706 double fc, fy, Es, fu, Eh, ld, width, depth, db; 01707 01708 int argStart = 2; 01709 01710 if (Tcl_GetInt(interp, argv[argStart++], &tag) != TCL_OK) 01711 { 01712 opserr << "WARNING invalid tag\n"; 01713 opserr << "BarSlip: " << tag << endln; 01714 return TCL_ERROR; 01715 } 01716 if (Tcl_GetDouble(interp, argv[argStart++], &fc) != TCL_OK) 01717 { 01718 opserr << "WARNING invalid fc\n"; 01719 opserr << "BarSlip: " << tag << endln; 01720 return TCL_ERROR; 01721 } 01722 if (Tcl_GetDouble(interp, argv[argStart++], &fy) != TCL_OK) 01723 { 01724 opserr << "WARNING invalid fy\n"; 01725 opserr << "BarSlip: " << tag << endln; 01726 return TCL_ERROR; 01727 } 01728 if (Tcl_GetDouble(interp, argv[argStart++], &Es) != TCL_OK) 01729 { 01730 opserr << "WARNING invalid Es\n"; 01731 opserr << "BarSlip: " << tag << endln; 01732 return TCL_ERROR; 01733 } 01734 if (Tcl_GetDouble(interp, argv[argStart++], &fu) != TCL_OK) 01735 { 01736 opserr << "WARNING invalid fu\n"; 01737 opserr << "BarSlip: " << tag << endln; 01738 return TCL_ERROR; 01739 } 01740 if (Tcl_GetDouble(interp, argv[argStart++], &Eh) != TCL_OK) 01741 { 01742 opserr << "WARNING invalid Eh\n"; 01743 opserr << "BarSlip: " << tag << endln; 01744 return TCL_ERROR; 01745 } 01746 if (Tcl_GetDouble(interp, argv[argStart++], &db) != TCL_OK) 01747 { 01748 opserr << "WARNING invalid db\n"; 01749 opserr << "BarSlip: " << tag << endln; 01750 return TCL_ERROR; 01751 } 01752 if (Tcl_GetDouble(interp, argv[argStart++], &ld) != TCL_OK) 01753 { 01754 opserr << "WARNING invalid ld\n"; 01755 opserr << "BarSlip: " << tag << endln; 01756 return TCL_ERROR; 01757 } 01758 if (Tcl_GetInt(interp, argv[argStart++], &nb) != TCL_OK) 01759 { 01760 opserr << "WARNING invalid nbars\n"; 01761 opserr << "BarSlip: " << tag << endln; 01762 return TCL_ERROR; 01763 } 01764 if (Tcl_GetDouble(interp, argv[argStart++], &width) != TCL_OK) 01765 { 01766 opserr << "WARNING invalid width\n"; 01767 opserr << "BarSlip: " << tag << endln; 01768 return TCL_ERROR; 01769 } 01770 if (Tcl_GetDouble(interp, argv[argStart++], &depth) != TCL_OK) 01771 { 01772 opserr << "WARNING invalid depth\n"; 01773 opserr << "BarSlip: " << tag << endln; 01774 return TCL_ERROR; 01775 } 01776 01777 int y; 01778 y = argStart; 01779 01780 01781 if ((strcmp(argv[y],"strong") == 0) || (strcmp(argv[y],"Strong") == 0) || (strcmp(argv[y],"weak") == 0) || (strcmp(argv[y],"Weak") == 0)) 01782 { 01783 if ((strcmp(argv[y],"strong") == 0) || (strcmp(argv[y],"Strong") == 0)) 01784 { 01785 bsf = 0; 01786 } 01787 01788 if ((strcmp(argv[y],"weak") == 0) || (strcmp(argv[y],"Weak") == 0)) 01789 { 01790 bsf = 1; 01791 } 01792 } 01793 else 01794 { 01795 opserr << "WARNING invalid bond strength specified\n"; 01796 opserr << "BarSlip: " << tag << endln; 01797 return TCL_ERROR; 01798 } 01799 y ++; 01800 01801 if ((strcmp(argv[y],"beamtop") == 0) || (strcmp(argv[y],"beamTop") == 0) || 01802 (strcmp(argv[y],"beambot") == 0) || (strcmp(argv[y],"beamBot") == 0) || (strcmp(argv[y],"beambottom") == 0) || (strcmp(argv[y],"beamBottom") == 0) || 01803 (strcmp(argv[y],"beam") == 0) || (strcmp(argv[y],"Beam") == 0) || (strcmp(argv[y],"Column") == 0) || (strcmp(argv[y],"column") == 0)) 01804 { 01805 if ((strcmp(argv[y],"beamtop") == 0) || (strcmp(argv[y],"beamTop") == 0) || (strcmp(argv[y],"beam") == 0) || (strcmp(argv[y],"Beam") == 0)) 01806 { 01807 typ = 0; 01808 } 01809 01810 if ((strcmp(argv[y],"beambot") == 0) || (strcmp(argv[y],"beamBot") == 0) || (strcmp(argv[y],"beambottom") == 0) || (strcmp(argv[y],"beamBottom") == 0)) 01811 { 01812 typ = 1; 01813 } 01814 01815 if ((strcmp(argv[y],"column") == 0) || (strcmp(argv[y],"Column") == 0)) 01816 { 01817 typ = 2; 01818 } 01819 } 01820 else 01821 { 01822 opserr << "WARNING invalid location of bar specified\n"; 01823 opserr << "BarSlip: " << tag << endln; 01824 return TCL_ERROR; 01825 } 01826 if (argc == 17) { 01827 y ++; 01828 01829 if ((strcmp(argv[y],"damage1") == 0) || (strcmp(argv[y],"Damage1") == 0) || (strcmp(argv[y],"damage2") == 0) || (strcmp(argv[y],"Damage2") == 0) || 01830 (strcmp(argv[y],"nodamage") == 0) || (strcmp(argv[y],"Nodamage") == 0) || (strcmp(argv[y],"NoDamage") == 0) || (strcmp(argv[y],"noDamage") == 0)) 01831 { 01832 if ((strcmp(argv[y],"damage1") == 0) || (strcmp(argv[y],"Damage1") == 0)) 01833 { 01834 dmg = 1; 01835 } 01836 else if ((strcmp(argv[y],"damage2") == 0) || (strcmp(argv[y],"Damage2") == 0)) 01837 { 01838 dmg = 2; 01839 } 01840 else if ((strcmp(argv[y],"nodamage") == 0) || (strcmp(argv[y],"Nodamage") == 0) || (strcmp(argv[y],"NoDamage") == 0) || (strcmp(argv[y],"noDamage") == 0)) 01841 { 01842 dmg = 0; 01843 } 01844 01845 } 01846 else 01847 { 01848 opserr << "WARNING invalid damage specified\n"; 01849 opserr << "BarSlip: " << tag << endln; 01850 return TCL_ERROR; 01851 } 01852 01853 y ++; 01854 01855 if ((strcmp(argv[y],"mpa") == 0) || (strcmp(argv[y],"MPa") == 0) || (strcmp(argv[y],"mPa") == 0) || (strcmp(argv[y],"Mpa") == 0) || 01856 (strcmp(argv[y],"psi") == 0) || (strcmp(argv[y],"Psi") == 0) || (strcmp(argv[y],"PSI") == 0) || (strcmp(argv[y],"Pa") == 0) || 01857 (strcmp(argv[y],"pa") == 0) || (strcmp(argv[y],"psf") == 0) || (strcmp(argv[y],"Psf") == 0) || (strcmp(argv[y],"PSF") == 0) || 01858 (strcmp(argv[y],"ksi") == 0) || (strcmp(argv[y],"Ksi") == 0) || (strcmp(argv[y],"KSI") == 0) || (strcmp(argv[y],"ksf") == 0) || 01859 (strcmp(argv[y],"Ksf") == 0) || (strcmp(argv[y],"KSF") == 0)) 01860 { 01861 if ((strcmp(argv[y],"mpa") == 0) || (strcmp(argv[y],"MPa") == 0) || (strcmp(argv[y],"mPa") == 0) || (strcmp(argv[y],"Mpa") == 0)) 01862 { 01863 unt = 1; 01864 } 01865 else if ((strcmp(argv[y],"psi") == 0) || (strcmp(argv[y],"Psi") == 0) || (strcmp(argv[y],"PSI") == 0)) 01866 { 01867 unt = 2; 01868 } 01869 else if ((strcmp(argv[y],"Pa") == 0) || (strcmp(argv[y],"pa") == 0)) 01870 { 01871 unt = 3; 01872 } 01873 else if ((strcmp(argv[y],"psf") == 0) || (strcmp(argv[y],"Psf") == 0) || (strcmp(argv[y],"PSF") == 0)) 01874 { 01875 unt = 4; 01876 } 01877 else if ((strcmp(argv[y],"ksi") == 0) || (strcmp(argv[y],"Ksi") == 0) || (strcmp(argv[y],"KSI") == 0)) 01878 { 01879 unt = 5; 01880 } 01881 else if ((strcmp(argv[y],"ksf") == 0) || (strcmp(argv[y],"Ksf") == 0) || (strcmp(argv[y],"KSF") == 0)) 01882 { 01883 unt = 6; 01884 } 01885 } 01886 else 01887 { 01888 opserr << "WARNING invalid unit specified\n"; 01889 opserr << "BarSlip: " << tag << endln; 01890 return TCL_ERROR; 01891 } 01892 } 01893 01894 // allocate the material 01895 if (argc == 15 ) { 01896 theMaterial = new BarSlipMaterial (tag, fc, fy, Es, fu, Eh, db, ld, nb, width, depth, bsf, typ); 01897 } 01898 01899 if (argc == 17) { 01900 theMaterial = new BarSlipMaterial (tag, fc, fy, Es, fu, Eh, db, ld, nb, width, depth, bsf, typ, dmg, unt); 01901 } 01902 01903 } 01904 01905 else if ((strcmp(argv[1],"Bond_SP01") == 0) || (strcmp(argv[1],"Bond") == 0)) { //%strain penetration material 01906 // Check that there is the minimum number of arguments 01907 if (argc < 9) { 01908 opserr << "WARNING insufficient arguments\n"; 01909 printCommand(argc,argv); 01910 opserr << "Want: uniaxialMaterial Bond_SP01 tag? fy? sy? fu? su? b? R?"; 01911 opserr << " <Cd? db? fc? la?>" << endln; 01912 return TCL_ERROR; 01913 } 01914 01915 int tag; 01916 01917 if (Tcl_GetInt(interp, argv[2], &tag) != TCL_OK) { 01918 opserr << "WARNING invalid uniaxialMaterial Bond_SP01 tag" << endln; 01919 return TCL_ERROR; 01920 } 01921 01922 // Read required Bond_SP01 material parameters 01923 double fy, sy, fu, su, Kz, R; 01924 01925 if (Tcl_GetDouble(interp, argv[3], &fy) != TCL_OK) { 01926 opserr << "WARNING invalid bar yield strength (ksi): fy\n"; 01927 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01928 return TCL_ERROR; 01929 } 01930 01931 if (Tcl_GetDouble(interp, argv[4], &sy) != TCL_OK) { 01932 opserr << "WARNING invalid slip (in.) @ bar yield: sy\n"; 01933 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01934 return TCL_ERROR; 01935 } 01936 01937 if (Tcl_GetDouble(interp, argv[5], &fu) != TCL_OK) { 01938 opserr << "WARNING invalid bar failure strength (1.57fy? ksi) fu\n"; 01939 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01940 return TCL_ERROR; 01941 } 01942 01943 if (Tcl_GetDouble(interp, argv[6], &su) != TCL_OK) { 01944 opserr << "WARNING invalid slip (in.) @ bar failure: su\n"; 01945 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01946 return TCL_ERROR; 01947 } 01948 01949 if (Tcl_GetDouble(interp, argv[7], &Kz) != TCL_OK) { 01950 opserr << "WARNING invalid hardening ratio for envelop(<0.25<b(0.3)<0.5?): Cr\n"; 01951 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01952 return TCL_ERROR; 01953 } 01954 01955 if (Tcl_GetDouble(interp, argv[8], &R) != TCL_OK) { 01956 opserr << "WARNING invalid pinching factor (0.5<R<1.0?): R\n"; 01957 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01958 return TCL_ERROR; 01959 } 01960 01961 // Read optional Bond_SP01 material parameters (reserved for non-fully anchored cases 01962 double Cd, db, fc, la; 01963 01964 if (argc > 9) { 01965 if (argc < 13) { 01966 opserr << "WARNING insufficient number of Bond_SP01 parameters\n"; 01967 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01968 return TCL_ERROR; 01969 } 01970 01971 if (Tcl_GetDouble(interp, argv[9], &Cd) != TCL_OK) { 01972 opserr << "WARNING invalid bond damage factor (0<Cd<1?): Cd\n"; 01973 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01974 return TCL_ERROR; 01975 } 01976 01977 if (Tcl_GetDouble(interp, argv[10], &db) != TCL_OK) { 01978 opserr << "WARNING invalid bar diameter (in.): db\n"; 01979 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01980 return TCL_ERROR; 01981 } 01982 01983 if (Tcl_GetDouble(interp, argv[11], &fc) != TCL_OK) { 01984 opserr << "WARNING invalid concrete strength (ksi): fc\n"; 01985 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01986 return TCL_ERROR; 01987 } 01988 01989 if (Tcl_GetDouble(interp, argv[12], &la) != TCL_OK) { 01990 opserr << "WARNING invalid embedded length (in.): la\n"; 01991 opserr << "uniaxialMaterial Bond_SP01: " << tag << endln; 01992 return TCL_ERROR; 01993 } 01994 01995 // Parsing was successful, allocate the material 01996 theMaterial = new Bond_SP01 (tag, fy, sy, fu, su, Kz, R, Cd, db, fc, la); 01997 } 01998 else 01999 // Parsing was successful, allocate the material 02000 theMaterial = new Bond_SP01 (tag, fy, sy, fu, su, Kz, R); 02001 02002 } //%strain penetration material 02003 02004 02005 else { 02006 // Fedeas 02007 theMaterial = TclModelBuilder_addFedeasMaterial(clientData, interp, argc, argv, theTclBuilder); 02008 02009 // Drain 02010 if (theMaterial == 0) 02011 theMaterial = TclModelBuilder_addDrainMaterial(clientData, interp, argc, argv, theTclBuilder); 02012 02013 // SNAP 02014 if (theMaterial == 0) 02015 theMaterial = TclModelBuilder_addSnapMaterial(clientData, interp, argc, argv, theTclBuilder); 02016 02017 // Py, Tz, Qz models 02018 if (theMaterial == 0) 02019 theMaterial = TclModelBuilder_addPyTzQzMaterial(clientData, interp, argc, argv, theTclBuilder, theDomain); 02020 02021 #ifdef _LIMITSTATEMATERIAL 02022 // LimitState 02023 if (theMaterial == 0) 02024 theMaterial = Tcl_AddLimitStateMaterial(clientData, interp, argc, argv); 02025 #endif 02026 } 02027 02028 if (theMaterial == 0) { 02029 02030 // 02031 // maybe element in a package already loaded 02032 // loop through linked list of loaded functions comparing names & if find call it 02033 // 02034 02035 UniaxialPackageCommand *matCommands = theUniaxialPackageCommands; 02036 bool found = false; 02037 while (matCommands != NULL && found == false) { 02038 if (strcmp(argv[1], matCommands->funcName) == 0) { 02039 02040 int result = (*(matCommands->funcPtr))(clientData, interp, argc, argv, theTclBuilder); 02041 return result; 02042 } else 02043 matCommands = matCommands->next; 02044 } 02045 02046 02047 // 02048 // maybe element command exists in a dll in library path 02049 // so try loading package of same name as material name containg 02050 // a c function "TclCommand_MatName" 02051 // 02052 02053 void *libHandle; 02054 int (*funcPtr)(ClientData clientData, Tcl_Interp *interp, int argc, 02055 TCL_Char **argv, TclModelBuilder *); 02056 int matNameLength = strlen(argv[1]); 02057 char *tclFuncName = new char[matNameLength+12]; 02058 strcpy(tclFuncName, "TclCommand_"); 02059 strcpy(&tclFuncName[11], argv[1]); 02060 int res = getLibraryFunction(argv[1], tclFuncName, &libHandle, (void **)&funcPtr); 02061 02062 delete [] tclFuncName; 02063 02064 if (res == 0) { 02065 02066 // 02067 // add loaded function to list of functions 02068 // 02069 char *matName = new char[matNameLength+1]; 02070 strcpy(matName, argv[1]); 02071 UniaxialPackageCommand *theMatCommand = new UniaxialPackageCommand; 02072 theMatCommand->funcPtr = funcPtr; 02073 theMatCommand->funcName = matName; 02074 theMatCommand->next = theUniaxialPackageCommands; 02075 theUniaxialPackageCommands = theMatCommand; 02076 02077 int result = (*funcPtr)(clientData, interp, 02078 argc, argv, 02079 theTclBuilder); 02080 02081 return result; 02082 } 02083 } 02084 02085 // 02086 // if still here the element command does not exist 02087 // 02088 02089 if (theMaterial == 0) { 02090 opserr << "WARNING could not create uniaxialMaterial " << argv[1] << endln; 02091 return TCL_ERROR; 02092 } 02093 02094 // Now add the material to the modelBuilder 02095 if (theTclBuilder->addUniaxialMaterial(*theMaterial) < 0) { 02096 opserr << "WARNING could not add uniaxialMaterial to the domain\n"; 02097 opserr << *theMaterial << endln; 02098 delete theMaterial; // invoke the material objects destructor, otherwise mem leak 02099 return TCL_ERROR; 02100 } 02101 02102 return TCL_OK; 02103 }
Generated on Mon Oct 23 15:05:22 2006 for OpenSees by |
opensees-support @ berkeley.edu
Supported by the National Science Foundation
©2006, UC Regents