Joint3D.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.3 $
00022 // $Date: 2006/08/04 22:22:37 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/element/joint/Joint3D.cpp,v $
00024 
00025 // Written: Arash Altoontash, Gregory Deierlein
00026 // Created: 03/02
00027 // Revision: Arash
00028 
00029 // Joint3D.cpp: implementation of the Joint3D class.
00030 //
00032 
00033 #include <stdio.h>
00034 #include <Channel.h>
00035 #include <FEM_ObjectBroker.h>
00036 #include <Renderer.h>
00037 #include <Information.h>
00038 #include <math.h>
00039 #include <stdlib.h>
00040 #include <string.h>
00041 #include <MP_Constraint.h>
00042 #include <MP_Joint3D.h>
00043 #include <ElementResponse.h>
00044 #include <UniaxialMaterial.h>
00045 #include <Joint3D.h>
00046 
00047 
00048 Matrix Joint3D::K(45,45);
00049 Vector Joint3D::V(45);
00050 
00052 // Construction/Destruction
00054 
00055 
00056 Joint3D::Joint3D()
00057   :Element(0, ELE_TAG_Joint3D ), 
00058   ExternalNodes(7), InternalConstraints(6), 
00059   TheDomain(0), numDof(0), nodeDbTag(0), dofDbTag(0)
00060 {
00061   for (int i=0 ; i<7 ; i++ )
00062     theNodes[i] = NULL;
00063   
00064   for (int j=0 ; j<3 ; j++ )
00065     theSprings[j] = NULL;
00066 }
00067 
00068 
00069 
00070 Joint3D::Joint3D(int tag, int nd1, int nd2, int nd3, int nd4, int nd5, int nd6, int IntNodeTag,
00071           UniaxialMaterial &springx, UniaxialMaterial &springy, UniaxialMaterial &springz,
00072           Domain *theDomain, int LrgDisp)
00073 :Element(tag, ELE_TAG_Joint3D ), ExternalNodes(7), InternalConstraints(6), 
00074 TheDomain(0), numDof(0), nodeDbTag(0), dofDbTag(0)
00075 {
00076   int i;
00077   numDof  = 45;
00078 
00079   K.Zero();
00080   V.Zero();
00081 
00082   TheDomain = theDomain;
00083   if( TheDomain==NULL ) {
00084     opserr << "WARNING Joint3D(): Specified domain does not exist , Domain = 0\n";
00085     return;
00086   }
00087 
00088   // Save external node id's
00089   ExternalNodes(0) = nd1;
00090   ExternalNodes(1) = nd2;
00091   ExternalNodes(2) = nd3;
00092   ExternalNodes(3) = nd4;
00093   ExternalNodes(4) = nd5;
00094   ExternalNodes(5) = nd6;
00095   ExternalNodes(6) = IntNodeTag;
00096   
00097 
00098   // get  the external nodes
00099   for ( i=0 ; i<6 ; i++)
00100   {
00101     theNodes[i] = NULL;
00102     theNodes[i] = TheDomain->getNode( ExternalNodes(i) );
00103     if (theNodes[i] == NULL) {
00104       opserr << "WARNING Joint3D::setDomain(): Nd" <<(i+1) <<": ";
00105       opserr << ExternalNodes(i) << "does not exist in model for element \n" << *this;
00106       return;
00107     }
00108   }
00109   
00110   // check for a two dimensional domain, since this element supports only two dimensions 
00111   const Vector &end1Crd = theNodes[0]->getCrds();
00112   const Vector &end2Crd = theNodes[1]->getCrds();       
00113   const Vector &end3Crd = theNodes[2]->getCrds();
00114   const Vector &end4Crd = theNodes[3]->getCrds();
00115   const Vector &end5Crd = theNodes[4]->getCrds();
00116   const Vector &end6Crd = theNodes[5]->getCrds();
00117   
00118   int dimNd1 = end1Crd.Size();
00119   int dimNd2 = end2Crd.Size();
00120   int dimNd3 = end3Crd.Size();
00121   int dimNd4 = end4Crd.Size();
00122   int dimNd5 = end5Crd.Size();
00123   int dimNd6 = end6Crd.Size();
00124 
00125   if (dimNd1 != 3 || dimNd2 != 3 || dimNd3 != 3 || dimNd4 != 3 || dimNd5 != 3 || dimNd6 != 3 ) {
00126     opserr << "WARNING Joint3D::setDomain(): has incorrect space dimension \n";
00127     opserr << "                                    space dimension not supported by Joint3D";
00128     return;
00129   }
00130         
00131   // now verify the number of dof at node ends
00132   int dofNd1 = theNodes[0]->getNumberDOF();
00133   int dofNd2 = theNodes[1]->getNumberDOF();     
00134   int dofNd3 = theNodes[2]->getNumberDOF();
00135   int dofNd4 = theNodes[3]->getNumberDOF();
00136   int dofNd5 = theNodes[4]->getNumberDOF();
00137   int dofNd6 = theNodes[5]->getNumberDOF();
00138 
00139   if (dofNd1 != 6 || dofNd2 != 6 || dofNd3 != 6 || dofNd4 != 6 || dofNd5 != 6 || dofNd6 != 6 ) {
00140     opserr << "WARNING Joint3D::Joint3D: has incorrect degrees of freedom \n";
00141     opserr << "                                    DOF not supported by Joint3D";
00142     return;
00143   }
00144   
00145   // check the joint size. The joint size must be non-zero
00146   Vector Center1(end1Crd);
00147   Vector Center2(end3Crd);
00148   Vector Center3(end5Crd);
00149   Center1 = Center1 - end2Crd;
00150   Center2 = Center2 - end4Crd;
00151   Center3 = Center3 - end6Crd;
00152         
00153   double L1 = Center1.Norm();
00154   double L2 = Center2.Norm();
00155   double L3 = Center3.Norm();
00156   
00157   if( Center1.Norm()<1e-12  || Center2.Norm()<1e-12  || Center3.Norm()<1e-12 ) {
00158     opserr << "WARNING Joint3D::(): zero length\n";
00159     return;     
00160   }
00161         
00162   // check if nodes are not located on each other and they can construct
00163   // a parallelogram
00164   Center1 = end1Crd + end2Crd;
00165   Center2 = end3Crd + end4Crd;
00166   Center3 = end5Crd + end6Crd;
00167   
00168   Center1 = 0.5 * Center1;
00169   Center2 = 0.5 * Center2;
00170   Center3 = 0.5 * Center3;
00171   
00172   Vector CenterTemp(Center2);
00173   CenterTemp = CenterTemp - Center1;
00174   if ( CenterTemp.Norm() > 1e-6 ) {
00175     opserr << "WARNING Joint3D::(): can not construct a shear block over external nodes\n";
00176         opserr << "check the coordinates\n";
00177     return;     
00178   }
00179   
00180   CenterTemp = Center3 - Center1;
00181   if ( CenterTemp.Norm() > 1e-6 ) {
00182     opserr << "WARNING Joint3D::(): can not construct a shear block over external nodes\n";
00183         opserr << "check the coordinates\n";
00184     return;     
00185   }
00186         
00187   // Generate internal node and add it up to domain
00188   theNodes[6]  = new Node ( IntNodeTag , 9, Center1(0) , Center1(1) , Center1(2) );
00189   if ( theNodes[6] == NULL ) {
00190     opserr << "Joint3D::Joint3D - Unable to generate new nodes , out of memory\n" ;
00191   } else {
00192     if( TheDomain->addNode( theNodes[6] ) == false )            // add intenal nodes to domain
00193       opserr << "Joint3D::Joint3D - unable to add internal nodeto domain\n";
00194   }
00195   
00196   // make copy of the uniaxial materials for the element
00197 
00198   if ( &springx == NULL ) {
00199           opserr << "ERROR Joint3D::Joint3D(): The rotational spring in y'z' plane does not exist ";
00200           exit(-1);
00201   } else { theSprings[0] = springx.getCopy(); }
00202   
00203   if ( &springy == NULL ) {
00204           opserr << "ERROR Joint3D::Joint3D(): The rotational spring in x'z' plane does not exist ";
00205           exit(-1);
00206   } else { theSprings[1] = springy.getCopy(); }
00207   
00208   if ( &springz == NULL ) {
00209           opserr << "ERROR Joint3D::Joint3D(): The rotational spring in x'y' plane does not exist ";
00210           exit(-1);
00211   } else { theSprings[2] = springz.getCopy(); }
00212   
00213   for ( i=0 ; i<3 ; i++ )
00214   {
00215       if ( theSprings[i] == NULL ) {
00216                   opserr << "ERROR Joint3D::Joint3D(): Can not make copy of uniaxial materials, out of memory ";
00217                   exit(-1);
00218       }
00219   }
00220   
00221 
00222   // Generate and add constraints to domain
00223   
00224   // get the constraint numbers
00225   int startMPtag = theDomain->getNumMPs();
00226   for ( i=0 ; i<6 ; i++ ) InternalConstraints(i) = startMPtag + i ;
00227  
00228   // create MP_Joint constraint node 1
00229   if ( addMP_Joint( TheDomain, InternalConstraints(0), ExternalNodes(6), ExternalNodes(0), ExternalNodes(5), 8, ExternalNodes(3), 7, LrgDisp ) != 0) {
00230     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 1\n";
00231     return;
00232   }
00233 
00234   // create MP_Joint constraint node 2
00235   if ( addMP_Joint( TheDomain, InternalConstraints(1), ExternalNodes(6), ExternalNodes(1), ExternalNodes(5), 8, ExternalNodes(3), 7, LrgDisp ) != 0) {
00236     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 2\n";
00237     return;
00238   }
00239 
00240   // create MP_Joint constraint node 3
00241   if ( addMP_Joint( TheDomain, InternalConstraints(2), ExternalNodes(6), ExternalNodes(2), ExternalNodes(1), 6, ExternalNodes(5), 8, LrgDisp ) != 0) {
00242     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 3\n";
00243     return;
00244   }
00245   
00246   // create MP_Joint constraint node 4
00247   if ( addMP_Joint( TheDomain, InternalConstraints(3), ExternalNodes(6), ExternalNodes(3), ExternalNodes(1), 6, ExternalNodes(5), 8, LrgDisp ) != 0) {
00248     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 4\n";
00249     return;
00250   }
00251 
00252   // create MP_Joint constraint node 5
00253   if ( addMP_Joint( TheDomain, InternalConstraints(4), ExternalNodes(6), ExternalNodes(4), ExternalNodes(3), 7, ExternalNodes(1), 6, LrgDisp ) != 0) {
00254     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 3\n";
00255     return;
00256   }
00257 
00258   // create MP_Joint constraint node 6
00259   if ( addMP_Joint( TheDomain, InternalConstraints(5), ExternalNodes(6), ExternalNodes(5), ExternalNodes(3), 7, ExternalNodes(1), 6, LrgDisp ) != 0) {
00260     opserr << "WARNING Joint3D::Joint3D(): can not generate ForJoint MP at node 3\n";
00261     return;
00262   }
00263 }
00264 
00265 
00266 Joint3D::~Joint3D()
00267 {
00268 
00269         if ( TheDomain != NULL)
00270         {
00271                 MP_Constraint *Temp_MP;
00272                 for ( int i=0 ; i < 6 ; i++ )
00273                 {
00274                         Temp_MP = TheDomain->getMP_Constraint( InternalConstraints(i) );
00275                         
00276                         if ( Temp_MP != NULL )
00277                         {
00278                                 TheDomain->removeMP_Constraint( InternalConstraints(i) );
00279                                 delete Temp_MP;
00280                         }
00281                 }
00282                 if ( theNodes[7] != NULL )
00283                 {
00284                         int intnodetag = theNodes[7]->getTag();
00285                         TheDomain->removeNode( intnodetag );
00286                         delete theNodes[7];
00287                 }
00288         }
00289 
00290         for (int i=0 ; i<3 ; i++)
00291                 if ( theSprings[i] != NULL ) delete theSprings[i];
00292 }
00293 
00294 
00295 
00296 void Joint3D::setDomain(Domain *theDomain)
00297 {
00298         //Ckeck domain not null - invoked when object removed from a domain
00299         if (theDomain == 0) {
00300                 for(int i=0 ; i<7 ; i++) theNodes[i] = NULL;
00301         } else {
00302                 
00303                 TheDomain = theDomain;
00304                 this->DomainComponent::setDomain(theDomain);
00305                 
00306                 for (int i=0 ; i<7 ; i++)
00307                         if ( theNodes[i] ==0 )  theNodes[i] = TheDomain->getNode( ExternalNodes(i) );
00308         }
00309 }
00310 
00311 
00312 int Joint3D::addMP_Joint(Domain *theDomain, int mpNum, int RetNodeID, int ConNodeID, int RotNodeID, int Rdof, int DspNodeID, int Ddof, int LrgDispFlag )
00313 {
00314         MP_Constraint *Temp_MP;
00315 
00316         // create MP_ForJoint constraint
00317         Temp_MP = new MP_Joint3D( theDomain, mpNum, RetNodeID, ConNodeID, RotNodeID, Rdof, DspNodeID, Ddof, LrgDispFlag );
00318                 
00319         if (Temp_MP == NULL)
00320         {
00321                 opserr << "Joint3D::addMP_Joint - WARNING ran out of memory for MP_Joint3D MP_Constraint ";
00322                 return -1;
00323         }
00324         // Add the multi-point constraint to the domain
00325         if (theDomain->addMP_Constraint (Temp_MP) == false)
00326         {
00327                 opserr << "Joint3D::addMP_Joint - WARNING could not add equalDOF MP_Constraint to domain ";
00328                 delete Temp_MP;
00329                 return -2;
00330         }
00331         return 0;
00332 }
00333 
00335 // Public methods called, taken care of for 2D element subclasses
00337 
00338 int Joint3D::update(void)
00339 {
00340         const Vector &dispC = theNodes[6]->getTrialDisp();
00341 
00342         int result = 0;
00343 
00344         for ( int i=0 ; i<3 ; i++ )
00345         {
00346                 if ( theSprings[i] != NULL ) result = theSprings[i]->setTrialStrain(dispC(i+6));
00347                 if ( result != 0 ) break;
00348         }
00349         
00350         return result;
00351 }
00352 
00353 int Joint3D::commitState()
00354 {
00355         int result = 0;
00356 
00357         for ( int i=0 ; i<3 ; i++ )
00358         {
00359                 if ( theSprings[i] != NULL ) result = theSprings[i]->commitState();
00360                 if ( result != 0 ) break;
00361         }
00362         
00363         return result;
00364 }
00365 
00366 int Joint3D::revertToLastCommit()
00367 {
00368         int result = 0;
00369 
00370         for ( int i=0 ; i<3 ; i++ )
00371         {
00372                 if ( theSprings[i] != NULL ) result = theSprings[i]->revertToLastCommit();
00373                 if ( result != 0 ) break;
00374         }
00375         
00376         return result;
00377 }
00378 
00379 int Joint3D::revertToStart(void)
00380 {
00381         int result = 0;
00382 
00383         for ( int i=0 ; i<3 ; i++ )
00384         {
00385                 if ( theSprings[i] != NULL ) result = theSprings[i]->revertToStart();
00386                 if ( result != 0 ) break;
00387         }
00388         
00389         return result;
00390 }
00391 
00392 
00393 int Joint3D::getNumExternalNodes(void) const
00394 {
00395         return 7;
00396 }
00397 
00398 const ID &Joint3D::getExternalNodes(void)
00399 {
00400         return ExternalNodes;
00401 }
00402 
00403 Node **Joint3D::getNodePtrs(void)
00404 {
00405         return theNodes;
00406 }
00407 
00408 int Joint3D::getNumDOF(void)
00409 {
00410   return numDof;
00411 }
00412 
00413 const Matrix &Joint3D::getTangentStiff(void)
00414 {
00415         double Ktangent[3] ;
00416         for ( int i=0 ; i<3 ; i++ ) 
00417         {
00418                 Ktangent[i] = 0;
00419                 if ( theSprings[i] != NULL ) Ktangent[i] = theSprings[i]->getTangent();
00420         }
00421 
00422         K.Zero();
00423 
00424         K(42,42)  =  Ktangent[0];
00425         K(43,43)  =  Ktangent[1];
00426         K(44,44)  =  Ktangent[2];
00427 
00428         return K;
00429 }
00430 
00431 
00432 const Matrix &Joint3D::getInitialStiff(void)
00433 {
00434         double Kintial[3] ;
00435         for ( int i=0 ; i<3 ; i++ ) 
00436         {
00437                 Kintial[i] = 0;
00438                 if ( theSprings[i] != NULL ) Kintial[i] = theSprings[i]->getTangent();
00439         }
00440 
00441         K.Zero();
00442 
00443         K(42,42)  =  Kintial[0];
00444         K(43,43) = -Kintial[0];
00445         K(44,44)  =  Kintial[1];
00446 
00447         return K;
00448 }
00449 
00450 
00451 const Matrix &Joint3D::getDamp(void)
00452 {       
00453         K.Zero();
00454         return K;
00455 }
00456 
00457 const Matrix &Joint3D::getMass(void)
00458 {
00459         K.Zero();
00460         return K;
00461 }
00462 
00463 void Joint3D::Print(OPS_Stream &s, int flag )
00464 {
00465   s << "\nElement: " << getTag() << " type: Joint3D iNode: "
00466     << ExternalNodes(0) << " jNode: " << ExternalNodes(1) << "\n"
00467     << " kNode: " << ExternalNodes(2) << " lNode: " << ExternalNodes(3) << "\n"
00468         << " mNode: " << ExternalNodes(4) << " nNode: " << ExternalNodes(5) << "\n"
00469         << " Internal node: " << ExternalNodes(6) << "\n";
00470 }
00471 
00473 // methods for applying and returning loads
00475 
00476 void Joint3D::zeroLoad(void)
00477 {
00478 
00479 }
00480 
00481 int Joint3D::addLoad(ElementalLoad *theLoad, double loadFactor)
00482 {
00483   return 0;
00484 }
00485 
00486 int Joint3D::addInertiaLoadToUnbalance(const Vector &accel)
00487 {
00488     return 0;
00489 }
00490 
00491 
00492 
00493 const Vector &Joint3D::getResistingForce()
00494 {
00495         double Force[3] ;
00496         for ( int i=0 ; i<3 ; i++ ) 
00497         {
00498                 Force[i] = 0;
00499                 if ( theSprings[i] != NULL ) Force[i] = theSprings[i]->getStress();
00500         }
00501 
00502         V.Zero();
00503 
00504         V(42) = Force[0];
00505         V(43) = Force[1];
00506         V(44) = Force[2];
00507 
00508         return V;
00509 }
00510 
00511 const Vector &
00512 Joint3D::getResistingForceIncInertia()
00513 {
00514         return this->getResistingForce();
00515 }
00516 
00517 
00518 int Joint3D::displaySelf(Renderer &theViewer, int displayMode, float fact)
00519 {
00520         // first determine the four corner points of the element based on
00521         // the display factor (a measure of the distorted image)
00522         // store this information in 2 3d vectors v1 and v2
00523 
00524         const Vector &node1Crd = theNodes[0]->getCrds();
00525         const Vector &node2Crd = theNodes[1]->getCrds();        
00526         const Vector &node3Crd = theNodes[2]->getCrds();
00527         const Vector &node4Crd = theNodes[3]->getCrds();
00528         const Vector &node5Crd = theNodes[4]->getCrds();
00529         const Vector &node6Crd = theNodes[5]->getCrds();
00530 
00531         const Vector &node1Disp = theNodes[0]->getDisp();
00532         const Vector &node2Disp = theNodes[1]->getDisp();    
00533         const Vector &node3Disp = theNodes[2]->getDisp();
00534         const Vector &node4Disp = theNodes[3]->getDisp();  
00535         const Vector &node5Disp = theNodes[4]->getDisp(); 
00536         const Vector &node6Disp = theNodes[5]->getDisp(); 
00537 
00538         static Vector v1(3);
00539         static Vector v2(3);
00540         static Vector v3(3);
00541         static Vector v4(3);
00542         static Vector v5(3);
00543         static Vector v6(3);
00544         
00545         // calculate the current coordinates of four external nodes
00546         for (int i=0; i<3; i++) 
00547     {
00548                 v1(i) = node1Crd(i)+node1Disp(i)*fact;
00549                 v2(i) = node2Crd(i)+node2Disp(i)*fact;
00550                 v3(i) = node3Crd(i)+node3Disp(i)*fact;
00551                 v4(i) = node4Crd(i)+node4Disp(i)*fact;
00552                 v5(i) = node5Crd(i)+node5Disp(i)*fact;
00553                 v6(i) = node6Crd(i)+node6Disp(i)*fact;
00554         }
00555 
00556         // draw the center lines
00557         int dummy;
00558         dummy = theViewer.drawLine(v1, v2, 1.0, 1.0);
00559         dummy = theViewer.drawLine(v3, v4, 1.0, 1.0);
00560         dummy = theViewer.drawLine(v5, v6, 1.0, 1.0);
00561         
00562         // calculate the eight corners of the block
00563         Vector va(3);
00564         Vector vb(3);
00565         Vector vc(3);
00566 
00567         va = v2 - v1;
00568         vb = v4 - v3;
00569         vc = v6 - v5;
00570 
00571         Vector vbegin(3);
00572         Vector vend(3);
00573         vbegin = v1 + 0.5*vb - 0.5*vc;
00574         vend = vbegin + va;
00575         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00576 
00577         vbegin = vend;
00578         vend = vbegin + vb;
00579         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00580 
00581         vbegin = vend;
00582         vend = vbegin - va;
00583         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00584 
00585         vbegin = vend;
00586         vend = vbegin - vb;
00587         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00588 
00589         vbegin = v1 - 0.5*vb - 0.5*vc;
00590         vend = vbegin + va;
00591         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00592 
00593         vbegin = vend;
00594         vend = vbegin + vb;
00595         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00596 
00597         vbegin = vend;
00598         vend = vbegin - va;
00599         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00600 
00601         vbegin = vend;
00602         vend = vbegin - vb;
00603         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00604 
00605         vbegin = v1 + 0.5*vb - 0.5*vc;
00606         vend = vbegin - vb;
00607         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00608 
00609         vbegin = v1 + 0.5*vb + 0.5*vc;
00610         vend = vbegin - vb;
00611         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00612 
00613         vbegin = v2 + 0.5*vb - 0.5*vc;
00614         vend = vbegin - vb;
00615         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00616 
00617         vbegin = v2 + 0.5*vb + 0.5*vc;
00618         vend = vbegin - vb;
00619         dummy = theViewer.drawLine(vbegin, vend, 1.0, 1.0);
00620 
00621         return 0;
00622 
00623 }
00624 
00625 
00626 //most-probably requires to be overridden
00627 Response* Joint3D::setResponse(const char **argv, int argc, Information &eleInformation, OPS_Stream &output)
00628 {
00629 //
00630 // we compare argv[0] for known response types for the Truss
00631 //
00632 
00633         if (strcmp(argv[0],"node") == 0 || strcmp(argv[0],"internalNode") == 0 )
00634     return new ElementResponse(this, 1, Vector(9));
00635 
00636         else if (strcmp(argv[0],"size") == 0 || strcmp(argv[0],"jointSize") == 0 )
00637     return new ElementResponse(this, 2, Vector(3));
00638 
00639         else if (strcmp(argv[0],"moment") == 0 || strcmp(argv[0],"moments") == 0 
00640                 || strcmp(argv[0],"force") == 0 || strcmp(argv[0],"forces") == 0 )
00641     return new ElementResponse(this, 3, Vector(3));
00642 
00643         else if (strcmp(argv[0],"defo") == 0 || strcmp(argv[0],"deformations") == 0 ||
00644            strcmp(argv[0],"deformation") == 0 )
00645     return new ElementResponse(this, 4, Vector(3));
00646 
00647         else if (strcmp(argv[0],"defoANDforce") == 0 || strcmp(argv[0],"deformationANDforce") == 0 ||
00648            strcmp(argv[0],"deformationsANDforces") == 0 )
00649     return new ElementResponse(this, 5, Vector(6));
00650 
00651         else if ( strcmp(argv[0],"stiff") == 0 || strcmp(argv[0],"stiffness") == 0 )
00652     return new ElementResponse(this, 6, Matrix(45,45) );
00653         
00654         else if (strcmp(argv[0],"plasticRotation") == 0 || strcmp(argv[0],"plasticDeformation") == 0)
00655                 return new ElementResponse(this, 7, Vector(3));
00656 
00657         else 
00658                 return 0;
00659         
00660 }
00661 
00662 int Joint3D::getResponse(int responseID, Information &eleInformation)
00663 {
00664         switch (responseID) {
00665         case -1:
00666                 return -1;
00667         
00668         case 1:
00669                 if(eleInformation.theVector!=0)
00670                 {
00671                         const Vector& disp = theNodes[6]->getTrialDisp();
00672                         for ( int i = 0 ; i<9 ; i++ ) 
00673                                 (*(eleInformation.theVector))(i) = disp(i);
00674                 }
00675                 return 0;
00676 
00677         case 2:
00678                 if(eleInformation.theVector!=0)
00679                 {
00680                         const Vector &node1Crd = theNodes[0]->getCrds();
00681                         const Vector &node2Crd = theNodes[1]->getCrds();        
00682                         const Vector &node3Crd = theNodes[2]->getCrds();
00683                         const Vector &node4Crd = theNodes[3]->getCrds();
00684                         const Vector &node5Crd = theNodes[4]->getCrds();
00685                         const Vector &node6Crd = theNodes[5]->getCrds();
00686 
00687                         const Vector &node1Disp = theNodes[0]->getDisp();
00688                         const Vector &node2Disp = theNodes[1]->getDisp();    
00689                         const Vector &node3Disp = theNodes[2]->getDisp();
00690                         const Vector &node4Disp = theNodes[3]->getDisp();  
00691                         const Vector &node5Disp = theNodes[4]->getDisp();
00692                         const Vector &node6Disp = theNodes[5]->getDisp(); 
00693 
00694                         Vector v1(3);
00695                         Vector v2(3);
00696                         Vector v3(3);
00697                         Vector v4(3);
00698                         Vector v5(3);
00699                         Vector v6(3);
00700         
00701                         // calculate the current coordinates of four external nodes
00702                         for (int i=0; i<3; i++) 
00703                     {
00704                                 v1(i) = node1Crd(i)+node1Disp(i);
00705                                 v2(i) = node2Crd(i)+node2Disp(i);
00706                                 v3(i) = node3Crd(i)+node3Disp(i);
00707                                 v4(i) = node4Crd(i)+node4Disp(i);
00708                                 v5(i) = node5Crd(i)+node5Disp(i);
00709                                 v6(i) = node6Crd(i)+node6Disp(i);
00710                         }
00711                         v2 = v2 - v1;
00712                         v4 = v4 - v3;
00713                         v6 = v6 - v5;
00714 
00715                         v1(0) = sqrt( v2(0)*v2(0) + v2(1)*v2(1) + v2(2)*v2(2) );
00716                         v1(1) = sqrt( v4(0)*v4(0) + v4(1)*v4(1) + v4(2)*v4(2) );
00717                         v1(2) = sqrt( v6(0)*v6(0) + v6(1)*v6(1) + v6(2)*v6(2) );
00718 
00719                         *(eleInformation.theVector) = v1;
00720                 }
00721                 return 0;
00722 
00723         case 3:
00724                 if( eleInformation.theVector != 0 )
00725                 {
00726                         for ( int i =0 ; i<3 ; i++ )
00727                         {
00728                                 (*(eleInformation.theVector))(i) = 0.0;
00729                                 if ( theSprings[i] != NULL ) 
00730                                         (*(eleInformation.theVector))(i) = theSprings[i]->getStress();
00731                         }
00732                 }
00733                 return 0;
00734 
00735         case 4:
00736                 if(eleInformation.theVector!=0)
00737                 {
00738                         for ( int i =0 ; i<3 ; i++ )
00739                         {
00740                                 (*(eleInformation.theVector))(i) = 0.0;
00741                                 if ( theSprings[i] != NULL ) 
00742                                         (*(eleInformation.theVector))(i) = theSprings[i]->getStrain();
00743                         }
00744                 }
00745                 return 0;
00746 
00747         case 5:
00748                 if(eleInformation.theVector!=0)
00749                 {
00750                         for ( int i =0 ; i<3 ; i++ )
00751                         {
00752                                 (*(eleInformation.theVector))(i) = 0.0;
00753                                 (*(eleInformation.theVector))(i+3) = 0.0;
00754                                 if ( theSprings[i] != NULL )
00755                                 {
00756                                         (*(eleInformation.theVector))(i) = theSprings[i]->getStrain();
00757                                         (*(eleInformation.theVector))(i+3) = theSprings[i]->getStress();
00758                                 }
00759                         }
00760                 }
00761                 return 0;
00762 
00763         case 6:
00764                 return eleInformation.setMatrix(this->getTangentStiff());
00765         
00766         case 7:
00767                 if(eleInformation.theVector!=0)
00768                 {
00769                         for ( int i=0 ; i<3 ; i++ )
00770                         {
00771                                 (*(eleInformation.theVector))(i) = 0.0;
00772                                 if ( theSprings[i] != NULL && theSprings[i]->getInitialTangent() != 0.0 )
00773                                 {
00774                                         (*(eleInformation.theVector))(i) = 
00775                                                 theSprings[i]->getStrain() - theSprings[i]->getStress()/theSprings[i]->getInitialTangent();
00776                                 }
00777                                 
00778                         }                       
00779                 }
00780                 return 0;
00781         
00782         default:
00783                 return -1;
00784         }
00785 }
00786 
00787 
00788 int Joint3D::sendSelf(int commitTag, Channel &theChannel)
00789 {
00790         return 0;
00791 }
00792 
00793 int Joint3D::recvSelf(int commitTag, Channel &theChannel, FEM_ObjectBroker &theBroker)
00794 {
00795         return 0;
00796 }
00797 

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