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

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