TclFourNodeQuadUPCommand.cpp

Go to the documentation of this file.
00001 //
00002 
00003 // Description: This file contains the implementation of
00004 
00005 // TclModelBuilder_addFourNodeQuadUP() ,
00006 
00007 // TclModelBuilder_addBrickUP() ,
00008 
00009 // TclModelBuilder_addNineFourNodeQuadUP() , and
00010 
00011 // TclModelBuilder_addTwentyEightNodeBrickUP()
00012 
00013 //
00014 
00015 // Zhaohui Yang and Jinchi Lu (May 2004)
00016 
00017 
00018 
00019 #include <stdlib.h>
00020 
00021 #include <string.h>
00022 
00023 #include <Domain.h>
00024 
00025 
00026 
00027 #include <FourNodeQuadUP.h>
00028 
00029 #include <BrickUP.h>
00030 
00031 #include <Nine_Four_Node_QuadUP.h>
00032 
00033 #include <Twenty_Eight_Node_BrickUP.h>
00034 
00035 
00036 
00037 #include <TclModelBuilder.h>
00038 
00039 
00040 
00041 //#ifdef _DEBUG
00042 
00043 //#define TCL_Char const char
00044 
00045 //#endif
00046 
00047 
00048 
00049 extern void printCommand(int argc, TCL_Char **argv);
00050 
00051 
00052 
00053 /*  *****************************************************************************
00054 
00055 
00056 
00057     Q U A D  U_P
00058 
00059 
00060 
00061     ***************************************************************************** */
00062 
00063 
00064 
00065 int
00066 
00067 TclModelBuilder_addFourNodeQuadUP(ClientData clientData, Tcl_Interp *interp,
00068 
00069                                 int argc,
00070 
00071                                 TCL_Char **argv,
00072 
00073                                 Domain*theTclDomain,
00074 
00075                                 TclModelBuilder *theTclBuilder)
00076 
00077 {
00078 
00079   // ensure the destructor has not been called -
00080 
00081   if (theTclBuilder == 0) {
00082 
00083     opserr << "WARNING builder has been destroyed\n";
00084 
00085     return TCL_ERROR;
00086 
00087   }
00088 
00089 
00090 
00091         if (theTclBuilder->getNDM() != 2 || theTclBuilder->getNDF() != 3) {
00092 
00093                 opserr << "WARNING -- model dimensions and/or nodal DOF not compatible with QuadUP element\n";
00094 
00095                 return TCL_ERROR;
00096 
00097         }
00098 
00099 
00100 
00101   // check the number of arguments is correct
00102 
00103   int argStart = 2;
00104 
00105 
00106 
00107   if ((argc-argStart) < 11) {
00108 
00109     opserr << "WARNING insufficient arguments\n";
00110 
00111     printCommand(argc, argv);
00112 
00113     opserr << "Want: element FourNodeQuadUP eleTag? iNode? jNode? kNode? lNode? thk? type? matTag? bulk? rho? perm_x? perm_y? <b1? b2? pressure? dM? dK?>\n";
00114 
00115     return TCL_ERROR;
00116 
00117   }
00118 
00119 
00120 
00121   // get the id and end nodes
00122 
00123   int FourNodeQuadUPId, iNode, jNode, kNode, lNode, matID;
00124 
00125   double thickness, bk, r, perm1, perm2;
00126 
00127         double p = 0.0;         // uniform normal traction (pressure)
00128 
00129         double b1 = 0.0;
00130 
00131         double b2 = 0.0;
00132 
00133 
00134 
00135   TCL_Char *type;
00136 
00137   if (Tcl_GetInt(interp, argv[argStart], &FourNodeQuadUPId) != TCL_OK) {
00138 
00139     opserr << "WARNING invalid FourNodeQuadUP eleTag" << endln;
00140 
00141     return TCL_ERROR;
00142 
00143   }
00144 
00145   if (Tcl_GetInt(interp, argv[1+argStart], &iNode) != TCL_OK) {
00146 
00147     opserr << "WARNING invalid iNode\n";
00148 
00149     opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00150 
00151     return TCL_ERROR;
00152 
00153   }
00154 
00155 
00156 
00157   if (Tcl_GetInt(interp, argv[2+argStart], &jNode) != TCL_OK) {
00158 
00159      opserr << "WARNING invalid jNode\n";
00160 
00161      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00162 
00163      return TCL_ERROR;
00164 
00165   }
00166 
00167 
00168 
00169   if (Tcl_GetInt(interp, argv[3+argStart], &kNode) != TCL_OK) {
00170 
00171      opserr << "WARNING invalid kNode\n";
00172 
00173      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00174 
00175      return TCL_ERROR;
00176 
00177   }
00178 
00179 
00180 
00181   if (Tcl_GetInt(interp, argv[4+argStart], &lNode) != TCL_OK) {
00182 
00183      opserr << "WARNING invalid lNode\n";
00184 
00185      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00186 
00187      return TCL_ERROR;
00188 
00189   }
00190 
00191 
00192 
00193   if (Tcl_GetDouble(interp, argv[5+argStart], &thickness) != TCL_OK) {
00194 
00195      opserr << "WARNING invalid thickness\n";
00196 
00197      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00198 
00199      return TCL_ERROR;
00200 
00201   }
00202 
00203 
00204 
00205   if (Tcl_GetInt(interp, argv[6+argStart], &matID) != TCL_OK) {
00206 
00207      opserr << "WARNING invalid matID\n";
00208 
00209      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00210 
00211      return TCL_ERROR;
00212 
00213   }
00214 
00215 
00216 
00217         if (Tcl_GetDouble(interp, argv[7+argStart], &bk) != TCL_OK) {
00218 
00219      opserr << "WARNING invalid fluid bulk modulus\n";
00220 
00221      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00222 
00223      return TCL_ERROR;
00224 
00225   }
00226 
00227 
00228 
00229   if (Tcl_GetDouble(interp, argv[8+argStart], &r) != TCL_OK) {
00230 
00231      opserr << "WARNING invalid fluid mass density\n";
00232 
00233      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00234 
00235      return TCL_ERROR;
00236 
00237   }
00238 
00239 
00240 
00241   if (Tcl_GetDouble(interp, argv[9+argStart], &perm1) != TCL_OK) {
00242 
00243      opserr << "WARNING invalid lateral permeability\n";
00244 
00245      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00246 
00247      return TCL_ERROR;
00248 
00249   }
00250 
00251 
00252 
00253   if (Tcl_GetDouble(interp, argv[10+argStart], &perm2) != TCL_OK) {
00254 
00255      opserr << "WARNING invalid vertical permeability\n";
00256 
00257      opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00258 
00259      return TCL_ERROR;
00260 
00261   }
00262 
00263 
00264 
00265         if ((argc-argStart) >= 12) {
00266 
00267                 if (Tcl_GetDouble(interp, argv[11+argStart], &b1) != TCL_OK) {
00268 
00269                         opserr << "WARNING invalid b1\n";
00270 
00271                         opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00272 
00273                         return TCL_ERROR;
00274 
00275                 }
00276 
00277         }
00278 
00279         if ((argc-argStart) >= 13) {
00280 
00281                 if (Tcl_GetDouble(interp, argv[12+argStart], &b2) != TCL_OK) {
00282 
00283                         opserr << "WARNING invalid b2\n";
00284 
00285                         opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00286 
00287                         return TCL_ERROR;
00288 
00289                 }
00290 
00291         }
00292 
00293         if ((argc-argStart) >= 14) {
00294 
00295                 if (Tcl_GetDouble(interp, argv[13+argStart], &p) != TCL_OK) {
00296 
00297                         opserr << "WARNING invalid pressure\n";
00298 
00299                         opserr << "FourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00300 
00301                         return TCL_ERROR;
00302 
00303                 }
00304 
00305         }
00306 
00307 
00308 
00309   NDMaterial *theMaterial = theTclBuilder->getNDMaterial(matID);
00310 
00311 
00312 
00313   if (theMaterial == 0) {
00314 
00315       opserr << "WARNING material not found\n";
00316 
00317       opserr << "Material: " << matID;
00318 
00319       opserr << "\nFourNodeQuadUP element: " << FourNodeQuadUPId << endln;
00320 
00321       return TCL_ERROR;
00322 
00323   }
00324 
00325 
00326 
00327   // now create the FourNodeQuadUP and add it to the Domain
00328 
00329   FourNodeQuadUP *theFourNodeQuadUP =
00330 
00331       new FourNodeQuadUP(FourNodeQuadUPId,iNode,jNode,kNode,lNode,
00332 
00333                        *theMaterial, "PlaneStrain", thickness, bk, r, perm1, perm2, b1, b2, p);
00334 
00335   if (theFourNodeQuadUP == 0) {
00336 
00337       opserr << "WARNING ran out of memory creating element\n";
00338 
00339       opserr << "FourNodeQuad element: " << FourNodeQuadUPId << endln;
00340 
00341       return TCL_ERROR;
00342 
00343   }
00344 
00345 
00346 
00347   if (theTclDomain->addElement(theFourNodeQuadUP) == false) {
00348 
00349       opserr << "WARNING could not add element to the domain\n";
00350 
00351       opserr << "FourNodeQuad element: " << FourNodeQuadUPId << endln;
00352 
00353       delete theFourNodeQuadUP;
00354 
00355       return TCL_ERROR;
00356 
00357   }
00358 
00359 
00360 
00361   // if get here we have sucessfully created the element and added it to the domain
00362 
00363   return TCL_OK;
00364 
00365 }
00366 
00367 
00368 
00369 
00370 
00371 /*  *****************************************************************************
00372 
00373 
00374 
00375     BRICK  U_P
00376 
00377 
00378 
00379     ***************************************************************************** */
00380 
00381 
00382 
00383 int
00384 
00385 TclModelBuilder_addBrickUP(ClientData clientData, Tcl_Interp *interp,
00386 
00387                                 int argc,
00388 
00389                                 TCL_Char **argv,
00390 
00391                                 Domain*theTclDomain,
00392 
00393                                 TclModelBuilder *theTclBuilder)
00394 
00395 {
00396 
00397   // ensure the destructor has not been called -
00398 
00399   if (theTclBuilder == 0) {
00400 
00401     opserr << "WARNING builder has been destroyed\n";
00402 
00403     return TCL_ERROR;
00404 
00405   }
00406 
00407 
00408 
00409         if (theTclBuilder->getNDM() != 3 || theTclBuilder->getNDF() != 4) {
00410 
00411                 opserr << "WARNING -- model dimensions and/or nodal DOF not compatible with QuadUP element\n";
00412 
00413                 return TCL_ERROR;
00414 
00415         }
00416 
00417 
00418 
00419   // check the number of arguments is correct
00420 
00421   int argStart = 2;
00422 
00423 
00424 
00425   if ((argc-argStart) < 15) {
00426 
00427     opserr << "WARNING insufficient arguments\n";
00428 
00429     printCommand(argc, argv);
00430 
00431     opserr << "Want: element brickUP eleTag? N1? N2? N3? N4? N5? N6? N7? N8? matTag? bulk? rhof? perm_x? perm_y? perm_z? <b1? b2? b3?>\n";
00432 
00433     return TCL_ERROR;
00434 
00435   }
00436 
00437 
00438 
00439   // get the id and end nodes
00440 
00441   int brickUPId, Nod[8], matID;
00442 
00443   double bk, r, perm1, perm2, perm3;
00444 
00445         double b1 = 0.0;
00446 
00447         double b2 = 0.0;
00448 
00449         double b3 = 0.0;
00450 
00451 
00452 
00453   if (Tcl_GetInt(interp, argv[argStart], &brickUPId) != TCL_OK) {
00454 
00455     opserr << "WARNING invalid brickUP eleTag" << endln;
00456 
00457     return TCL_ERROR;
00458 
00459   }
00460 
00461 
00462 
00463   for (int i=0; i<8; i++)
00464 
00465     if (Tcl_GetInt(interp, argv[1+argStart+i], &(Nod[i])) != TCL_OK) {
00466 
00467       opserr << "WARNING invalid Node number\n";
00468 
00469       opserr << "brickUP element: " << brickUPId << endln;
00470 
00471       return TCL_ERROR;
00472 
00473         }
00474 
00475 
00476 
00477   if (Tcl_GetInt(interp, argv[9+argStart], &matID) != TCL_OK) {
00478 
00479      opserr << "WARNING invalid matID\n";
00480 
00481      opserr << "brickUP element: " << brickUPId << endln;
00482 
00483      return TCL_ERROR;
00484 
00485   }
00486 
00487 
00488 
00489         if (Tcl_GetDouble(interp, argv[10+argStart], &bk) != TCL_OK) {
00490 
00491      opserr << "WARNING invalid fluid bulk modulus\n";
00492 
00493      opserr << "brickUP element: " << brickUPId << endln;
00494 
00495      return TCL_ERROR;
00496 
00497   }
00498 
00499 
00500 
00501   if (Tcl_GetDouble(interp, argv[11+argStart], &r) != TCL_OK) {
00502 
00503      opserr << "WARNING invalid fluid mass density\n";
00504 
00505      opserr << "brickUP element: " << brickUPId << endln;
00506 
00507      return TCL_ERROR;
00508 
00509   }
00510 
00511 
00512 
00513   if (Tcl_GetDouble(interp, argv[12+argStart], &perm1) != TCL_OK) {
00514 
00515      opserr << "WARNING invalid permeability_x\n";
00516 
00517      opserr << "brickUP element: " << brickUPId << endln;
00518 
00519      return TCL_ERROR;
00520 
00521   }
00522 
00523 
00524 
00525   if (Tcl_GetDouble(interp, argv[13+argStart], &perm2) != TCL_OK) {
00526 
00527      opserr << "WARNING invalid permeability_y\n";
00528 
00529      opserr << "brickUP element: " << brickUPId << endln;
00530 
00531      return TCL_ERROR;
00532 
00533   }
00534 
00535 
00536 
00537   if (Tcl_GetDouble(interp, argv[14+argStart], &perm3) != TCL_OK) {
00538 
00539      opserr << "WARNING invalid permeability_z\n";
00540 
00541      opserr << "brickUP element: " << brickUPId << endln;
00542 
00543      return TCL_ERROR;
00544 
00545   }
00546 
00547 
00548 
00549         if ((argc-argStart) >= 16) {
00550 
00551                 if (Tcl_GetDouble(interp, argv[15+argStart], &b1) != TCL_OK) {
00552 
00553                         opserr << "WARNING invalid b1\n";
00554 
00555                         opserr << "brickUP element: " << brickUPId << endln;
00556 
00557                         return TCL_ERROR;
00558 
00559                 }
00560 
00561         }
00562 
00563         if ((argc-argStart) >= 17) {
00564 
00565                 if (Tcl_GetDouble(interp, argv[16+argStart], &b2) != TCL_OK) {
00566 
00567                         opserr << "WARNING invalid b2\n";
00568 
00569                         opserr << "brickUP element: " << brickUPId << endln;
00570 
00571                         return TCL_ERROR;
00572 
00573                 }
00574 
00575         }
00576 
00577         if ((argc-argStart) >= 18) {
00578 
00579                 if (Tcl_GetDouble(interp, argv[17+argStart], &b3) != TCL_OK) {
00580 
00581                         opserr << "WARNING invalid b3\n";
00582 
00583                         opserr << "brickUP element: " << brickUPId << endln;
00584 
00585                         return TCL_ERROR;
00586 
00587                 }
00588 
00589         }
00590 
00591 
00592 
00593   NDMaterial *theMaterial = theTclBuilder->getNDMaterial(matID);
00594 
00595 
00596 
00597   if (theMaterial == 0) {
00598 
00599       opserr << "WARNING material not found\n";
00600 
00601       opserr << "Material: " << matID;
00602 
00603       opserr << "\nbrickUP element: " << brickUPId << endln;
00604 
00605       return TCL_ERROR;
00606 
00607   }
00608 
00609 
00610 
00611   // now create the brickUP and add it to the Domain
00612 
00613   BrickUP *theBrickUP =
00614 
00615       new BrickUP(brickUPId,Nod[0],Nod[1],Nod[2],Nod[3],Nod[4],Nod[5],Nod[6],Nod[7],
00616 
00617                        *theMaterial, bk, r, perm1, perm2, perm3, b1, b2, b3);
00618 
00619   if (theBrickUP == 0) {
00620 
00621       opserr << "WARNING ran out of memory creating element\n";
00622 
00623       opserr << "brickUP element: " << brickUPId << endln;
00624 
00625       return TCL_ERROR;
00626 
00627   }
00628 
00629 
00630 
00631   if (theTclDomain->addElement(theBrickUP) == false) {
00632 
00633       opserr << "WARNING could not add element to the domain\n";
00634 
00635       opserr << "brickUP element: " << brickUPId << endln;
00636 
00637       delete theBrickUP;
00638 
00639       return TCL_ERROR;
00640 
00641   }
00642 
00643 
00644 
00645   // if get here we have sucessfully created the element and added it to the domain
00646 
00647   return TCL_OK;
00648 
00649 }
00650 
00651 
00652 
00653 /*  *****************************************************************************
00654 
00655 
00656 
00657     9-4-N O D E  Q U A D  U_P
00658 
00659 
00660 
00661     ***************************************************************************** */
00662 
00663 
00664 
00665 int
00666 
00667 TclModelBuilder_addNineFourNodeQuadUP(ClientData clientData, Tcl_Interp *interp,
00668 
00669                                 int argc,
00670 
00671                                 TCL_Char **argv,
00672 
00673                                 Domain*theTclDomain,
00674 
00675                                 TclModelBuilder *theTclBuilder)
00676 
00677 {
00678 
00679   // ensure the destructor has not been called -
00680 
00681   if (theTclBuilder == 0) {
00682 
00683     opserr << "WARNING builder has been destroyed\n";
00684 
00685     return TCL_ERROR;
00686 
00687   }
00688 
00689 
00690 
00691         if (theTclBuilder->getNDM() != 2) {
00692 
00693                 opserr << "WARNING -- model dimensions not compatible with 9-4-NodeQuadUP element\n";
00694 
00695                 return TCL_ERROR;
00696 
00697         }
00698 
00699 
00700 
00701   // check the number of arguments is correct
00702 
00703   int argStart = 2;
00704 
00705 
00706 
00707   if ((argc-argStart) < 16) {
00708 
00709     opserr << "WARNING insufficient arguments\n";
00710 
00711     printCommand(argc, argv);
00712 
00713     opserr << "Want: element FourNodeQuadUP eleTag? Node1? ... Node9? thk? type? matTag? bulk? rho? perm_x? perm_y? <b1? b2? pressure? dM? dK?>\n";
00714 
00715     return TCL_ERROR;
00716 
00717   }
00718 
00719 
00720 
00721   // get the id and end nodes
00722 
00723   int NineFourNodeQuadUPId, Node[9], matID;
00724 
00725   double thickness, bk, r, perm1, perm2;
00726 
00727         double b1 = 0.0;
00728 
00729         double b2 = 0.0;
00730 
00731 
00732 
00733   if (Tcl_GetInt(interp, argv[argStart], &NineFourNodeQuadUPId) != TCL_OK) {
00734 
00735     opserr << "WARNING invalid FourNodeQuadUP eleTag" << endln;
00736 
00737     return TCL_ERROR;
00738 
00739   }
00740 
00741   for (int i=1; i<=9; i++) {
00742 
00743      if (Tcl_GetInt(interp, argv[i+argStart], &Node[i-1]) != TCL_OK) {
00744 
00745        opserr << "WARNING invalid Node\n";
00746 
00747        opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00748 
00749        return TCL_ERROR;
00750 
00751          }
00752 
00753   }
00754 
00755 
00756 
00757   if (Tcl_GetDouble(interp, argv[10+argStart], &thickness) != TCL_OK) {
00758 
00759      opserr << "WARNING invalid thickness\n";
00760 
00761      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00762 
00763      return TCL_ERROR;
00764 
00765   }
00766 
00767 
00768 
00769   if (Tcl_GetInt(interp, argv[11+argStart], &matID) != TCL_OK) {
00770 
00771      opserr << "WARNING invalid matID\n";
00772 
00773      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00774 
00775      return TCL_ERROR;
00776 
00777   }
00778 
00779 
00780 
00781         if (Tcl_GetDouble(interp, argv[12+argStart], &bk) != TCL_OK) {
00782 
00783      opserr << "WARNING invalid fluid bulk modulus\n";
00784 
00785      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00786 
00787      return TCL_ERROR;
00788 
00789   }
00790 
00791 
00792 
00793   if (Tcl_GetDouble(interp, argv[13+argStart], &r) != TCL_OK) {
00794 
00795      opserr << "WARNING invalid fluid mass density\n";
00796 
00797      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00798 
00799      return TCL_ERROR;
00800 
00801   }
00802 
00803 
00804 
00805   if (Tcl_GetDouble(interp, argv[14+argStart], &perm1) != TCL_OK) {
00806 
00807      opserr << "WARNING invalid lateral permeability\n";
00808 
00809      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00810 
00811      return TCL_ERROR;
00812 
00813   }
00814 
00815 
00816 
00817   if (Tcl_GetDouble(interp, argv[15+argStart], &perm2) != TCL_OK) {
00818 
00819      opserr << "WARNING invalid vertical permeability\n";
00820 
00821      opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00822 
00823      return TCL_ERROR;
00824 
00825   }
00826 
00827 
00828 
00829         if ((argc-argStart) >= 17) {
00830 
00831                 if (Tcl_GetDouble(interp, argv[16+argStart], &b1) != TCL_OK) {
00832 
00833                         opserr << "WARNING invalid b1\n";
00834 
00835                         opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00836 
00837                         return TCL_ERROR;
00838 
00839                 }
00840 
00841         }
00842 
00843         if ((argc-argStart) >= 18) {
00844 
00845                 if (Tcl_GetDouble(interp, argv[17+argStart], &b2) != TCL_OK) {
00846 
00847                         opserr << "WARNING invalid b2\n";
00848 
00849                         opserr << "FourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00850 
00851                         return TCL_ERROR;
00852 
00853                 }
00854 
00855         }
00856 
00857 
00858 
00859   NDMaterial *theMaterial = theTclBuilder->getNDMaterial(matID);
00860 
00861 
00862 
00863   if (theMaterial == 0) {
00864 
00865       opserr << "WARNING material not found\n";
00866 
00867       opserr << "Material: " << matID;
00868 
00869       opserr << "\nFourNodeQuadUP element: " << NineFourNodeQuadUPId << endln;
00870 
00871       return TCL_ERROR;
00872 
00873   }
00874 
00875 
00876 
00877   // now create the FourNodeQuadUP and add it to the Domain
00878 
00879   NineFourNodeQuadUP *theNineFourNodeQuadUP =
00880 
00881       new NineFourNodeQuadUP(NineFourNodeQuadUPId,Node[0],Node[1],Node[2],
00882 
00883                                  Node[3],Node[4],Node[5],Node[6],Node[7],Node[8],
00884 
00885                                      *theMaterial, "PlaneStrain", thickness, bk, r, perm1, perm2, b1, b2);
00886 
00887   if (theNineFourNodeQuadUP == 0) {
00888 
00889       opserr << "WARNING ran out of memory creating element\n";
00890 
00891       opserr << "FourNodeQuad element: " << NineFourNodeQuadUPId << endln;
00892 
00893       return TCL_ERROR;
00894 
00895   }
00896 
00897 
00898 
00899   if (theTclDomain->addElement(theNineFourNodeQuadUP) == false) {
00900 
00901       opserr << "WARNING could not add element to the domain\n";
00902 
00903       opserr << "FourNodeQuad element: " << NineFourNodeQuadUPId << endln;
00904 
00905       delete theNineFourNodeQuadUP;
00906 
00907       return TCL_ERROR;
00908 
00909   }
00910 
00911 
00912 
00913   // if get here we have sucessfully created the element and added it to the domain
00914 
00915   return TCL_OK;
00916 
00917 }
00918 
00919 
00920 
00921 /*  *****************************************************************************
00922 
00923 
00924 
00925     20-8 NODED BRICK  U_P
00926 
00927 
00928 
00929     ***************************************************************************** */
00930 
00931 
00932 
00933 int
00934 
00935 TclModelBuilder_addTwentyEightNodeBrickUP(ClientData clientData, Tcl_Interp *interp,
00936 
00937                                 int argc,
00938 
00939                                 TCL_Char **argv,
00940 
00941                                 Domain*theTclDomain,
00942 
00943                                 TclModelBuilder *theTclBuilder)
00944 
00945 {
00946 
00947   // ensure the destructor has not been called -
00948 
00949   if (theTclBuilder == 0) {
00950 
00951     opserr << "WARNING builder has been destroyed\n";
00952 
00953     return TCL_ERROR;
00954 
00955   }
00956 
00957 
00958 
00959         if (theTclBuilder->getNDM() != 3 ) {
00960 
00961                 opserr << "WARNING -- model dimensions and/or nodal DOF not compatible with 20_8_BrickUP element\n";
00962 
00963                 return TCL_ERROR;
00964 
00965         }
00966 
00967 
00968 
00969   // check the number of arguments is correct
00970 
00971   int argStart = 2;
00972 
00973 
00974 
00975   if ((argc-argStart) < 27) {
00976 
00977     opserr << "WARNING insufficient arguments\n";
00978 
00979     printCommand(argc, argv);
00980 
00981     opserr << "Want: element 20_8_BrickUP eleTag? N1? N2? N3? N4? N5? N6? N7? N8? N9? N10? N11? N12? N13? N14? N15? N16? N17? N18? N19? N20? matTag? bulk? rhof? perm_x? perm_y? perm_z? <b1? b2? b3?>\n";
00982 
00983     return TCL_ERROR;
00984 
00985   }
00986 
00987 
00988 
00989   // get the id and end nodes
00990 
00991   int brickUPId, Nod[20], matID;
00992 
00993   double bk, r, perm1, perm2, perm3;
00994 
00995         double b1 = 0.0;
00996 
00997         double b2 = 0.0;
00998 
00999         double b3 = 0.0;
01000 
01001 
01002 
01003   if (Tcl_GetInt(interp, argv[argStart], &brickUPId) != TCL_OK) {
01004 
01005     opserr << "WARNING invalid 20_8_BrickUP eleTag" << endln;
01006 
01007     return TCL_ERROR;
01008 
01009   }
01010 
01011 
01012 
01013   for (int i=0; i<20; i++)
01014 
01015     if (Tcl_GetInt(interp, argv[1+argStart+i], &(Nod[i])) != TCL_OK) {
01016 
01017       opserr << "WARNING invalid Node number\n";
01018 
01019       opserr << "20_8_BrickUP element: " << brickUPId << endln;
01020 
01021       return TCL_ERROR;
01022 
01023         }
01024 
01025 
01026 
01027   if (Tcl_GetInt(interp, argv[21+argStart], &matID) != TCL_OK) {
01028 
01029      opserr << "WARNING invalid matID\n";
01030 
01031      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01032 
01033      return TCL_ERROR;
01034 
01035   }
01036 
01037 
01038 
01039         if (Tcl_GetDouble(interp, argv[22+argStart], &bk) != TCL_OK) {
01040 
01041      opserr << "WARNING invalid fluid bulk modulus\n";
01042 
01043      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01044 
01045      return TCL_ERROR;
01046 
01047   }
01048 
01049 
01050 
01051   if (Tcl_GetDouble(interp, argv[23+argStart], &r) != TCL_OK) {
01052 
01053      opserr << "WARNING invalid fluid mass density\n";
01054 
01055      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01056 
01057      return TCL_ERROR;
01058 
01059   }
01060 
01061 
01062 
01063   if (Tcl_GetDouble(interp, argv[24+argStart], &perm1) != TCL_OK) {
01064 
01065      opserr << "WARNING invalid permeability_x\n";
01066 
01067      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01068 
01069      return TCL_ERROR;
01070 
01071   }
01072 
01073 
01074 
01075   if (Tcl_GetDouble(interp, argv[25+argStart], &perm2) != TCL_OK) {
01076 
01077      opserr << "WARNING invalid permeability_y\n";
01078 
01079      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01080 
01081      return TCL_ERROR;
01082 
01083   }
01084 
01085 
01086 
01087   if (Tcl_GetDouble(interp, argv[26+argStart], &perm3) != TCL_OK) {
01088 
01089      opserr << "WARNING invalid permeability_z\n";
01090 
01091      opserr << "20_8_BrickUP element: " << brickUPId << endln;
01092 
01093      return TCL_ERROR;
01094 
01095   }
01096 
01097 
01098 
01099         if ((argc-argStart) >= 28) {
01100 
01101                 if (Tcl_GetDouble(interp, argv[27+argStart], &b1) != TCL_OK) {
01102 
01103                         opserr << "WARNING invalid b1\n";
01104 
01105                         opserr << "20_8_BrickUP element: " << brickUPId << endln;
01106 
01107                         return TCL_ERROR;
01108 
01109                 }
01110 
01111         }
01112 
01113         if ((argc-argStart) >= 29) {
01114 
01115                 if (Tcl_GetDouble(interp, argv[28+argStart], &b2) != TCL_OK) {
01116 
01117                         opserr << "WARNING invalid b2\n";
01118 
01119                         opserr << "20_8_BrickUP element: " << brickUPId << endln;
01120 
01121                         return TCL_ERROR;
01122 
01123                 }
01124 
01125         }
01126 
01127         if ((argc-argStart) >= 30) {
01128 
01129                 if (Tcl_GetDouble(interp, argv[29+argStart], &b3) != TCL_OK) {
01130 
01131                         opserr << "WARNING invalid b3\n";
01132 
01133                         opserr << "20_8_BrickUP element: " << brickUPId << endln;
01134 
01135                         return TCL_ERROR;
01136 
01137                 }
01138 
01139         }
01140 
01141 
01142 
01143   NDMaterial *theMaterial = theTclBuilder->getNDMaterial(matID);
01144 
01145 
01146 
01147   if (theMaterial == 0) {
01148 
01149       opserr << "WARNING material not found\n";
01150 
01151       opserr << "Material: " << matID;
01152 
01153       opserr << "\n20_8_BrickUP element: " << brickUPId << endln;
01154 
01155       return TCL_ERROR;
01156 
01157   }
01158 
01159 
01160 
01161   // now create the brickUP and add it to the Domain
01162 
01163   TwentyEightNodeBrickUP *theTwentyEightNodeBrickUP =
01164 
01165       new TwentyEightNodeBrickUP(brickUPId,Nod[0],Nod[1],Nod[2],Nod[3],Nod[4],Nod[5],Nod[6],Nod[7],
01166 
01167                                 Nod[8],Nod[9],Nod[10],Nod[11],Nod[12],Nod[13],Nod[14],
01168 
01169                                 Nod[15],Nod[16],Nod[17],Nod[18],Nod[19],
01170 
01171                        *theMaterial, bk, r, perm1, perm2, perm3, b1, b2, b3);
01172 
01173   if (theTwentyEightNodeBrickUP == 0) {
01174 
01175       opserr << "WARNING ran out of memory creating element\n";
01176 
01177       opserr << "20_8_BrickUP element: " << brickUPId << endln;
01178 
01179       return TCL_ERROR;
01180 
01181   }
01182 
01183 
01184 
01185   if (theTclDomain->addElement(theTwentyEightNodeBrickUP) == false) {
01186 
01187       opserr << "WARNING could not add element to the domain\n";
01188 
01189       opserr << "20_8_BrickUP element: " << brickUPId << endln;
01190 
01191       delete theTwentyEightNodeBrickUP;
01192 
01193       return TCL_ERROR;
01194 
01195   }
01196 
01197 
01198 
01199   // if get here we have sucessfully created the element and added it to the domain
01200 
01201   return TCL_OK;
01202 
01203 }
01204 
01205 
01206 

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