My title

00001 /* ****************************************************************** **
00002 **    OpenSees - Open System for Earthquake Engineering Simulation    **
00003 **          Pacific Earthquake Engineering Research Center            **
00004 **                                                                    **
00005 **                                                                    **
00006 ** (C) Copyright 1999, The Regents of the University of California    **
00007 ** All Rights Reserved.                                               **
00008 **                                                                    **
00009 ** Commercial use of this program without express permission of the   **
00010 ** University of California, Berkeley, is strictly prohibited.  See   **
00011 ** file 'COPYRIGHT'  in main directory for information on usage and   **
00012 ** redistribution,  and for a DISCLAIMER OF ALL WARRANTIES.           **
00013 **                                                                    **
00014 ** Developed by:                                                      **
00015 **   Frank McKenna (fmckenna@ce.berkeley.edu)                         **
00016 **   Gregory L. Fenves (fenves@ce.berkeley.edu)                       **
00017 **   Filip C. Filippou (filippou@ce.berkeley.edu)                     **
00018 **                                                                    **
00019 ** ****************************************************************** */
00020                                                                         
00021 // $Revision: 1.2 $
00022 // $Date: 2001/05/30 07:14:37 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/coordTransformation/LinearCrdTransf2d.cpp,v $
00024                                                                         
00025                                                                         
00026 // File: ~/crdTransf/LinearCrdTransf2d.C
00027 //
00028 // Written: Remo Magalhaes de Souza (rmsouza@ce.berkeley.edu)
00029 // Created: 04/2000
00030 // Revision: A
00031 // 
00032 // Modified: May 2001 for matrix-multiply unrolling
00033 //
00034 // Purpose: This file contains the implementation for the 
00035 // LinearCrdTransf2d class. LinearCrdTransf2d is a linear
00036 // transformation for a planar frame between the global 
00037 // and basic coordinate systems
00038 
00039 
00040 #include <Vector.h>
00041 #include <Matrix.h>
00042 #include <Node.h>
00043 #include <Channel.h>
00044 
00045 #include <iomanip.h>
00046 
00047 #include <LinearCrdTransf2d.h>
00048 
00049 // constructor:
00050 LinearCrdTransf2d::LinearCrdTransf2d(int tag):
00051   CrdTransf2d(tag, CRDTR_TAG_LinearCrdTransf2d),
00052   nodeIPtr(0), nodeJPtr(0),
00053   nodeIOffset(0), nodeJOffset(0),
00054   cosTheta(0), sinTheta(0), L(0)
00055 {
00056  // Does nothing
00057 }
00058 
00059 // constructor:
00060 LinearCrdTransf2d::LinearCrdTransf2d(int tag,
00061              const Vector &rigJntOffset1,
00062              const Vector &rigJntOffset2):
00063   CrdTransf2d(tag, CRDTR_TAG_LinearCrdTransf2d),
00064   nodeIPtr(0), nodeJPtr(0),
00065   nodeIOffset(0), nodeJOffset(0),
00066   cosTheta(0), sinTheta(0), L(0)
00067 {
00068  // check rigid joint offset for node I
00069  if (&rigJntOffset1 == 0 || rigJntOffset1.Size() != 2 ) {
00070   cerr << "LinearCrdTransf2d::LinearCrdTransf2d:  Invalid rigid joint offset vector for node I\n";
00071   cerr << "Size must be 2\n";      
00072  }
00073  else {
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   cerr << "LinearCrdTransf2d::LinearCrdTransf2d:  Invalid rigid joint offset vector for node J\n";
00082   cerr << "Size must be 2\n";      
00083  }
00084  else {
00085   nodeJOffset = new double[2];
00086   nodeJOffset[0] = rigJntOffset2(0);
00087   nodeJOffset[1] = rigJntOffset2(1);
00088  }
00089 }
00090 
00091 
00092 
00093  
00094 // constructor:
00095 // invoked by a FEM_ObjectBroker, recvSelf() needs to be invoked on this object.
00096 LinearCrdTransf2d::LinearCrdTransf2d():
00097   CrdTransf2d(0, CRDTR_TAG_LinearCrdTransf2d),
00098   nodeIPtr(0), nodeJPtr(0),
00099   nodeIOffset(0), nodeJOffset(0),
00100   cosTheta(0), sinTheta(0), L(0)
00101 {
00102 
00103 }
00104 
00105 
00106 
00107 // destructor:
00108 LinearCrdTransf2d::~LinearCrdTransf2d() 
00109 {
00110  if (nodeIOffset)
00111   delete [] nodeIOffset;
00112  if (nodeJOffset)
00113   delete [] nodeJOffset;
00114 }
00115 
00116 
00117 int
00118 LinearCrdTransf2d::commitState(void)
00119 {
00120    return 0;
00121 }
00122 
00123 
00124 int
00125 LinearCrdTransf2d::revertToLastCommit(void)
00126 {
00127    return 0;
00128 }
00129 
00130 
00131 int
00132 LinearCrdTransf2d::revertToStart(void)
00133 {
00134    return 0;
00135 }
00136 
00137 
00138 int 
00139 LinearCrdTransf2d::initialize(Node *nodeIPointer, Node *nodeJPointer)
00140 {       
00141    int error;
00142 
00143    nodeIPtr = nodeIPointer;
00144    nodeJPtr = nodeJPointer;
00145 
00146    if ((!nodeIPtr) || (!nodeJPtr))
00147    {
00148       cerr << "\nLinearCrdTransf2d::initialize";
00149       cerr << "\ninvalid pointers to the element nodes\n";
00150       return -1;
00151    }
00152        
00153    // get element length and orientation
00154    if ((error = this->computeElemtLengthAndOrient()))
00155       return error;
00156       
00157    return 0;
00158 }
00159 
00160 
00161 int
00162 LinearCrdTransf2d::update(void)
00163 {       
00164    return 0;
00165 }
00166 
00167 
00168 int 
00169 LinearCrdTransf2d::computeElemtLengthAndOrient()
00170 {
00171    // element projection
00172    static Vector dx(2);
00173 
00174    const Vector &ndICoords = nodeIPtr->getCrds();
00175    const Vector &ndJCoords = nodeJPtr->getCrds();
00176 
00177    if (nodeIOffset == 0) {
00178     dx(0) = ndJCoords(0) - ndICoords(0);
00179     dx(1) = ndJCoords(1) - ndICoords(1);
00180    }
00181    else {
00182     dx(0) = ndJCoords(0) + nodeJOffset[0] - ndICoords(0) - nodeIOffset[0];
00183     dx(1) = ndJCoords(1) + nodeJOffset[1] - ndICoords(1) - nodeIOffset[1];
00184    }
00185    
00186    // calculate the element length
00187    L = dx.Norm();
00188 
00189    if (L == 0.0) 
00190    {
00191       cerr << "\nLinearCrdTransf2d::computeElemtLengthAndOrien: 0 length\n";
00192       return -2;  
00193    }
00194 
00195    // calculate the element local x axis components (direction cossines)
00196    // wrt to the global coordinates 
00197    cosTheta = dx(0)/L;
00198    sinTheta = dx(1)/L;
00199    
00200    return 0;
00201 }
00202 
00203 
00204 
00205 
00206 
00207 double 
00208 LinearCrdTransf2d::getInitialLength(void)
00209 {
00210    return L;
00211 }
00212 
00213 
00214 double 
00215 LinearCrdTransf2d::getDeformedLength(void)
00216 {
00217    return L;
00218 }
00219 
00220 
00221 const Vector &
00222 LinearCrdTransf2d::getBasicTrialDisp (void)
00223 {
00224  // determine global displacements
00225  const Vector &disp1 = nodeIPtr->getTrialDisp();
00226  const Vector &disp2 = nodeJPtr->getTrialDisp();
00227 
00228  static double ug[6];
00229  for (int i = 0; i < 3; i++) {
00230   ug[i]   = disp1(i);
00231   ug[i+3] = disp2(i);
00232  }
00233 
00234  static Vector ub(3);
00235 
00236  double oneOverL = 1.0/L;
00237  double sl = sinTheta*oneOverL;
00238  double cl = cosTheta*oneOverL;
00239 
00240  if (nodeIOffset == 0) {
00241   ub(0) = -cosTheta*ug[0] - sinTheta*ug[1] +
00242    cosTheta*ug[3] + sinTheta*ug[4];
00243 
00244   ub(1) = -sl*ug[0] + cl*ug[1] + ug[2] +
00245    sl*ug[3] - cl*ug[4];
00246 
00247   //ub(2) = -sl*ug[0] + cl*ug[1] +
00248   // sl*ug[3] - cl*ug[4] + ug[5];
00249   ub(2) = ub(1) + ug[5] - ug[2];
00250  }
00251  else {
00252   double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00253   double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00254   double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00255   double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00256 
00257   ub(0) = -cosTheta*ug[0] - sinTheta*ug[1] - t02*ug[2] +
00258    cosTheta*ug[3] + sinTheta*ug[4] + t35*ug[5];
00259 
00260   ub(1) = -sl*ug[0] + cl*ug[1] + (1.0+oneOverL*t12)*ug[2] +
00261    sl*ug[3] - cl*ug[4] - oneOverL*t45*ug[5];
00262 
00263   //ub(2) = -sl*ug[0] + cl*ug[1] + oneOverL*t12*ug[2] +
00264   // sl*ug[3] - cl*ug[4] + (1.0-oneOverL*t45)*ug[5];
00265   ub(2) = ub(1) + ug[5] - ug[2];
00266  }
00267 
00268  return ub;
00269 }
00270 
00271 
00272 const Vector &
00273 LinearCrdTransf2d::getBasicIncrDisp (void)
00274 {
00275  // determine global displacements
00276  const Vector &disp1 = nodeIPtr->getIncrDisp();
00277  const Vector &disp2 = nodeJPtr->getIncrDisp();
00278 
00279  static double dug[6];
00280  for (int i = 0; i < 3; i++) {
00281   dug[i]   = disp1(i);
00282   dug[i+3] = disp2(i);
00283  }
00284 
00285  static Vector dub(3);
00286 
00287  double oneOverL = 1.0/L;
00288  double sl = sinTheta*oneOverL;
00289  double cl = cosTheta*oneOverL;
00290 
00291  if (nodeIOffset == 0) {
00292   dub(0) = -cosTheta*dug[0] - sinTheta*dug[1] +
00293    cosTheta*dug[3] + sinTheta*dug[4];
00294 
00295   dub(1) = -sl*dug[0] + cl*dug[1] + dug[2] +
00296    sl*dug[3] - cl*dug[4];
00297 
00298   //dub(2) = -sl*dug[0] + cl*dug[1] +
00299   // sl*dug[3] - cl*dug[4] + dug[5];
00300   dub(2) = dub(1) + dug[5] - dug[2];
00301  }
00302  else {
00303   double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00304   double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00305   double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00306   double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00307 
00308   dub(0) = -cosTheta*dug[0] - sinTheta*dug[1] - t02*dug[2] +
00309    cosTheta*dug[3] + sinTheta*dug[4] + t35*dug[5];
00310 
00311   dub(1) = -sl*dug[0] + cl*dug[1] + (1.0+oneOverL*t12)*dug[2] +
00312    sl*dug[3] - cl*dug[4] - oneOverL*t45*dug[5];
00313 
00314   //dub(2) = -sl*dug[0] + cl*dug[1] + oneOverL*t12*dug[2] +
00315   // sl*dug[3] - cl*dug[4] + (1.0-oneOverL*t45)*dug[5];
00316   dub(2) = dub(1) + dug[5] - dug[2];
00317  }
00318 
00319  return dub;
00320 }
00321 
00322 
00323 const Vector &
00324 LinearCrdTransf2d::getBasicIncrDeltaDisp(void)
00325 {
00326  // determine global displacements
00327  const Vector &disp1 = nodeIPtr->getIncrDeltaDisp();
00328  const Vector &disp2 = nodeJPtr->getIncrDeltaDisp();
00329 
00330  static double Dug[6];
00331  for (int i = 0; i < 3; i++) {
00332   Dug[i]   = disp1(i);
00333   Dug[i+3] = disp2(i);
00334  }
00335 
00336  static Vector Dub(3);
00337 
00338  double oneOverL = 1.0/L;
00339  double sl = sinTheta*oneOverL;
00340  double cl = cosTheta*oneOverL;
00341 
00342  if (nodeIOffset == 0) {
00343   Dub(0) = -cosTheta*Dug[0] - sinTheta*Dug[1] +
00344    cosTheta*Dug[3] + sinTheta*Dug[4];
00345 
00346   Dub(1) = -sl*Dug[0] + cl*Dug[1] + Dug[2] +
00347    sl*Dug[3] - cl*Dug[4];
00348 
00349   //Dub(2) = -sl*Dug[0] + cl*Dug[1] +
00350   // sl*Dug[3] - cl*Dug[4] + Dug[5];
00351   Dub(2) = Dub(1) + Dug[5] - Dug[2];
00352  }
00353  else {
00354   double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00355   double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00356   double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00357   double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00358 
00359   Dub(0) = -cosTheta*Dug[0] - sinTheta*Dug[1] - t02*Dug[2] +
00360    cosTheta*Dug[3] + sinTheta*Dug[4] + t35*Dug[5];
00361 
00362   Dub(1) = -sl*Dug[0] + cl*Dug[1] + (1.0+oneOverL*t12)*Dug[2] +
00363    sl*Dug[3] - cl*Dug[4] - oneOverL*t45*Dug[5];
00364 
00365   //Dub(2) = -sl*Dug[0] + cl*Dug[1] + oneOverL*t12*Dug[2] +
00366   // sl*Dug[3] - cl*Dug[4] + (1.0-oneOverL*t45)*Dug[5];
00367   Dub(2) = Dub(1) + Dug[5] - Dug[2];
00368  }
00369 
00370  return Dub;
00371 }
00372 
00373 
00374 const Vector &
00375 LinearCrdTransf2d::getGlobalResistingForce(const Vector &pb, const Vector &unifLoad)
00376 {
00377  // transform resisting forces from the basic system to local coordinates
00378  static double pl[6];
00379 
00380  double q0 = pb(0);
00381  double q1 = pb(1);
00382  double q2 = pb(2);
00383 
00384  double oneOverL = 1.0/L;
00385 
00386  pl[0] = -q0;
00387  pl[1] =  oneOverL*(q1+q2);
00388  pl[2] =  q1;
00389  pl[3] =  q0;
00390  //pl[4] = -oneOverL*(q1+q2);
00391  pl[4] = -pl[1];
00392  pl[5] =  q2;
00393 
00394  // add end forces due to uniform distributed
00395  // loads to the system with rigid body modes
00396  pl[0] -= unifLoad(0)*L;
00397  double V = 0.5*unifLoad(1)*L;
00398  pl[1] -= V;
00399  pl[4] -= V;
00400      
00401  // transform resisting forces  from local to global coordinates
00402  static Vector pg(6);
00403 
00404  pg(0) = cosTheta*pl[0] - sinTheta*pl[1];
00405  pg(1) = sinTheta*pl[0] + cosTheta*pl[1];
00406    
00407  pg(3) = cosTheta*pl[3] - sinTheta*pl[4];
00408  pg(4) = sinTheta*pl[3] + cosTheta*pl[4];
00409  
00410  if (nodeIOffset == 0) {
00411   pg(2) = pl[2];
00412   pg(5) = pl[5];
00413  }
00414  else {
00415   double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00416   double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00417   double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00418   double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00419 
00420   pg(2) = t02*pl[0] + t12*pl[1] + pl[2];
00421   pg(5) = t35*pl[3] + t45*pl[4] + pl[5];
00422  }
00423 
00424  return pg;
00425 }
00426 
00427 const Matrix &
00428 LinearCrdTransf2d::getGlobalStiffMatrix (const Matrix &kb, const Vector &pb)
00429 {
00430  static Matrix kg(6,6);
00431  static double tmp [6][6];
00432  static double tmp2[6][6];
00433 
00434  double oneOverL = 1.0/L;
00435 
00436  double kb00, kb01, kb02, kb10, kb11, kb12, kb20, kb21, kb22;
00437 
00438  kb00 = kb(0,0);  kb01 = kb(0,1);  kb02 = kb(0,2);
00439  kb10 = kb(1,0);  kb11 = kb(1,1);  kb12 = kb(1,2);
00440  kb20 = kb(2,0);  kb21 = kb(2,1);  kb22 = kb(2,2);
00441 
00442  double t02 = 0.0;
00443  double t12 = 1.0;
00444  double t22 = 0.0;
00445 
00446  if (nodeIOffset != 0) {
00447   t02 =  cosTheta*nodeIOffset[1] - sinTheta*nodeIOffset[0];
00448   t12 =  oneOverL*(sinTheta*nodeIOffset[1]+cosTheta*nodeIOffset[0]) + 1.0;
00449   t22 =  oneOverL*(sinTheta*nodeIOffset[1]+cosTheta*nodeIOffset[0]);
00450  }
00451 
00452  double t05 = 0.0;
00453  double t15 = 0.0;
00454  double t25 = 1.0;
00455 
00456  if (nodeJOffset != 0) {
00457   t05 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00458   t15 = -oneOverL*(sinTheta*nodeJOffset[1]+cosTheta*nodeJOffset[0]);
00459   t25 = -oneOverL*(sinTheta*nodeJOffset[1]+cosTheta*nodeJOffset[0]) + 1.0;
00460  }
00461 
00462  double sl = sinTheta*oneOverL;
00463  double cl = cosTheta*oneOverL;
00464 
00465  tmp[0][0] = -cosTheta*kb00 - sl*(kb01+kb02);
00466  tmp[0][1] = -sinTheta*kb00 + cl*(kb01+kb02);
00467  tmp[0][2] = (nodeIOffset) ? t02*kb00 + t12*kb01 + t22*kb02 : kb01;
00468  tmp[0][3] = -tmp[0][0];
00469  tmp[0][4] = -tmp[0][1];
00470  tmp[0][5] = (nodeJOffset) ? t05*kb00 + t15*kb01 + t25*kb02 : kb02;
00471  
00472  tmp[1][0] = -cosTheta*kb10 - sl*(kb11+kb12);
00473  tmp[1][1] = -sinTheta*kb10 + cl*(kb11+kb12);
00474  tmp[1][2] = (nodeIOffset) ? t02*kb10 + t12*kb11 + t22*kb12 : kb11;
00475  tmp[1][3] = -tmp[1][0];
00476  tmp[1][4] = -tmp[1][1];
00477  tmp[1][5] = (nodeJOffset) ? t05*kb10 + t15*kb11 + t25*kb12 : kb12;
00478 
00479  tmp[2][0] = -cosTheta*kb20 - sl*(kb21+kb22);
00480  tmp[2][1] = -sinTheta*kb20 + cl*(kb21+kb22);
00481  tmp[2][2] = (nodeIOffset) ? t02*kb20 + t12*kb21 + t22*kb22 : kb21;
00482  tmp[2][3] = -tmp[2][0];
00483  tmp[2][4] = -tmp[2][1];
00484  tmp[2][5] = (nodeJOffset) ? t05*kb20 + t15*kb21 + t25*kb22 : kb22;
00485 
00486  kg(0,0) = -cosTheta*tmp[0][0] - sl*(tmp[1][0]+tmp[2][0]);
00487  kg(0,1) = -cosTheta*tmp[0][1] - sl*(tmp[1][1]+tmp[2][1]);
00488  kg(0,2) = -cosTheta*tmp[0][2] - sl*(tmp[1][2]+tmp[2][2]);
00489  kg(0,3) = -cosTheta*tmp[0][3] - sl*(tmp[1][3]+tmp[2][3]);
00490  kg(0,4) = -cosTheta*tmp[0][4] - sl*(tmp[1][4]+tmp[2][4]);
00491  kg(0,5) = -cosTheta*tmp[0][5] - sl*(tmp[1][5]+tmp[2][5]);
00492 
00493  kg(1,0) = -sinTheta*tmp[0][0] + cl*(tmp[1][0]+tmp[2][0]);
00494  kg(1,1) = -sinTheta*tmp[0][1] + cl*(tmp[1][1]+tmp[2][1]);
00495  kg(1,2) = -sinTheta*tmp[0][2] + cl*(tmp[1][2]+tmp[2][2]);
00496  kg(1,3) = -sinTheta*tmp[0][3] + cl*(tmp[1][3]+tmp[2][3]);
00497  kg(1,4) = -sinTheta*tmp[0][4] + cl*(tmp[1][4]+tmp[2][4]);
00498  kg(1,5) = -sinTheta*tmp[0][5] + cl*(tmp[1][5]+tmp[2][5]);
00499 
00500  if (nodeIOffset) {
00501   kg(2,0) =  t02*tmp[0][0] + t12*tmp[1][0] + t22*tmp[2][0];
00502   kg(2,1) =  t02*tmp[0][1] + t12*tmp[1][1] + t22*tmp[2][1];
00503   kg(2,2) =  t02*tmp[0][2] + t12*tmp[1][2] + t22*tmp[2][2];
00504   kg(2,3) =  t02*tmp[0][3] + t12*tmp[1][3] + t22*tmp[2][3];
00505   kg(2,4) =  t02*tmp[0][4] + t12*tmp[1][4] + t22*tmp[2][4];
00506   kg(2,5) =  t02*tmp[0][5] + t12*tmp[1][5] + t22*tmp[2][5];
00507  }
00508  else {
00509   kg(2,0) = tmp[1][0];
00510   kg(2,1) = tmp[1][1];
00511   kg(2,2) = tmp[1][2];
00512   kg(2,3) = tmp[1][3];
00513   kg(2,4) = tmp[1][4];
00514   kg(2,5) = tmp[1][5];
00515  }
00516 
00517  kg(3,0) = -kg(0,0);
00518  kg(3,1) = -kg(0,1);
00519  kg(3,2) = -kg(0,2);
00520  kg(3,3) = -kg(0,3);
00521  kg(3,4) = -kg(0,4);
00522  kg(3,5) = -kg(0,5);
00523 
00524  kg(4,0) = -kg(1,0);
00525  kg(4,1) = -kg(1,1);
00526  kg(4,2) = -kg(1,2);
00527  kg(4,3) = -kg(1,3);
00528  kg(4,4) = -kg(1,4);
00529  kg(4,5) = -kg(1,5);
00530 
00531  if (nodeJOffset) {
00532   kg(5,0) =  t05*tmp[0][0] + t15*tmp[1][0] + t25*tmp[2][0];
00533   kg(5,1) =  t05*tmp[0][1] + t15*tmp[1][1] + t25*tmp[2][1];
00534   kg(5,2) =  t05*tmp[0][2] + t15*tmp[1][2] + t25*tmp[2][2];
00535   kg(5,3) =  t05*tmp[0][3] + t15*tmp[1][3] + t25*tmp[2][3];
00536   kg(5,4) =  t05*tmp[0][4] + t15*tmp[1][4] + t25*tmp[2][4];
00537   kg(5,5) =  t05*tmp[0][5] + t15*tmp[1][5] + t25*tmp[2][5];
00538  }
00539  else {
00540   kg(5,0) =  tmp[2][0];
00541   kg(5,1) =  tmp[2][1];
00542   kg(5,2) =  tmp[2][2];
00543   kg(5,3) =  tmp[2][3];
00544   kg(5,4) =  tmp[2][4];
00545   kg(5,5) =  tmp[2][5];
00546  }
00547  
00548  return kg;
00549 }
00550   
00551 
00552 
00553 
00554 CrdTransf2d *
00555 LinearCrdTransf2d::getCopy(void)
00556 {
00557   // create a new instance of LinearCrdTransf2d 
00558 
00559   LinearCrdTransf2d *theCopy;
00560 
00561   if (nodeIOffset) {
00562    Vector offsetI(nodeIOffset, 2);
00563    Vector offsetJ(nodeJOffset, 2);
00564 
00565    theCopy = new LinearCrdTransf2d(this->getTag(), offsetI, offsetJ);
00566   }
00567   else
00568    theCopy = new LinearCrdTransf2d(this->getTag());
00569 
00570   theCopy->nodeIPtr = nodeIPtr;
00571   theCopy->nodeJPtr = nodeJPtr;
00572   theCopy->cosTheta = cosTheta;
00573   theCopy->sinTheta = sinTheta;
00574   theCopy->L = L;
00575   
00576   return theCopy;
00577 }
00578 
00579 
00580 int 
00581 LinearCrdTransf2d::sendSelf(int cTag, Channel &theChannel)
00582 {
00583  int res = 0;
00584 
00585  static Vector data(9);
00586 
00587  data(0) = this->getTag();
00588  data(6) = L;
00589  data(7) = cosTheta;
00590  data(8) = sinTheta;
00591 
00592  res += theChannel.sendVector(this->getDbTag(), cTag, data);
00593  if (res < 0) {
00594   g3ErrorHandler->warning("%s - failed to send Vector",
00595    "LinearCrdTransf2d::sendSelf");
00596   return res;
00597  }
00598 
00599     return res;
00600 }
00601 
00602     
00603 
00604 int 
00605 LinearCrdTransf2d::recvSelf(int cTag, Channel &theChannel, FEM_ObjectBroker &theBroker)
00606 {
00607  int res = 0;
00608 
00609  static Vector data(9);
00610 
00611  res += theChannel.recvVector(this->getDbTag(), cTag, data);
00612  if (res < 0) {
00613   g3ErrorHandler->warning("%s - failed to receive Vector",
00614    "LinearCrdTransf2d::recvSelf");
00615   return res;
00616  }
00617 
00618  this->setTag((int)data(0));
00619  L = data(6);
00620  cosTheta = data(7);
00621  sinTheta = data(8);
00622 
00623     return res;
00624 }
00625   
00626 
00627 const Vector &
00628 LinearCrdTransf2d::getPointGlobalCoordFromLocal(const Vector &xl)
00629 {
00630    static Vector xg(2);
00631 
00632    const Vector &nodeICoords = nodeIPtr->getCrds();
00633    xg(0) = nodeICoords(0);
00634    xg(1) = nodeICoords(1);
00635 
00636    if (nodeIOffset) {
00637     xg(0) += nodeIOffset[0];
00638     xg(1) += nodeIOffset[1];
00639    }
00640 
00641    // xg = xg + Rlj'*xl
00642    xg(0) += cosTheta*xl(0) - sinTheta*xl(1);
00643    xg(1) += sinTheta*xl(0) + cosTheta*xl(1);
00644      
00645    return xg;  
00646 }
00647 
00648     
00649 const Vector &
00650 LinearCrdTransf2d::getPointGlobalDisplFromBasic (double xi, const Vector &uxb)
00651 {
00652    // determine global displacements
00653    const Vector &disp1 = nodeIPtr->getTrialDisp();
00654    const Vector &disp2 = nodeJPtr->getTrialDisp();
00655 
00656    static Vector ug(6);
00657    for (int i = 0; i < 3; i++)
00658    {
00659       ug(i)   = disp1(i);
00660       ug(i+3) = disp2(i);
00661    }
00662 
00663    // transform global end displacements to local coordinates
00664    static Vector ul(6);      // total displacements
00665 
00666  ul(0) =  cosTheta*ug(0) + sinTheta*ug(1);
00667  ul(1) = -sinTheta*ug(0) + cosTheta*ug(1);
00668  ul(2) =  ug(2);
00669  ul(3) =  cosTheta*ug(3) + sinTheta*ug(4);
00670  ul(4) = -sinTheta*ug(3) + cosTheta*ug(4);
00671  ul(5) =  ug(5);
00672 
00673     if (nodeIOffset != 0) {
00674   double t02 = -cosTheta*nodeIOffset[1] + sinTheta*nodeIOffset[0];
00675   double t12 =  sinTheta*nodeIOffset[1] + cosTheta*nodeIOffset[0];
00676   double t35 = -cosTheta*nodeJOffset[1] + sinTheta*nodeJOffset[0];
00677   double t45 =  sinTheta*nodeJOffset[1] + cosTheta*nodeJOffset[0];
00678 
00679   ul(0) += t02*ug(2);
00680   ul(1) += t12*ug(2);
00681   ul(3) += t35*ug(5);
00682   ul(4) += t45*ug(5);
00683  }
00684 
00685  // compute displacements at point xi, in local coordinates
00686    static Vector uxl(2),  uxg(2);
00687 
00688    uxl(0) = uxb(0) +        ul(0);
00689    uxl(1) = uxb(1) + (1-xi)*ul(1) + xi*ul(4);
00690 
00691    // rotate displacements to global coordinates
00692    // uxg = RljT*uxl
00693    uxg(0) = cosTheta*uxl(0) - sinTheta*uxl(1);
00694    uxg(1) = sinTheta*uxl(0) + cosTheta*uxl(1);
00695      
00696    return uxg;  
00697 }
00698 
00699 
00700 
00701 
00702 void
00703 LinearCrdTransf2d::Print(ostream &s, int flag)
00704 {
00705    s << "\nCrdTransf: " << this->getTag() << " Type: LinearCrdTransf2d";
00706    s << "\tnodeI Offset: " << nodeIOffset;
00707    s << "\tnodeJ Offset: " << nodeJOffset;
00708 }
00709 
00710 
00711 
00712 
00713 
00714 
00715 
00716