TclLimitState.cpp

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

Generated on Mon Oct 23 15:05:20 2006 for OpenSees by doxygen 1.5.0