PDeltaCrdTransf2d.cpp

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.10 $
00022 // $Date: 2005/12/15 00:30:38 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/coordTransformation/PDeltaCrdTransf2d.cpp,v $
00024 
00025 
00026 // Written: Remo Magalhaes de Souza (rmsouza@ce.berkeley.edu)
00027 // Created: 04/2000
00028 // Revision: A
00029 //
00030 // Modified: 04/2005 Andreas Schellenberg (getBasicTrialVel, getBasicTrialAccel)
00031 // 
00032 // Purpose: This file contains the implementation for the 
00033 // PDeltaCrdTransf2d class. PDeltaCrdTransf2d is a linear
00034 // transformation for a planar frame between the global 
00035 // and basic coordinate systems
00036 
00037 
00038 #include <Vector.h>
00039 #include <Matrix.h>
00040 #include <Node.h>
00041 #include <Channel.h>
00042 
00043 #include <PDeltaCrdTransf2d.h>
00044 
00045 
00046 // constructor:
00047 PDeltaCrdTransf2d::PDeltaCrdTransf2d(int tag)
00048 :CrdTransf2d(tag, CRDTR_TAG_PDeltaCrdTransf2d),
00049 nodeIPtr(0), nodeJPtr(0),
00050 nodeIOffset(0), nodeJOffset(0),
00051 cosTheta(0), sinTheta(0), L(0), ul14(0),
00052 nodeIInitialDisp(0), nodeJInitialDisp(0), initialDispChecked(false)
00053 {
00054     // Does nothing
00055 }
00056 
00057 
00058 // constructor:
00059 PDeltaCrdTransf2d::PDeltaCrdTransf2d(int tag,
00060                                      const Vector &rigJntOffset1,
00061                                      const Vector &rigJntOffset2)
00062                                      :CrdTransf2d(tag, CRDTR_TAG_PDeltaCrdTransf2d),
00063                                      nodeIPtr(0), nodeJPtr(0),
00064                                      nodeIOffset(0), nodeJOffset(0),
00065                                      cosTheta(0), sinTheta(0), L(0), ul14(0),
00066                                      nodeIInitialDisp(0), nodeJInitialDisp(0), initialDispChecked(false)
00067 {
00068     // check rigid joint offset for node I
00069     if (&rigJntOffset1 == 0 || rigJntOffset1.Size() != 2 ) {
00070         opserr << "PDeltaCrdTransf2d::PDeltaCrdTransf2d:  Invalid rigid joint offset vector for node I\n";
00071         opserr << "Size must be 2\n";      
00072     }
00073     else if (rigJntOffset1.Norm() > 0.0) {
00074         nodeIOffset = new double[2];
00075         nodeIOffset[0] = rigJntOffset1(0);
00076         nodeIOffset[1] = rigJntOffset1(1);
00077     }
00078     
00079     // check rigid joint offset for node J
00080     if (&rigJntOffset2 == 0 || rigJntOffset2.Size() != 2 ) {
00081         opserr << "PDeltaCrdTransf2d::PDeltaCrdTransf2d:  Invalid rigid joint offset vector for node J\n";
00082         opserr << "Size must be 2\n";      
00083     }
00084     else if (rigJntOffset2.Norm() > 0.0) {
00085         nodeJOffset = new double[2];
00086         nodeJOffset[0] = rigJntOffset2(0);
00087         nodeJOffset[1] = rigJntOffset2(1);
00088     }
00089 }
00090 
00091 
00092 // constructor:
00093 // invoked by a FEM_ObjectBroker, recvSelf() needs to be invoked on this object.
00094 PDeltaCrdTransf2d::PDeltaCrdTransf2d()
00095 :CrdTransf2d(0, CRDTR_TAG_PDeltaCrdTransf2d),
00096 nodeIPtr(0), nodeJPtr(0),
00097 nodeIOffset(0), nodeJOffset(0),
00098 cosTheta(0), sinTheta(0), L(0), ul14(0),
00099 nodeIInitialDisp(0), nodeJInitialDisp(0), initialDispChecked(false)
00100 {
00101     
00102 }
00103 
00104 
00105 // destructor:
00106 PDeltaCrdTransf2d::~PDeltaCrdTransf2d() 
00107 {
00108     if (nodeIOffset)
00109         delete [] nodeIOffset;
00110     if (nodeJOffset)
00111         delete [] nodeJOffset;
00112     if (nodeIInitialDisp != 0)
00113         delete [] nodeIInitialDisp;
00114     if (nodeJInitialDisp != 0)
00115         delete [] nodeJInitialDisp;
00116 }
00117 
00118 
00119 int
00120 PDeltaCrdTransf2d::commitState(void)
00121 {
00122     return 0;
00123 }
00124 
00125 
00126 int
00127 PDeltaCrdTransf2d::revertToLastCommit(void)
00128 {
00129     return 0;
00130 }
00131 
00132 
00133 int
00134 PDeltaCrdTransf2d::revertToStart(void)
00135 {
00136     return 0;
00137 }
00138 
00139 
00140 int 
00141 PDeltaCrdTransf2d::initialize(Node *nodeIPointer, Node *nodeJPointer)
00142 {       
00143     int error;
00144     
00145     nodeIPtr = nodeIPointer;
00146     nodeJPtr = nodeJPointer;
00147     
00148     if ((!nodeIPtr) || (!nodeJPtr))
00149     {
00150         opserr << "\nPDeltaCrdTransf2d::initialize";
00151         opserr << "\ninvalid pointers to the element nodes\n";
00152         return -1;
00153     }
00154     
00155     // see if there is some initial displacements at nodes
00156     if (initialDispChecked == false) {
00157         
00158         const Vector &nodeIDisp = nodeIPtr->getDisp();
00159         const Vector &nodeJDisp = nodeJPtr->getDisp();
00160         for (int i=0; i<3; i++)
00161             if (nodeIDisp(i) != 0.0) {
00162                 nodeIInitialDisp = new double [3];
00163                 for (int j=0; j<3; j++)
00164                     nodeIInitialDisp[j] = nodeIDisp(j);
00165                 i = 3;
00166             }
00167             for (int j=0; j<3; j++)
00168                 if (nodeJDisp(j) != 0.0) {
00169                     nodeJInitialDisp = new double [3];
00170                     for (int i=0; i<3; i++)
00171                         nodeJInitialDisp[i] = nodeJDisp(i);
00172                     j = 3;
00173                 }
00174                 
00175                 initialDispChecked = true;
00176     }
00177     
00178     // get element length and orientation
00179     if ((error = this->computeElemtLengthAndOrient()))
00180         return error;
00181     
00182     
00183     return 0;
00184 }
00185 
00186 
00187 int
00188 PDeltaCrdTransf2d::update(void)
00189 {
00190     static Vector nodeIDisp(3);
00191     static Vector nodeJDisp(3);
00192     nodeIDisp = nodeIPtr->getTrialDisp();
00193     nodeJDisp = nodeJPtr->getTrialDisp();
00194     
00195     if (nodeIInitialDisp != 0) {
00196         for (int j=0; j<3; j++)
00197             nodeIDisp(j) -= nodeIInitialDisp[j];
00198     }
00199     
00200     if (nodeJInitialDisp != 0) {
00201         for (int j=0; j<3; j++)
00202             nodeJDisp(j) -= nodeJInitialDisp[j];
00203     }
00204     
00205     double ul1;
00206     double ul4;
00207     
00208     ul1 = -sinTheta*nodeIDisp(0) + cosTheta*nodeIDisp(1);
00209     ul4 = -sinTheta*nodeJDisp(0) + cosTheta*nodeJDisp(1);
00210     
00211     if (nodeIOffset != 0) {
00212         double t12 = sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00213         ul1 += t12*nodeIDisp(2);
00214     }
00215     
00216     if (nodeJOffset != 0) {
00217         double t45 = sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00218         ul4 += t45*nodeJDisp(2);
00219     }
00220     
00221     ul14 = ul1-ul4;
00222     
00223     return 0;
00224 }
00225 
00226 
00227 int 
00228 PDeltaCrdTransf2d::computeElemtLengthAndOrient()
00229 {
00230     // element projection
00231     static Vector dx(2);
00232     
00233     const Vector &ndICoords = nodeIPtr->getCrds();
00234     const Vector &ndJCoords = nodeJPtr->getCrds();
00235     
00236     dx(0) = ndJCoords(0) - ndICoords(0);
00237     dx(1) = ndJCoords(1) - ndICoords(1);
00238     
00239     if (nodeIInitialDisp != 0) {
00240         dx(0) -= nodeIInitialDisp[0];
00241         dx(1) -= nodeIInitialDisp[1];
00242     }
00243     
00244     if (nodeJInitialDisp != 0) {
00245         dx(0) += nodeJInitialDisp[0];
00246         dx(1) += nodeJInitialDisp[1];
00247     }
00248     
00249     if (nodeJOffset != 0) {
00250         dx(0) += nodeJOffset[0];
00251         dx(1) += nodeJOffset[1];
00252     }
00253     
00254     if (nodeIOffset != 0) {
00255         dx(0) -= nodeIOffset[0];
00256         dx(1) -= nodeIOffset[1];
00257     }
00258     
00259     // calculate the element length
00260     L = dx.Norm();
00261     
00262     if (L == 0.0) 
00263     {
00264         opserr << "\nPDeltaCrdTransf2d::computeElemtLengthAndOrien: 0 length\n";
00265         return -2;  
00266     }
00267     
00268     // calculate the element local x axis components (direction cossines)
00269     // wrt to the global coordinates 
00270     cosTheta = dx(0)/L;
00271     sinTheta = dx(1)/L;
00272     
00273     return 0;
00274 }
00275 
00276 
00277 double 
00278 PDeltaCrdTransf2d::getInitialLength(void)
00279 {
00280     return L;
00281 }
00282 
00283 
00284 double 
00285 PDeltaCrdTransf2d::getDeformedLength(void)
00286 {
00287     return L;
00288 }
00289 
00290 
00291 const Vector &
00292 PDeltaCrdTransf2d::getBasicTrialDisp (void)
00293 {
00294     // determine global displacements
00295     const Vector &disp1 = nodeIPtr->getTrialDisp();
00296     const Vector &disp2 = nodeJPtr->getTrialDisp();
00297     
00298     static double ug[6];
00299     for (int i = 0; i < 3; i++) {
00300         ug[i]   = disp1(i);
00301         ug[i+3] = disp2(i);
00302     }
00303     
00304     if (nodeIInitialDisp != 0) {
00305         for (int j=0; j<3; j++)
00306             ug[j] -= nodeIInitialDisp[j];
00307     }
00308     
00309     if (nodeJInitialDisp != 0) {
00310         for (int j=0; j<3; j++)
00311             ug[j+3] -= nodeJInitialDisp[j];
00312     }
00313     
00314     static Vector ub(3);
00315     
00316     double oneOverL = 1.0/L;
00317     double sl = sinTheta*oneOverL;
00318     double cl = cosTheta*oneOverL;
00319     
00320     ub(0) = -cosTheta*ug[0] - sinTheta*ug[1] +
00321         cosTheta*ug[3] + sinTheta*ug[4];
00322     
00323     ub(1) = -sl*ug[0] + cl*ug[1] + ug[2] +
00324         sl*ug[3] - cl*ug[4];
00325     
00326     if (nodeIOffset != 0) {
00327         double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00328         double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00329         ub(0) -= t02*ug[2];
00330         ub(1) += oneOverL*t12*ug[2];
00331     }
00332     
00333     if (nodeJOffset != 0) {
00334         double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00335         double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00336         ub(0) += t35*ug[5];
00337         ub(1) -= oneOverL*t45*ug[5];
00338     }
00339     
00340     ub(2) = ub(1) + ug[5] - ug[2];
00341     
00342     return ub;
00343 }
00344 
00345 
00346 const Vector &
00347 PDeltaCrdTransf2d::getBasicIncrDisp (void)
00348 {
00349     // determine global displacements
00350     const Vector &disp1 = nodeIPtr->getIncrDisp();
00351     const Vector &disp2 = nodeJPtr->getIncrDisp();
00352     
00353     static double dug[6];
00354     for (int i = 0; i < 3; i++) {
00355         dug[i]   = disp1(i);
00356         dug[i+3] = disp2(i);
00357     }
00358     
00359     static Vector dub(3);
00360     
00361     double oneOverL = 1.0/L;
00362     double sl = sinTheta*oneOverL;
00363     double cl = cosTheta*oneOverL;
00364     
00365     dub(0) = -cosTheta*dug[0] - sinTheta*dug[1] +
00366         cosTheta*dug[3] + sinTheta*dug[4];
00367     
00368     dub(1) = -sl*dug[0] + cl*dug[1] + dug[2] +
00369         sl*dug[3] - cl*dug[4];
00370     
00371     if (nodeIOffset != 0) {
00372         double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00373         double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00374         dub(0) -= t02*dug[2];
00375         dub(1) += oneOverL*t12*dug[2];
00376     }
00377     
00378     if (nodeJOffset != 0) {
00379         double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00380         double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00381         dub(0) += t35*dug[5];
00382         dub(1) -= oneOverL*t45*dug[5];
00383     }
00384     
00385     dub(2) = dub(1) + dug[5] - dug[2];
00386     
00387     return dub;
00388 }
00389 
00390 
00391 const Vector &
00392 PDeltaCrdTransf2d::getBasicIncrDeltaDisp(void)
00393 {
00394     // determine global displacements
00395     const Vector &disp1 = nodeIPtr->getIncrDeltaDisp();
00396     const Vector &disp2 = nodeJPtr->getIncrDeltaDisp();
00397     
00398     static double Dug[6];
00399     for (int i = 0; i < 3; i++) {
00400         Dug[i]   = disp1(i);
00401         Dug[i+3] = disp2(i);
00402     }
00403     
00404     static Vector Dub(3);
00405     
00406     double oneOverL = 1.0/L;
00407     double sl = sinTheta*oneOverL;
00408     double cl = cosTheta*oneOverL;
00409     
00410     Dub(0) = -cosTheta*Dug[0] - sinTheta*Dug[1] +
00411         cosTheta*Dug[3] + sinTheta*Dug[4];
00412     
00413     Dub(1) = -sl*Dug[0] + cl*Dug[1] + Dug[2] +
00414         sl*Dug[3] - cl*Dug[4];
00415     
00416     if (nodeIOffset != 0) {
00417         double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00418         double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00419         Dub(0) -= t02*Dug[2];
00420         Dub(1) += oneOverL*t12*Dug[2];
00421     }
00422     
00423     if (nodeJOffset != 0) {
00424         double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00425         double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00426         Dub(0) += t35*Dug[5];
00427         Dub(1) -= oneOverL*t45*Dug[5];
00428     }
00429     
00430     Dub(2) = Dub(1) + Dug[5] - Dug[2];
00431     
00432     return Dub;
00433 }
00434 
00435 
00436 const Vector &
00437 PDeltaCrdTransf2d::getBasicTrialVel(void)
00438 {
00439         // determine global velocities
00440         const Vector &vel1 = nodeIPtr->getTrialVel();
00441         const Vector &vel2 = nodeJPtr->getTrialVel();
00442         
00443         static double vg[6];
00444         for (int i = 0; i < 3; i++) {
00445                 vg[i]   = vel1(i);
00446                 vg[i+3] = vel2(i);
00447         }
00448         
00449         static Vector vb(3);
00450         
00451         double oneOverL = 1.0/L;
00452         double sl = sinTheta*oneOverL;
00453         double cl = cosTheta*oneOverL;
00454         
00455         vb(0) = -cosTheta*vg[0] - sinTheta*vg[1] +
00456                 cosTheta*vg[3] + sinTheta*vg[4];
00457         
00458         vb(1) = -sl*vg[0] + cl*vg[1] + vg[2] +
00459                 sl*vg[3] - cl*vg[4];
00460         
00461         if (nodeIOffset != 0) {
00462                 double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00463                 double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00464                 vb(0) -= t02*vg[2];
00465                 vb(1) += oneOverL*t12*vg[2];
00466         }
00467         
00468         if (nodeJOffset != 0) {
00469                 double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00470                 double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00471                 vb(0) += t35*vg[5];
00472                 vb(1) -= oneOverL*t45*vg[5];
00473         }
00474         
00475         vb(2) = vb(1) + vg[5] - vg[2];
00476         
00477         return vb;
00478 }
00479 
00480 
00481 const Vector &
00482 PDeltaCrdTransf2d::getBasicTrialAccel(void)
00483 {
00484         // determine global accelerations
00485         const Vector &accel1 = nodeIPtr->getTrialAccel();
00486         const Vector &accel2 = nodeJPtr->getTrialAccel();
00487         
00488         static double ag[6];
00489         for (int i = 0; i < 3; i++) {
00490                 ag[i]   = accel1(i);
00491                 ag[i+3] = accel2(i);
00492         }
00493         
00494         static Vector ab(3);
00495         
00496         double oneOverL = 1.0/L;
00497         double sl = sinTheta*oneOverL;
00498         double cl = cosTheta*oneOverL;
00499         
00500         ab(0) = -cosTheta*ag[0] - sinTheta*ag[1] +
00501                 cosTheta*ag[3] + sinTheta*ag[4];
00502         
00503         ab(1) = -sl*ag[0] + cl*ag[1] + ag[2] +
00504                 sl*ag[3] - cl*ag[4];
00505         
00506         if (nodeIOffset != 0) {
00507                 double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00508                 double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00509                 ab(0) -= t02*ag[2];
00510                 ab(1) += oneOverL*t12*ag[2];
00511         }
00512         
00513         if (nodeJOffset != 0) {
00514                 double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00515                 double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00516                 ab(0) += t35*ag[5];
00517                 ab(1) -= oneOverL*t45*ag[5];
00518         }
00519         
00520         ab(2) = ab(1) + ag[5] - ag[2];
00521         
00522         return ab;
00523 }
00524 
00525 
00526 const Vector &
00527 PDeltaCrdTransf2d::getGlobalResistingForce(const Vector &pb, const Vector &p0)
00528 {
00529     // transform resisting forces from the basic system to local coordinates
00530     static double pl[6];
00531     
00532     double q0 = pb(0);
00533     double q1 = pb(1);
00534     double q2 = pb(2);
00535     
00536     double oneOverL = 1.0/L;
00537     
00538     double V = oneOverL*(q1+q2);
00539     pl[0] = -q0;
00540     pl[1] =  V;
00541     pl[2] =  q1;
00542     pl[3] =  q0;
00543     pl[4] = -V;
00544     pl[5] =  q2;
00545     
00546     // add end forces due to element p0 loads
00547     pl[0] += p0(0);
00548     pl[1] += p0(1);
00549     pl[4] += p0(2);
00550     
00551     // Include leaning column effects (P-Delta)
00552     double NoverL = ul14*q0*oneOverL;             
00553     pl[1] += NoverL;
00554     pl[4] -= NoverL;
00555     
00556     // transform resisting forces  from local to global coordinates
00557     static Vector pg(6);
00558     
00559     pg(0) = cosTheta*pl[0] - sinTheta*pl[1];
00560     pg(1) = sinTheta*pl[0] + cosTheta*pl[1];
00561     
00562     pg(3) = cosTheta*pl[3] - sinTheta*pl[4];
00563     pg(4) = sinTheta*pl[3] + cosTheta*pl[4];
00564     
00565     pg(2) = pl[2];
00566     pg(5) = pl[5];      
00567     
00568     if (nodeIOffset != 0) {
00569         double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00570         double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00571         
00572         pg(2) += t02*pl[0] + t12*pl[1];
00573     }
00574     
00575     if (nodeJOffset != 0) {
00576         double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00577         double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00578         
00579         pg(5) += t35*pl[3] + t45*pl[4];
00580     }
00581     
00582     return pg;
00583 }
00584 
00585 
00586 const Matrix &
00587 PDeltaCrdTransf2d::getGlobalStiffMatrix (const Matrix &kb, const Vector &pb)
00588 {
00589     static Matrix kg(6,6);
00590     static double kl[6][6];
00591     static double tmp[6][6];
00592     
00593     double oneOverL = 1.0/L;
00594     
00595     // Basic stiffness
00596     double kb00, kb01, kb02, kb10, kb11, kb12, kb20, kb21, kb22;
00597     kb00 = kb(0,0);             kb01 = kb(0,1);         kb02 = kb(0,2);
00598     kb10 = kb(1,0);             kb11 = kb(1,1);         kb12 = kb(1,2);
00599     kb20 = kb(2,0);             kb21 = kb(2,1);         kb22 = kb(2,2);
00600     
00601     // Transform basic stiffness to local system
00602     kl[0][0] =  kb00;
00603     kl[1][0] = -oneOverL*(kb10+kb20);
00604     kl[2][0] = -kb10;
00605     kl[3][0] = -kb00;
00606     kl[4][0] = -kl[1][0];
00607     kl[5][0] = -kb20;
00608     
00609     kl[0][1] = -oneOverL*(kb01+kb02);
00610     kl[1][1] =  oneOverL*oneOverL*(kb11+kb12+kb21+kb22);
00611     kl[2][1] =  oneOverL*(kb11+kb12);
00612     kl[3][1] = -kl[0][1];
00613     kl[4][1] = -kl[1][1];
00614     kl[5][1] =  oneOverL*(kb21+kb22);
00615     
00616     kl[0][2] = -kb01;
00617     kl[1][2] =  oneOverL*(kb11+kb21);
00618     kl[2][2] =  kb11;
00619     kl[3][2] =  kb01;
00620     kl[4][2] = -kl[1][2];
00621     kl[5][2] =  kb21;
00622     
00623     kl[0][3] = -kl[0][0];
00624     kl[1][3] = -kl[1][0];
00625     kl[2][3] = -kl[2][0];
00626     kl[3][3] = -kl[3][0];
00627     kl[4][3] = -kl[4][0];
00628     kl[5][3] = -kl[5][0];
00629     
00630     kl[0][4] = -kl[0][1];
00631     kl[1][4] = -kl[1][1];
00632     kl[2][4] = -kl[2][1];
00633     kl[3][4] = -kl[3][1];
00634     kl[4][4] = -kl[4][1];
00635     kl[5][4] = -kl[5][1];
00636     
00637     kl[0][5] = -kb02;
00638     kl[1][5] =  oneOverL*(kb12+kb22);
00639     kl[2][5] =  kb12;
00640     kl[3][5] =  kb02;
00641     kl[4][5] = -kl[1][5];
00642     kl[5][5] =  kb22;
00643     
00644     // Include geometric stiffness effects in local system
00645     double NoverL = pb(0)*oneOverL;
00646     kl[1][1] += NoverL;
00647     kl[4][4] += NoverL;
00648     kl[1][4] -= NoverL;
00649     kl[4][1] -= NoverL;
00650     
00651     double t02 = 0.0;
00652     double t12 = 0.0;
00653     double t35 = 0.0;
00654     double t45 = 0.0;
00655     
00656     if (nodeIOffset != 0) {
00657         t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00658         t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00659     }
00660     
00661     if (nodeJOffset != 0) {
00662         t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00663         t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00664     }
00665     
00666     // Now transform from local to global ... compute kl*T
00667     tmp[0][0] = kl[0][0]*cosTheta - kl[0][1]*sinTheta;
00668     tmp[1][0] = kl[1][0]*cosTheta - kl[1][1]*sinTheta;
00669     tmp[2][0] = kl[2][0]*cosTheta - kl[2][1]*sinTheta;
00670     tmp[3][0] = kl[3][0]*cosTheta - kl[3][1]*sinTheta;
00671     tmp[4][0] = kl[4][0]*cosTheta - kl[4][1]*sinTheta;
00672     tmp[5][0] = kl[5][0]*cosTheta - kl[5][1]*sinTheta;
00673     
00674     tmp[0][1] = kl[0][0]*sinTheta + kl[0][1]*cosTheta;
00675     tmp[1][1] = kl[1][0]*sinTheta + kl[1][1]*cosTheta;
00676     tmp[2][1] = kl[2][0]*sinTheta + kl[2][1]*cosTheta;
00677     tmp[3][1] = kl[3][0]*sinTheta + kl[3][1]*cosTheta;
00678     tmp[4][1] = kl[4][0]*sinTheta + kl[4][1]*cosTheta;
00679     tmp[5][1] = kl[5][0]*sinTheta + kl[5][1]*cosTheta;
00680     
00681     if (nodeIOffset) {
00682         tmp[0][2] = kl[0][0]*t02 + kl[0][1]*t12 + kl[0][2];
00683         tmp[1][2] = kl[1][0]*t02 + kl[1][1]*t12 + kl[1][2];
00684         tmp[2][2] = kl[2][0]*t02 + kl[2][1]*t12 + kl[2][2];
00685         tmp[3][2] = kl[3][0]*t02 + kl[3][1]*t12 + kl[3][2];
00686         tmp[4][2] = kl[4][0]*t02 + kl[4][1]*t12 + kl[4][2];
00687         tmp[5][2] = kl[5][0]*t02 + kl[5][1]*t12 + kl[5][2];
00688     }
00689     else {
00690         tmp[0][2] = kl[0][2];
00691         tmp[1][2] = kl[1][2];
00692         tmp[2][2] = kl[2][2];
00693         tmp[3][2] = kl[3][2];
00694         tmp[4][2] = kl[4][2];
00695         tmp[5][2] = kl[5][2];
00696     }
00697     
00698     tmp[0][3] = kl[0][3]*cosTheta - kl[0][4]*sinTheta;
00699     tmp[1][3] = kl[1][3]*cosTheta - kl[1][4]*sinTheta;
00700     tmp[2][3] = kl[2][3]*cosTheta - kl[2][4]*sinTheta;
00701     tmp[3][3] = kl[3][3]*cosTheta - kl[3][4]*sinTheta;
00702     tmp[4][3] = kl[4][3]*cosTheta - kl[4][4]*sinTheta;
00703     tmp[5][3] = kl[5][3]*cosTheta - kl[5][4]*sinTheta;
00704     
00705     tmp[0][4] = kl[0][3]*sinTheta + kl[0][4]*cosTheta;
00706     tmp[1][4] = kl[1][3]*sinTheta + kl[1][4]*cosTheta;
00707     tmp[2][4] = kl[2][3]*sinTheta + kl[2][4]*cosTheta;
00708     tmp[3][4] = kl[3][3]*sinTheta + kl[3][4]*cosTheta;
00709     tmp[4][4] = kl[4][3]*sinTheta + kl[4][4]*cosTheta;
00710     tmp[5][4] = kl[5][3]*sinTheta + kl[5][4]*cosTheta;
00711     
00712     if (nodeJOffset) {
00713         tmp[0][5] = kl[0][3]*t35 + kl[0][4]*t45 + kl[0][5];
00714         tmp[1][5] = kl[1][3]*t35 + kl[1][4]*t45 + kl[1][5];
00715         tmp[2][5] = kl[2][3]*t35 + kl[2][4]*t45 + kl[2][5];
00716         tmp[3][5] = kl[3][3]*t35 + kl[3][4]*t45 + kl[3][5];
00717         tmp[4][5] = kl[4][3]*t35 + kl[4][4]*t45 + kl[4][5];
00718         tmp[5][5] = kl[5][3]*t35 + kl[5][4]*t45 + kl[5][5];
00719     }
00720     else {
00721         tmp[0][5] = kl[0][5];
00722         tmp[1][5] = kl[1][5];
00723         tmp[2][5] = kl[2][5];
00724         tmp[3][5] = kl[3][5];
00725         tmp[4][5] = kl[4][5];
00726         tmp[5][5] = kl[5][5];
00727     }
00728     
00729     // Now compute T'*(kl*T)
00730     kg(0,0) = cosTheta*tmp[0][0] - sinTheta*tmp[1][0];
00731     kg(0,1) = cosTheta*tmp[0][1] - sinTheta*tmp[1][1];
00732     kg(0,2) = cosTheta*tmp[0][2] - sinTheta*tmp[1][2];
00733     kg(0,3) = cosTheta*tmp[0][3] - sinTheta*tmp[1][3];
00734     kg(0,4) = cosTheta*tmp[0][4] - sinTheta*tmp[1][4];
00735     kg(0,5) = cosTheta*tmp[0][5] - sinTheta*tmp[1][5];
00736     
00737     kg(1,0) = sinTheta*tmp[0][0] + cosTheta*tmp[1][0];
00738     kg(1,1) = sinTheta*tmp[0][1] + cosTheta*tmp[1][1];
00739     kg(1,2) = sinTheta*tmp[0][2] + cosTheta*tmp[1][2];
00740     kg(1,3) = sinTheta*tmp[0][3] + cosTheta*tmp[1][3];
00741     kg(1,4) = sinTheta*tmp[0][4] + cosTheta*tmp[1][4];
00742     kg(1,5) = sinTheta*tmp[0][5] + cosTheta*tmp[1][5];
00743     
00744     if (nodeIOffset) {
00745         kg(2,0) = t02*tmp[0][0] + t12*tmp[1][0] + tmp[2][0];
00746         kg(2,1) = t02*tmp[0][1] + t12*tmp[1][1] + tmp[2][1];
00747         kg(2,2) = t02*tmp[0][2] + t12*tmp[1][2] + tmp[2][2];
00748         kg(2,3) = t02*tmp[0][3] + t12*tmp[1][3] + tmp[2][3];
00749         kg(2,4) = t02*tmp[0][4] + t12*tmp[1][4] + tmp[2][4];
00750         kg(2,5) = t02*tmp[0][5] + t12*tmp[1][5] + tmp[2][5];
00751     }
00752     else {
00753         kg(2,0) = tmp[2][0];
00754         kg(2,1) = tmp[2][1];
00755         kg(2,2) = tmp[2][2];
00756         kg(2,3) = tmp[2][3];
00757         kg(2,4) = tmp[2][4];
00758         kg(2,5) = tmp[2][5];
00759     }
00760     
00761     kg(3,0) = cosTheta*tmp[3][0] - sinTheta*tmp[4][0];
00762     kg(3,1) = cosTheta*tmp[3][1] - sinTheta*tmp[4][1];
00763     kg(3,2) = cosTheta*tmp[3][2] - sinTheta*tmp[4][2];
00764     kg(3,3) = cosTheta*tmp[3][3] - sinTheta*tmp[4][3];
00765     kg(3,4) = cosTheta*tmp[3][4] - sinTheta*tmp[4][4];
00766     kg(3,5) = cosTheta*tmp[3][5] - sinTheta*tmp[4][5];
00767     
00768     kg(4,0) = sinTheta*tmp[3][0] + cosTheta*tmp[4][0];
00769     kg(4,1) = sinTheta*tmp[3][1] + cosTheta*tmp[4][1];
00770     kg(4,2) = sinTheta*tmp[3][2] + cosTheta*tmp[4][2];
00771     kg(4,3) = sinTheta*tmp[3][3] + cosTheta*tmp[4][3];
00772     kg(4,4) = sinTheta*tmp[3][4] + cosTheta*tmp[4][4];
00773     kg(4,5) = sinTheta*tmp[3][5] + cosTheta*tmp[4][5];
00774     
00775     if (nodeJOffset) {
00776         kg(5,0) = t35*tmp[3][0] + t45*tmp[4][0] + tmp[5][0];
00777         kg(5,1) = t35*tmp[3][1] + t45*tmp[4][1] + tmp[5][1];
00778         kg(5,2) = t35*tmp[3][2] + t45*tmp[4][2] + tmp[5][2];
00779         kg(5,3) = t35*tmp[3][3] + t45*tmp[4][3] + tmp[5][3];
00780         kg(5,4) = t35*tmp[3][4] + t45*tmp[4][4] + tmp[5][4];
00781         kg(5,5) = t35*tmp[3][5] + t45*tmp[4][5] + tmp[5][5];
00782     }
00783     else {
00784         kg(5,0) = tmp[5][0];
00785         kg(5,1) = tmp[5][1];
00786         kg(5,2) = tmp[5][2];
00787         kg(5,3) = tmp[5][3];
00788         kg(5,4) = tmp[5][4];
00789         kg(5,5) = tmp[5][5];
00790     }
00791     
00792     return kg;
00793 }
00794 
00795 
00796 const Matrix &
00797 PDeltaCrdTransf2d::getInitialGlobalStiffMatrix (const Matrix &kb)
00798 {
00799     static Matrix kg(6,6);
00800     static double tmp [6][6];
00801     
00802     double oneOverL = 1.0/L;
00803     
00804     double kb00, kb01, kb02, kb10, kb11, kb12, kb20, kb21, kb22;
00805     
00806     kb00 = kb(0,0);             kb01 = kb(0,1);         kb02 = kb(0,2);
00807     kb10 = kb(1,0);             kb11 = kb(1,1);         kb12 = kb(1,2);
00808     kb20 = kb(2,0);             kb21 = kb(2,1);         kb22 = kb(2,2);
00809     
00810     double t02 = 0.0;
00811     double t12 = 1.0;
00812     double t22 = 0.0;
00813     
00814     if (nodeIOffset != 0) {
00815         t02 =  cosTheta*nodeIOffset[1] - sinTheta*nodeIOffset[0];
00816         t12 =  oneOverL*(sinTheta*nodeIOffset[1]+cosTheta*nodeIOffset[0]) + 1.0;
00817         t22 =  oneOverL*(sinTheta*nodeIOffset[1]+cosTheta*nodeIOffset[0]);
00818     }
00819     
00820     double t05 = 0.0;
00821     double t15 = 0.0;
00822     double t25 = 1.0;
00823     
00824     if (nodeJOffset != 0) {
00825         t05 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00826         t15 = -oneOverL*(sinTheta*nodeJOffset[1]+cosTheta*nodeJOffset[0]);
00827         t25 = -oneOverL*(sinTheta*nodeJOffset[1]+cosTheta*nodeJOffset[0]) + 1.0;
00828     }
00829     
00830     double sl = sinTheta*oneOverL;
00831     double cl = cosTheta*oneOverL;
00832     
00833     tmp[0][0] = -cosTheta*kb00 - sl*(kb01+kb02);
00834     tmp[0][1] = -sinTheta*kb00 + cl*(kb01+kb02);
00835     tmp[0][2] = (nodeIOffset) ? t02*kb00 + t12*kb01 + t22*kb02 : kb01;
00836     tmp[0][3] = -tmp[0][0];
00837     tmp[0][4] = -tmp[0][1];
00838     tmp[0][5] = (nodeJOffset) ? t05*kb00 + t15*kb01 + t25*kb02 : kb02;
00839     
00840     tmp[1][0] = -cosTheta*kb10 - sl*(kb11+kb12);
00841     tmp[1][1] = -sinTheta*kb10 + cl*(kb11+kb12);
00842     tmp[1][2] = (nodeIOffset) ? t02*kb10 + t12*kb11 + t22*kb12 : kb11;
00843     tmp[1][3] = -tmp[1][0];
00844     tmp[1][4] = -tmp[1][1];
00845     tmp[1][5] = (nodeJOffset) ? t05*kb10 + t15*kb11 + t25*kb12 : kb12;
00846     
00847     tmp[2][0] = -cosTheta*kb20 - sl*(kb21+kb22);
00848     tmp[2][1] = -sinTheta*kb20 + cl*(kb21+kb22);
00849     tmp[2][2] = (nodeIOffset) ? t02*kb20 + t12*kb21 + t22*kb22 : kb21;
00850     tmp[2][3] = -tmp[2][0];
00851     tmp[2][4] = -tmp[2][1];
00852     tmp[2][5] = (nodeJOffset) ? t05*kb20 + t15*kb21 + t25*kb22 : kb22;
00853     
00854     kg(0,0) = -cosTheta*tmp[0][0] - sl*(tmp[1][0]+tmp[2][0]);
00855     kg(0,1) = -cosTheta*tmp[0][1] - sl*(tmp[1][1]+tmp[2][1]);
00856     kg(0,2) = -cosTheta*tmp[0][2] - sl*(tmp[1][2]+tmp[2][2]);
00857     kg(0,3) = -cosTheta*tmp[0][3] - sl*(tmp[1][3]+tmp[2][3]);
00858     kg(0,4) = -cosTheta*tmp[0][4] - sl*(tmp[1][4]+tmp[2][4]);
00859     kg(0,5) = -cosTheta*tmp[0][5] - sl*(tmp[1][5]+tmp[2][5]);
00860     
00861     kg(1,0) = -sinTheta*tmp[0][0] + cl*(tmp[1][0]+tmp[2][0]);
00862     kg(1,1) = -sinTheta*tmp[0][1] + cl*(tmp[1][1]+tmp[2][1]);
00863     kg(1,2) = -sinTheta*tmp[0][2] + cl*(tmp[1][2]+tmp[2][2]);
00864     kg(1,3) = -sinTheta*tmp[0][3] + cl*(tmp[1][3]+tmp[2][3]);
00865     kg(1,4) = -sinTheta*tmp[0][4] + cl*(tmp[1][4]+tmp[2][4]);
00866     kg(1,5) = -sinTheta*tmp[0][5] + cl*(tmp[1][5]+tmp[2][5]);
00867     
00868     if (nodeIOffset) {
00869         kg(2,0) =  t02*tmp[0][0] + t12*tmp[1][0] + t22*tmp[2][0];
00870         kg(2,1) =  t02*tmp[0][1] + t12*tmp[1][1] + t22*tmp[2][1];
00871         kg(2,2) =  t02*tmp[0][2] + t12*tmp[1][2] + t22*tmp[2][2];
00872         kg(2,3) =  t02*tmp[0][3] + t12*tmp[1][3] + t22*tmp[2][3];
00873         kg(2,4) =  t02*tmp[0][4] + t12*tmp[1][4] + t22*tmp[2][4];
00874         kg(2,5) =  t02*tmp[0][5] + t12*tmp[1][5] + t22*tmp[2][5];
00875     }
00876     else {
00877         kg(2,0) = tmp[1][0];
00878         kg(2,1) = tmp[1][1];
00879         kg(2,2) = tmp[1][2];
00880         kg(2,3) = tmp[1][3];
00881         kg(2,4) = tmp[1][4];
00882         kg(2,5) = tmp[1][5];
00883     }
00884     
00885     kg(3,0) = -kg(0,0);
00886     kg(3,1) = -kg(0,1);
00887     kg(3,2) = -kg(0,2);
00888     kg(3,3) = -kg(0,3);
00889     kg(3,4) = -kg(0,4);
00890     kg(3,5) = -kg(0,5);
00891     
00892     kg(4,0) = -kg(1,0);
00893     kg(4,1) = -kg(1,1);
00894     kg(4,2) = -kg(1,2);
00895     kg(4,3) = -kg(1,3);
00896     kg(4,4) = -kg(1,4);
00897     kg(4,5) = -kg(1,5);
00898     
00899     if (nodeJOffset) {
00900         kg(5,0) =  t05*tmp[0][0] + t15*tmp[1][0] + t25*tmp[2][0];
00901         kg(5,1) =  t05*tmp[0][1] + t15*tmp[1][1] + t25*tmp[2][1];
00902         kg(5,2) =  t05*tmp[0][2] + t15*tmp[1][2] + t25*tmp[2][2];
00903         kg(5,3) =  t05*tmp[0][3] + t15*tmp[1][3] + t25*tmp[2][3];
00904         kg(5,4) =  t05*tmp[0][4] + t15*tmp[1][4] + t25*tmp[2][4];
00905         kg(5,5) =  t05*tmp[0][5] + t15*tmp[1][5] + t25*tmp[2][5];
00906     }
00907     else {
00908         kg(5,0) =  tmp[2][0];
00909         kg(5,1) =  tmp[2][1];
00910         kg(5,2) =  tmp[2][2];
00911         kg(5,3) =  tmp[2][3];
00912         kg(5,4) =  tmp[2][4];
00913         kg(5,5) =  tmp[2][5];
00914     }
00915     
00916     return kg;
00917 }
00918 
00919 
00920 CrdTransf2d *
00921 PDeltaCrdTransf2d::getCopy(void)
00922 {
00923     // create a new instance of PDeltaCrdTransf2d 
00924     
00925     PDeltaCrdTransf2d *theCopy;
00926     
00927     Vector offsetI(2);
00928     Vector offsetJ(2);
00929     
00930     if (nodeIOffset != 0) {
00931         offsetI(0) = nodeIOffset[0];
00932         offsetI(1) = nodeIOffset[1];
00933     }
00934     
00935     if (nodeJOffset != 0) {
00936         offsetJ(0) = nodeJOffset[0];
00937         offsetJ(1) = nodeJOffset[1];
00938     }
00939     
00940     theCopy = new PDeltaCrdTransf2d(this->getTag(), offsetI, offsetJ);
00941     
00942     theCopy->nodeIPtr = nodeIPtr;
00943     theCopy->nodeJPtr = nodeJPtr;
00944     theCopy->cosTheta = cosTheta;
00945     theCopy->sinTheta = sinTheta;
00946     theCopy->L = L;
00947     theCopy->ul14 = ul14;
00948     
00949     return theCopy;
00950 }
00951 
00952 
00953 int 
00954 PDeltaCrdTransf2d::sendSelf(int cTag, Channel &theChannel)
00955 {
00956     int res = 0;
00957     
00958     static Vector data(12);
00959     data(0) = this->getTag();
00960     data(1) = L;
00961     if (nodeIOffset != 0) {
00962         data(2) = nodeIOffset[0];
00963         data(3) = nodeIOffset[1];
00964     } else {
00965         data(2) = 0.0;
00966         data(3) = 0.0;
00967     }
00968     
00969     if (nodeJOffset != 0) {
00970         data(4) = nodeJOffset[0];
00971         data(5) = nodeJOffset[1];
00972     } else {
00973         data(4) = 0.0;
00974         data(5) = 0.0;
00975     }
00976     
00977     if (nodeIInitialDisp != 0) {
00978         data(6) = nodeIInitialDisp[0];
00979         data(7) = nodeIInitialDisp[1];
00980         data(8) = nodeIInitialDisp[2];
00981     } else {
00982         data(6) = 0.0;
00983         data(7) = 0.0;
00984         data(8) = 0.0;
00985     }
00986     
00987     if (nodeJInitialDisp != 0) {
00988         data(9) = nodeJInitialDisp[0];
00989         data(10) = nodeJInitialDisp[1];
00990         data(11) = nodeJInitialDisp[2];
00991     } else {
00992         data(9) = 0.0;
00993         data(10) = 0.0;
00994         data(11) = 0.0;
00995     }
00996     
00997     res += theChannel.sendVector(this->getDbTag(), cTag, data);
00998     if (res < 0) {
00999         opserr << "PDeltaCrdTransf2d2d::sendSelf - failed to send Vector\n";
01000         return res;
01001     }
01002     
01003     return res;
01004 }
01005 
01006 
01007 int 
01008 PDeltaCrdTransf2d::recvSelf(int cTag, Channel &theChannel, FEM_ObjectBroker &theBroker)
01009 {
01010     int res = 0;
01011     
01012     static Vector data(12);
01013     
01014     res += theChannel.recvVector(this->getDbTag(), cTag, data);
01015     if (res < 0) {
01016         opserr << "PDeltaCrdTransf2d2d::recvSelf - failed to receive Vector\n";
01017         
01018         return res;
01019     }
01020     
01021     
01022     this->setTag((int)data(0));
01023     L = data(1);
01024     data(0) = this->getTag();
01025     data(1) = L;
01026     
01027     int flag;
01028     int i,j;
01029     
01030     flag = 0;
01031     for (i=2; i<=3; i++)
01032         if (data(i) != 0.0)
01033             flag = 1;
01034         if (flag == 1) {
01035             if (nodeIOffset == 0)
01036                 nodeIOffset = new double[2];
01037             for (i=2, j=0; i<=3; i++, j++)
01038                 nodeIOffset[j] = data(i);
01039         }
01040         
01041         flag = 0;
01042         for (i=4; i<=5; i++)
01043             if (data(i) != 0.0)
01044                 flag = 1;
01045             if (flag == 1) {
01046                 if (nodeJOffset == 0)
01047                     nodeJOffset = new double[2];
01048                 for (i=4, j=0; i<=5; i++, j++)
01049                     nodeJOffset[j] = data(i);
01050             }
01051             
01052             flag = 0;
01053             for (i=6; i<=8; i++)
01054                 if (data(i) != 0.0)
01055                     flag = 1;
01056                 if (flag == 1) {
01057                     if (nodeIInitialDisp == 0)
01058                         nodeIInitialDisp = new double[3];
01059                     for (i=6, j=0; i<=7; i++, j++)
01060                         nodeIInitialDisp[j] = data(i);
01061                 }
01062                 
01063                 flag = 0;
01064                 for (i=9; i<=11; i++)
01065                     if (data(i) != 0.0)
01066                         flag = 1;
01067                     if (flag == 1) {
01068                         if (nodeJInitialDisp == 0)
01069                             nodeJInitialDisp = new double [3];
01070                         for (i=9, j=0; i<=11; i++, j++)
01071                             nodeJInitialDisp[j] = data(i);
01072                     }
01073                     
01074                     initialDispChecked = true;
01075                     
01076                     return res;
01077 }
01078 
01079 
01080 const Vector &
01081 PDeltaCrdTransf2d::getPointGlobalCoordFromLocal(const Vector &xl)
01082 {
01083     static Vector xg(2);
01084     
01085     const Vector &nodeICoords = nodeIPtr->getCrds();
01086     xg(0) = nodeICoords(0);
01087     xg(1) = nodeICoords(1);
01088     
01089     if (nodeIOffset) {
01090         xg(0) += nodeIOffset[0];
01091         xg(1) += nodeIOffset[1];
01092     }
01093     
01094     // xg = xg + Rlj'*xl
01095     xg(0) += cosTheta*xl(0) - sinTheta*xl(1);
01096     xg(1) += sinTheta*xl(0) + cosTheta*xl(1);
01097     
01098     return xg;  
01099 }
01100 
01101 
01102 const Vector &
01103 PDeltaCrdTransf2d::getPointGlobalDisplFromBasic (double xi, const Vector &uxb)
01104 {
01105     // determine global displacements
01106     const Vector &disp1 = nodeIPtr->getTrialDisp();
01107     const Vector &disp2 = nodeJPtr->getTrialDisp();
01108     
01109     static Vector ug(6);
01110     for (int i = 0; i < 3; i++)
01111     {
01112         ug(i)   = disp1(i);
01113         ug(i+3) = disp2(i);
01114     }
01115     
01116     if (nodeIInitialDisp != 0) {
01117         for (int j=0; j<3; j++)
01118             ug[j] -= nodeIInitialDisp[j];
01119     }
01120     
01121     if (nodeJInitialDisp != 0) {
01122         for (int j=0; j<3; j++)
01123             ug[j+3] -= nodeJInitialDisp[j];
01124     }
01125     
01126     // transform global end displacements to local coordinates
01127     static Vector ul(6);      // total displacements
01128     
01129     ul(0) =  cosTheta*ug(0) + sinTheta*ug(1);
01130     ul(1) = -sinTheta*ug(0) + cosTheta*ug(1);
01131     ul(2) =  ug(2);
01132     ul(3) =  cosTheta*ug(3) + sinTheta*ug(4);
01133     ul(4) = -sinTheta*ug(3) + cosTheta*ug(4);
01134     ul(5) =  ug(5);
01135     
01136     if (nodeIOffset != 0) {
01137         double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
01138         double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
01139         
01140         ul(0) += t02*ug(2);
01141         ul(1) += t12*ug(2);
01142     }
01143     
01144     if (nodeJOffset != 0) {
01145         double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
01146         double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
01147         
01148         ul(3) += t35*ug(5);
01149         ul(4) += t45*ug(5);
01150     }
01151     
01152     // compute displacements at point xi, in local coordinates
01153     static Vector uxl(2),  uxg(2);
01154     
01155     uxl(0) = uxb(0) +        ul(0);
01156     uxl(1) = uxb(1) + (1-xi)*ul(1) + xi*ul(4);
01157     
01158     // rotate displacements to global coordinates
01159     // uxg = RljT*uxl
01160     uxg(0) = cosTheta*uxl(0) - sinTheta*uxl(1);
01161     uxg(1) = sinTheta*uxl(0) + cosTheta*uxl(1);
01162     
01163     return uxg;  
01164 }
01165 
01166 
01167 void
01168 PDeltaCrdTransf2d::Print(OPS_Stream &s, int flag)
01169 {
01170     s << "\nCrdTransf: " << this->getTag() << " Type: PDeltaCrdTransf2d";
01171     if (nodeIOffset != 0)
01172         s << "\tnodeI Offset: " << nodeIOffset[0] << ' ' << nodeIOffset[1] << endln;
01173     if (nodeJOffset != 0)
01174         s << "\tnodeJ Offset: " << nodeJOffset[0] << ' ' << nodeJOffset[1] << endln;
01175 }
Generated on Mon Oct 23 15:05:00 2006 for OpenSees by 1.5.0
opensees-support @ berkeley.edu
Supported by the National Science Foundation