//! @brief Return initial stiffness matrix.
const XC::Matrix &XC::CorotTruss::getInitialStiff(void) const
{
static Matrix kl(3,3);
if(A<1e-8)
std::clog << getClassName() << "::" << __FUNCTION__
<< "; WARNING area of element: " << getTag()
<< " is extremely small: " << A << std::endl;
// Material stiffness
kl.Zero();
kl(0,0)= A*theMaterial->getInitialTangent() / Lo;
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for(int i = 0; i < getNumDIM(); i++)
{
for(int j = 0; j < getNumDIM(); j++)
{
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
if(isDead())
(*theMatrix)*=dead_srf;
return *theMatrix;
}
const Matrix& ActuatorCorot::getInitialStiff(void)
{
// zero the matrix
theMatrix->Zero();
// local stiffness matrix
static Matrix kl(3,3);
// material stiffness portion
kl.Zero();
kl(0,0) = EA/L;
// compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
// copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (int i=0; i<numDIM; i++) {
for (int j=0; j<numDIM; j++) {
(*theMatrix)(i,j) = kg(i,j);
(*theMatrix)(i,j+numDOF2) = -kg(i,j);
(*theMatrix)(i+numDOF2,j) = -kg(i,j);
(*theMatrix)(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
const Matrix&
Timoshenko2d::getInitialBasicStiff()
{
static Matrix kb(3,3);
// Zero for integration
kb.Zero();
double L = crdTransf->getInitialLength();
const Vector &v = crdTransf->getBasicTrialDisp();
double oneOverL = 1.0/L;
double pts[maxNumSections];
beamInt->getSectionLocations(numSections, L, pts);
double wts[maxNumSections];
beamInt->getSectionWeights(numSections, L, wts);
// Loop over the integration points
for (int i = 0; i<numSections; i++) {
int order = theSections[i]->getOrder();
const ID &code = theSections[i]->getType();
// Get the section tangent stiffness and stress resultant
const Matrix &ks = theSections[i]->getInitialTangent();
// Perform numerical integration
bd[i] = this->getBd(i, v, L);
kb.addMatrixTripleProduct(1.0, bd[i], ks, L*wts[i]);
}
return kb;
}
const Matrix& ElastomericBearingBoucWen2d::getDamp()
{
// zero the matrix
theMatrix.Zero();
// call base class to setup Rayleigh damping
double factThis = 0.0;
if (addRayleigh == 1) {
theMatrix = this->Element::getDamp();
factThis = 1.0;
}
// now add damping tangent from materials
static Matrix cb(3,3);
cb.Zero();
cb(0,0) = theMaterials[0]->getDampTangent();
cb(2,2) = theMaterials[1]->getDampTangent();
// transform from basic to local system
static Matrix cl(6,6);
cl.addMatrixTripleProduct(0.0, Tlb, cb, 1.0);
// transform from local to global system and add to cg
theMatrix.addMatrixTripleProduct(factThis, Tgl, cl, 1.0);
return theMatrix;
}
const Matrix& ElastomericBearingBoucWen2d::getTangentStiff()
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix kl(6,6);
kl.addMatrixTripleProduct(0.0, Tlb, kb, 1.0);
// add geometric stiffness to local stiffness
double kGeo1 = 0.5*qb(0);
kl(2,1) -= kGeo1;
kl(2,4) += kGeo1;
kl(5,1) -= kGeo1;
kl(5,4) += kGeo1;
double kGeo2 = kGeo1*shearDistI*L;
kl(2,2) += kGeo2;
kl(5,2) -= kGeo2;
double kGeo3 = kGeo1*(1.0 - shearDistI)*L;
kl(2,5) -= kGeo3;
kl(5,5) += kGeo3;
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, kl, 1.0);
return theMatrix;
}
int EEBearing3d::setInitialStiff(const Matrix& kbinit)
{
// set initial stiffness matrix in basic system
if (kbinit.noRows() != 2 || kbinit.noCols() != 2) {
opserr << "EEBearing3d::setInitialStiff() - "
<< "matrix size is incorrect for element: "
<< this->getTag() << ".\n";
return OF_ReturnType_failed;
}
kbInit(0,0) = theMaterials[0]->getInitialTangent();
kbInit(1,1) = kbinit(0,0); kbInit(1,2) = kbinit(0,1);
kbInit(2,1) = kbinit(1,0); kbInit(2,2) = kbinit(1,1);
kbInit(3,3) = theMaterials[1]->getInitialTangent();
kbInit(4,4) = theMaterials[2]->getInitialTangent();
kbInit(5,5) = theMaterials[3]->getInitialTangent();
// zero the global matrix
theInitStiff.Zero();
// transform from basic to local system
static Matrix klInit(12,12);
klInit.addMatrixTripleProduct(0.0, Tlb, kbInit, 1.0);
// transform from local to global system
theInitStiff.addMatrixTripleProduct(0.0, Tgl, klInit, 1.0);
return OF_ReturnType_completed;
}
int EETrussCorot::setInitialStiff(const Matrix& kbinit)
{
if (kbinit.noRows() != 1 || kbinit.noCols() != 1) {
opserr << "EETrussCorot::setInitialStiff(): "
<< "matrix size is incorrect for element: "
<< this->getTag() << endln;
return -1;
}
kbInit = kbinit;
// transform the stiffness from the basic to the local system
static Matrix kl(3,3);
kl.Zero();
kl(0,0) = kbInit(0,0);
// transform the stiffness from the local to the global system
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
// copy stiffness into appropriate blocks in element stiffness
theInitStiff.Zero();
int numDOF2 = numDOF/2;
for (int i=0; i<numDIM; i++) {
for (int j=0; j<numDIM; j++) {
theInitStiff(i,j) = kg(i,j);
theInitStiff(i,j+numDOF2) = -kg(i,j);
theInitStiff(i+numDOF2,j) = -kg(i,j);
theInitStiff(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return 0;
}
const Matrix &
CorotTruss::getInitialStiff(void)
{
static Matrix kl(3,3);
// Material stiffness
kl.Zero();
kl(0,0) = A * theMaterial->getInitialTangent() / Lo;
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (int i = 0; i < numDIM; i++) {
for (int j = 0; j < numDIM; j++) {
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
//! @brief Return tangent stiffness matrix.
const XC::Matrix &XC::CorotTruss::getTangentStiff(void) const
{
static Matrix kl(3,3);
// Material stiffness
//
// Get material tangent
if(A<1e-8)
std::clog << getClassName() << "::" << __FUNCTION__
<< "; WARNING area of element: " << getTag()
<< " is extremely small: " << A << std::endl;
double EA = A*theMaterial->getTangent();
EA/= (Ln * Ln * Lo);
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
kl(i,j) = EA*d21[i]*d21[j];
// Geometric stiffness
//
// Get material stress
const double q = A*theMaterial->getStress();
const double SA = q/(Ln*Ln*Ln);
const double SL = q/Ln;
for(int i = 0; i < 3; i++)
{
kl(i,i) += SL;
for(int j = 0; j < 3; j++)
kl(i,j) -= SA*d21[i]*d21[j];
}
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for(int i = 0; i < getNumDIM(); i++)
{
for(int j = 0; j < getNumDIM(); j++)
{
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
if(isDead())
(*theMatrix)*=dead_srf;
return *theMatrix;
}
const Matrix&
NineFourNodeQuadUP::getTangentStiff()
{
int i, j, j2, j2m1, ik, ib, jk, jb;
static Matrix B(3,nenu*2);
static Matrix BTDB(nenu*2,nenu*2);
B.Zero();
BTDB.Zero();
K.Zero();
// Determine Jacobian for this integration point
this->globalShapeFunction(dvolu, wu, nintu, nenu, 0);
// Loop over the integration points
for (i = 0; i < nintu; i++) {
// Get the material tangent
const Matrix &D = theMaterial[i]->getTangent();
for (j=0; j<nenu; j++) {
j2 = j*2+1;
j2m1 = j*2;
B(0,j2m1) = shgu[0][j][i];
B(0,j2) = 0.;
B(1,j2m1) = 0.;
B(1,j2) = shgu[1][j][i];
B(2,j2m1) = shgu[1][j][i];
B(2,j2) = shgu[0][j][i];
}
// Perform numerical integration
//K = K + (B^ D * B) * intWt(i)*intWt(j) * detJ;
BTDB.addMatrixTripleProduct(1.0, B, D, dvolu[i]);
}
for (i = 0; i < nenu; i++) {
if (i<nenp) ik = i*3;
if (i>=nenp) ik = nenp*3 + (i-nenp)*2;
ib = i*2;
for (j = 0; j < nenu; j++) {
if (j<nenp) jk = j*3;
if (j>=nenp) jk = nenp*3 + (j-nenp)*2;
jb = j*2;
K(ik,jk) += BTDB(ib,jb);
K(ik+1,jk) += BTDB(ib+1,jb);
K(ik,jk+1) += BTDB(ib,jb+1);
K(ik+1,jk+1) += BTDB(ib+1,jb+1);
}
}
return K;
}
const Matrix& SingleFPSimple2d::getInitialStiff(void)
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix kl(6,6);
kl.addMatrixTripleProduct(0.0, Tlb, kbInit, 1.0);
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, kl, 1.0);
return theMatrix;
}
const Matrix& ElastomericBearingBoucWen2d::getInitialStiff()
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix klInit(6,6);
klInit.addMatrixTripleProduct(0.0, Tlb, kbInit, 1.0);
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, klInit, 1.0);
return theMatrix;
}
const Matrix &
CorotTruss::getTangentStiff(void)
{
static Matrix kl(3,3);
// Material stiffness
//
// Get material tangent
double EA = A*theMaterial->getTangent();
EA /= (Ln * Ln * Lo);
int i,j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
kl(i,j) = EA*d21[i]*d21[j];
// Geometric stiffness
//
// Get material stress
double q = A*theMaterial->getStress();
double SA = q/(Ln*Ln*Ln);
double SL = q/Ln;
for (i = 0; i < 3; i++) {
kl(i,i) += SL;
for (j = 0; j < 3; j++)
kl(i,j) -= SA*d21[i]*d21[j];
}
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (i = 0; i < numDIM; i++) {
for (j = 0; j < numDIM; j++) {
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
const Matrix& YamamotoBiaxialHDR::getInitialStiff()
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix localStiff(12,12);
localStiff.addMatrixTripleProduct(0.0, Tlb, basicStiffInit, 1.0);
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, localStiff, 1.0);
return theMatrix;
}
const Matrix& LeadRubberX::getInitialStiff()
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix kl(12,12);
kl.addMatrixTripleProduct(0.0, Tlb, kbInit, 1.0);
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, kl, 1.0);
return theMatrix;
}
const Matrix &
CorotTrussSection::getInitialStiff(void)
{
static Matrix kl(3,3);
// Material stiffness
//
// Get material tangent
int order = theSection->getOrder();
const ID &code = theSection->getType();
const Matrix &ks = theSection->getInitialTangent();
double EA = 0.0;
int i,j;
for (i = 0; i < order; i++) {
if (code(i) == SECTION_RESPONSE_P) {
EA += ks(i,i);
}
}
kl(0,0) = EA / Lo;
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (i = 0; i < numDIM; i++) {
for (j = 0; j < numDIM; j++) {
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
const Matrix&
Timoshenko2d::getTangentStiff(void)
{
static Matrix kb(3,3);
// Zero for integration
kb.Zero();
q.Zero();
double L = crdTransf->getInitialLength();
const Vector &v = crdTransf->getBasicTrialDisp();
double oneOverL = 1.0/L;
double pts[maxNumSections];
beamInt->getSectionLocations(numSections, L, pts);
double wts[maxNumSections];
beamInt->getSectionWeights(numSections, L, wts);
// Loop over the integration points
for (int i = 0; i<numSections; i++) {
int order = theSections[i]->getOrder(); // P M V
const ID &code = theSections[i]->getType();
// Get the section tangent stiffness and stress resultant
const Matrix &ks = theSections[i]->getSectionTangent();
const Vector &s = theSections[i]->getStressResultant();
// Perform numerical integration
bd[i] = this->getBd(i, v, L);
kb.addMatrixTripleProduct(1.0, bd[i], ks, L*wts[i]);
q.addMatrixTransposeVector(1.0, bd[i], s, L*wts[i]);
}
// Add effects of element loads, q = q(v) + q0
q(0) += q0[0];
q(1) += q0[1];
q(2) += q0[2];
// Transform to global stiffness
K = crdTransf->getGlobalStiffMatrix(kb, q);
return K;
}
const Matrix& ActuatorCorot::getTangentStiff(void)
{
// zero the matrix
theMatrix->Zero();
// local stiffness matrix
static Matrix kl(3,3);
// material stiffness portion
int i,j;
double EAoverL3 = EA/(Ln*Ln*L);
for (i=0; i<3; i++)
for (j=0; j<3; j++)
kl(i,j) = EAoverL3*d21[i]*d21[j];
// geometric stiffness portion
q(0) = EA/L*(db(0) - (*ctrlDisp)(0));
double SL = q(0)/Ln;
double SA = q(0)/(Ln*Ln*Ln);
for (i=0; i<3; i++) {
kl(i,i) += SL;
for (j=0; j<3; j++)
kl(i,j) -= SA*d21[i]*d21[j];
}
// compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
// copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (i=0; i<numDIM; i++) {
for (j=0; j<numDIM; j++) {
(*theMatrix)(i,j) = kg(i,j);
(*theMatrix)(i,j+numDOF2) = -kg(i,j);
(*theMatrix)(i+numDOF2,j) = -kg(i,j);
(*theMatrix)(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
const Matrix& SingleFPSimple2d::getTangentStiff(void)
{
// zero the matrix
theMatrix.Zero();
// transform from basic to local system
static Matrix kl(6,6);
kl.addMatrixTripleProduct(0.0, Tlb, kb, 1.0);
// add geometric stiffness to local stiffness
double kGeo = qb(0)*(1.0 - shearDistI)*L;
kl(2,1) -= qb(0);
kl(2,4) += qb(0);
kl(2,5) -= kGeo;
kl(5,5) += kGeo;
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, kl, 1.0);
return theMatrix;
}
const Matrix& LeadRubberX::getDamp()
{
// zero the matrix
theMatrix.Zero();
// call base class to setup Rayleigh damping
theMatrix = this->Element::getDamp();
double factThis = 0.0;
// now add damping tangent from materials
static Matrix cb(6,6);
cb.Zero();
// transform from basic to local system
static Matrix cl(12,12);
cl.addMatrixTripleProduct(0.0, Tlb, cb, 1.0);
// transform from local to global system and add to cg
theMatrix.addMatrixTripleProduct(factThis, Tgl, cl, 1.0);
return theMatrix;
}
const Matrix& EETrussCorot::getTangentStiff()
{
// zero the global matrix
theMatrix->Zero();
if (firstWarning == true) {
opserr << "\nWARNING EETrussCorot::getTangentStiff() - "
<< "Element: " << this->getTag() << endln
<< "TangentStiff cannot be calculated." << endln
<< "Return InitialStiff including GeometricStiff instead."
<< endln;
opserr << "Subsequent getTangentStiff warnings will be suppressed."
<< endln;
firstWarning = false;
}
// get daq resisting forces
if (theSite != 0) {
(*qDaq) = theSite->getForce();
}
else {
sData[0] = OF_RemoteTest_getForce;
theChannel->sendVector(0, 0, *sendData, 0);
theChannel->recvVector(0, 0, *recvData, 0);
}
// apply optional initial stiffness modification
if (iMod == true) {
// get daq displacements
if (theSite != 0) {
(*dbDaq) = theSite->getDisp();
}
else {
sData[0] = OF_RemoteTest_getDisp;
theChannel->sendVector(0, 0, *sendData, 0);
theChannel->recvVector(0, 0, *recvData, 0);
}
// correct for displacement control errors using I-Modification
qDaq->addMatrixVector(1.0, kbInit, (*dbDaq) - (*db), -1.0);
}
// transform the stiffness from the basic to the local system
int i,j;
static Matrix kl(3,3);
double EAoverL3 = kbInit(0,0)/(Ln*Ln);
for (i=0; i<3; i++)
for (j=0; j<3; j++)
kl(i,j) = EAoverL3*d21[i]*d21[j];
// add geometric stiffness portion
double SL = (*qDaq)(0)/Ln;
double SA = (*qDaq)(0)/(Ln*Ln*Ln);
for (i=0; i<3; i++) {
kl(i,i) += SL;
for (j=0; j<3; j++)
kl(i,j) -= SA*d21[i]*d21[j];
}
// transform the stiffness from the local to the global system
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
// copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (i=0; i<numDIM; i++) {
for (j=0; j<numDIM; j++) {
(*theMatrix)(i,j) = kg(i,j);
(*theMatrix)(i,j+numDOF2) = -kg(i,j);
(*theMatrix)(i+numDOF2,j) = -kg(i,j);
(*theMatrix)(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
const Vector &
TransformationFE::getC_Force(const Vector &accel, double fact)
{
this->FE_Element::zeroTangent();
this->FE_Element::addCtoTang();
const Matrix &theTangent = this->FE_Element::getTangent(0);
static ID numDOFs(dofData, 1);
numDOFs.setData(dofData, numGroups);
// DO THE SP STUFF TO THE TANGENT
// get the transformation matrix from each dof group & number of local dof
// for original node.
int numNode = numGroups;
for (int a = 0; a<numNode; a++) {
Matrix *theT = theDOFs[a]->getT();
theTransformations[a] = theT;
if (theT != 0)
numDOFs[a] = theT->noRows(); // T^
else
numDOFs[a] = theDOFs[a]->getNumDOF();
}
// perform Tt K T -- as T is block diagonal do T(i)^T K(i,j) T(j)
// where blocks are of size equal to num ele dof at a node
int startRow = 0;
int noRowsTransformed = 0;
int noRowsOriginal = 0;
static Matrix localK;
// foreach block row, for each block col do
for (int i=0; i<numNode; i++) {
int startCol = 0;
int numDOFi = numDOFs[i];
int noColsOriginal = 0;
for (int j=0; j<numNode; j++) {
const Matrix *Ti = theTransformations[i];
const Matrix *Tj = theTransformations[j];
int numDOFj = numDOFs[j];
localK.setData(localKbuffer, numDOFi, numDOFj);
// copy K(i,j) into localK matrix
// CHECK SIZE OF BUFFFER
for (int a=0; a<numDOFi; a++)
for (int b=0; b<numDOFj; b++)
localK(a,b) = theTangent(noRowsOriginal+a, noColsOriginal+b);
// now perform the matrix computation T(i)^T localK T(j)
// note: if T == 0 then the Identity is assumed
int noColsTransformed = 0;
static Matrix localTtKT;
if (Ti != 0 && Tj != 0) {
noRowsTransformed = Ti->noCols();
noColsTransformed = Tj->noCols();
// CHECK SIZE OF BUFFFER
localTtKT.setData(dataBuffer, noRowsTransformed, noColsTransformed);
//localTtKT = (*Ti) ^ localK * (*Tj);
localTtKT.addMatrixTripleProduct(0.0, *Ti, localK, *Tj, 1.0);
} else if (Ti == 0 && Tj != 0) {
noRowsTransformed = numDOFi;
noColsTransformed = Tj->noCols();
// CHECK SIZE OF BUFFFER
localTtKT.setData(dataBuffer, noRowsTransformed, noColsTransformed);
// localTtKT = localK * (*Tj);
localTtKT.addMatrixProduct(0.0, localK, *Tj, 1.0);
} else if (Ti != 0 && Tj == 0) {
noRowsTransformed = Ti->noCols();
noColsTransformed = numDOFj;
// CHECK SIZE OF BUFFFER
localTtKT.setData(dataBuffer, noRowsTransformed, noColsTransformed);
//localTtKT = (*Ti) ^ localK;
localTtKT.addMatrixTransposeProduct(0.0, *Ti, localK, 1.0);
} else {
noRowsTransformed = numDOFi;
noColsTransformed = numDOFj;
localTtKT.setData(dataBuffer, noRowsTransformed, noColsTransformed);
localTtKT = localK;
}
// now copy into modTangent the T(i)^t K(i,j) T(j) product
for (int c=0; c<noRowsTransformed; c++)
for (int d=0; d<noColsTransformed; d++)
(*modTangent)(startRow+c, startCol+d) = localTtKT(c,d);
startCol += noColsTransformed;
noColsOriginal += numDOFj;
}
noRowsOriginal += numDOFi;
startRow += noRowsTransformed;
}
// get the components we need out of the vector
// and place in a temporary vector
Vector tmp(numTransformedDOF);
for (int j=0; j<numTransformedDOF; j++) {
int dof = (*modID)(j);
if (dof >= 0)
tmp(j) = accel(dof);
else
tmp(j) = 0.0;
}
modResidual->addMatrixVector(0.0, *modTangent, tmp, 1.0);
return *modResidual;
}
int
TFP_Bearing::kt3Drma(double *v, double *vp, double *Fr, double A, double *P, double *vpi) {
Vector vF (v, 8);
Vector vpF (vp, 8);
Vector FrF (Fr, 8);
Vector PF (P,4);
/*
opserr << "v: " << vF;
opserr << "vp: " << vpF;
opserr << "Fr: " << FrF;
opserr << "A: " << A << endln;
opserr << "P: " << PF;
*/
static double Ri[8];
static double R[8];
static double N[4];
static Matrix kcont(8,8);
static Matrix krot(8,8);
int cont = 0;
kthat.Zero();
kt.Zero();
ks.Zero();
Af.Zero();
kcont.Zero();
krot.Zero();
for (int i=0; i<4; i++)
N[i] = A;
for (int i=0; i<4; i++) {
int z=4+i;
Ri[i]=sqrt((r[i]-h[i])*(r[i]-h[i]) - v[z]*v[z]);
Ri[z]=sqrt((r[i]-h[i])*(r[i]-h[i]) - v[i]*v[i]);
d[i] = r[i] - sqrt(r[i]*r[i]) - sqrt(v[i]*v[i]+v[z]*v[z]);
N[i] = A + sqrt((P[0]-P[2])*(P[0]-P[2]) + (P[1]-P[3])*(P[1]-P[3])) *
sqrt(v[i]*v[i]+v[z]*v[z])/r[i];
R[i] = Ri[i];
R[z] = Ri[z];
}
double dh =0;
for (int i=0; i<4; i++) {
dh += d[i];
}
// R[0] = (Ri[0]*Ri[2])/(Ri[2]+fabs(v[2])*Ri[0]);
// R[1]=(Ri[1]*Ri[3])/(Ri[3]+fabs(v[3])*Ri[1]);
// R[4]=(Ri[4]*Ri[6])/(Ri[6]+fabs(v[4])*Ri[6]);
// R[5]=(Ri[5]*Ri[7])/(Ri[7]+fabs(v[5])*Ri[7]);
double PNorm = 0.0;
for (int i=0; i<4; i++) {
PNorm += P[i]*P[i];
}
PNorm = sqrt(PNorm);
N[0]=A+PNorm*(sqrt(v[0]*v[0]+v[4]*v[4])/r[0]+sqrt(v[2]*v[2]+v[6]*v[6])/r[2]);
N[1]=A+PNorm*(sqrt(v[1]*v[1]+v[5]*v[5])/r[1]+sqrt(v[3]*v[3]+v[7]*v[7])/r[3]);
for (int i=0; i<4; i++) {
int z=4+i;
// double vyield=0.01;
double qYield=mu[i]*N[i];
double k0=qYield/vyield;
//get trial shear forces of hysteretic component
double qTrialx = k0*(v[i] -vs[i]- vp[i]);
double qTrialy = k0*(v[z] -vs[z]- vp[z]);
// compute yield criterion of hysteretic component
double qTrialNorm = sqrt(qTrialx*qTrialx+qTrialy*qTrialy);
double Y = qTrialNorm - qYield;
// elastic step -> no updates for pastic displacements required
if (Y <= 0 ) {
// set tangent stiffnesses
ks(i,i) = k0 + N[i]/R[i];
ks(z,z) = k0 + N[i]/R[z];
vpi[i] = vp[i];
vpi[z] = vp[z];
// plastic step -> return mapping
} else {
// compute consistency parameters
double dGamma = Y/k0;
// update plastic displacements
vpi[i] = vp[i] + dGamma*qTrialx/qTrialNorm;
vpi[z] = vp[z] + dGamma*qTrialy/qTrialNorm;
// set tangent stiffnesses
double qTrialNorm3 = qTrialNorm*qTrialNorm*qTrialNorm;
ks(i,i) = qYield*k0*qTrialy*qTrialy/qTrialNorm3 + N[i]/R[i];
ks(i,z) = -qYield*k0*qTrialx*qTrialy/qTrialNorm3;
ks(z,i) = -qYield*k0*qTrialx*qTrialy/qTrialNorm3;
ks(z,z) = qYield*k0*qTrialx*qTrialx/qTrialNorm3 + N[i]/R[z];
}
//opserr << "ks: " << ks;
// restrainer contact stiffness
double vt=sqrt(v[i]*v[i]+v[z]*v[z]); //local displacement of surface
double rt=(dOut[i]-dIn[i])/2.0; //restrainer distance
double del=0.1;
if (vt>rt) {
cont=1;
double krim=k0*2;
// set restrainer stiffnesses
double vi2 = v[i]*v[i];
double vz2 = v[z]*v[z];
kcont(i,i) = krim*v[i]*v[i]/(vi2+vz2);
kcont(i,z) = krim*v[z]*v[i]/(vi2+vz2);
kcont(z,i) = krim*v[z]*v[i]/(vi2+vz2);
kcont(z,z) = krim*v[z]*v[z]/(vi2+vz2);
//force rotation matrix
double F=sqrt(Fr[i]*Fr[i]+Fr[z]*Fr[z]);
krot(i,i) = F* ((v[i]+del)/sqrt((v[i]+del)*(v[i]+del)+vz2) - (v[i]-del)/sqrt((v[i]-del)*(v[i]-del)+vz2));
krot(i,z) = F* (v[i]/sqrt(vi2+(v[z]+del)*(v[z]+del)) - v[i]/sqrt(vi2+(v[z]-del)*(v[z]-del)));
krot(z,i) = F* (v[z]/sqrt((v[i]+del)*(v[i]+del)+vz2) - v[z]/sqrt((v[i]-del)*(v[i]-del)+vz2));
krot(z,z) = F* ((v[z]+del)/sqrt(vi2+(v[z]+del)*v[z]+del) - (v[z]-del)/sqrt(vi2+(v[z]-del)*v[z]-del));
}
}
double del = 0.1;
for (int i=0; i<8; i++)
for (int j=0; j<8; j++)
ksrest(i,j)=kcont(i,j)+krot(i,j)/(del * 2.0);
// opserr << "ksrest: " << ksrest;
Af.Zero();
Af(0,4) = Ri[0];
Af(1,5) = Ri[1];
Af(2,0) = Ri[2]/(Ri[2]+Ri[3]);
Af(2,2) = -Ri[2]/(Ri[2]+Ri[3]);
Af(2,4) = -Ri[2]*(Ri[0]+Ri[3])/(Ri[2]+Ri[3]);
Af(2,5) = Ri[2]*(-Ri[1]+Ri[3])/(Ri[2]+Ri[3]);
Af(3,0) = Ri[3]/(Ri[2]+Ri[3]);
Af(3,2) = -Ri[3]/(Ri[2]+Ri[3]);
Af(3,4) = Ri[3]*(-Ri[0]+Ri[2])/(Ri[2]+Ri[3]);
Af(3,5) = Ri[3]*(-Ri[2]-Ri[1])/(Ri[2]+Ri[3]);
Af(4,6) = Ri[4];
Af(5,7) = Ri[5];
Af(6,1) = Ri[6]/(Ri[6]+Ri[7]);
Af(6,3) = -Ri[6]/(Ri[6]+Ri[7]);
Af(6,6) = -Ri[6]*(Ri[4]+Ri[7])/(Ri[6]+Ri[7]);
Af(6,7) = Ri[6]*(-Ri[5]+Ri[7])/(Ri[6]+Ri[7]);
Af(7,1) = Ri[7]/(Ri[6]+Ri[7]);
Af(7,3) = -Ri[7]/(Ri[6]+Ri[7]);
Af(7,6) = Ri[7]*(-Ri[4]+Ri[6])/(Ri[6]+Ri[7]);
Af(7,7) = Ri[7]*(-Ri[6]-Ri[5])/(Ri[6]+Ri[7]);
// opserr << "Af: " << Af;
// opserr << "ks: " << ks;
// opserr << "ksrest: " << ksrest;
static Matrix KsPlusKsrest(8,8);
KsPlusKsrest = ks;
KsPlusKsrest += ksrest;
KsPlusKsrest(0,2) = KsPlusKsrest(0,2) + N[0]/R[2];
KsPlusKsrest(1,3) = KsPlusKsrest(1,3) + N[1]/R[5];
KsPlusKsrest(4,6) = KsPlusKsrest(4,6) + N[4]/R[6];
KsPlusKsrest(5,7) = KsPlusKsrest(5,7) + N[5]/R[7];
kt.addMatrixTripleProduct(0.0, Af, KsPlusKsrest,1.0);
// opserr << "kt:" << kt;
static Matrix Kee(4,4);
for (int i=0; i<4; i++) {
for (int j=0; j<4; j++) {
kthat(i,j) = kt(i,j);
Kee(i,j) = kt(i+4, j+4);
kei(i,j) = kt(i+4, j);
}
}
Kee.Invert(kee);
kthat.addMatrixTripleProduct(1.0, kei, kee, -1.0);
// opserr << "kthat: " << kthat;
return cont;
}
const Matrix& EEBearing3d::getTangentStiff()
{
if (firstWarning == true) {
opserr << "\nWARNING EEBearing3d::getTangentStiff() - "
<< "Element: " << this->getTag() << endln
<< "TangentStiff cannot be calculated." << endln
<< "Return InitialStiff including GeometricStiff instead."
<< endln;
opserr << "Subsequent getTangentStiff warnings will be suppressed."
<< endln;
firstWarning = false;
}
// zero the global matrix
theMatrix.Zero();
// get stiffness matrix in basic system
static Matrix kb(6,6);
kb.Zero();
kb(0,0) = theMaterials[0]->getTangent();
kb(1,1) = kbInit(1,1); kb(1,2) = kbInit(1,2);
kb(2,1) = kbInit(2,1); kb(2,2) = kbInit(2,2);
kb(3,3) = theMaterials[1]->getTangent();
kb(4,4) = theMaterials[2]->getTangent();
kb(5,5) = theMaterials[3]->getTangent();
// transform from basic to local system
static Matrix kl(12,12);
kl.addMatrixTripleProduct(0.0, Tlb, kb, 1.0);
if (Mratio.Size() == 4) {
// get daq resisting forces in basic system
if (theSite != 0) {
(*qbDaq) = theSite->getForce();
}
else {
sData[0] = OF_RemoteTest_getForce;
theChannel->sendVector(0, 0, *sendData, 0);
theChannel->recvVector(0, 0, *recvData, 0);
}
// apply optional initial stiffness modification
if (iMod == true)
this->applyIMod();
// use material force if force from test is zero
if ((*qbDaq)(0) == 0.0)
(*qbDaq)(0) = theMaterials[0]->getStress();
if ((*qbDaq)(3) == 0.0)
(*qbDaq)(3) = theMaterials[1]->getStress();
if ((*qbDaq)(4) == 0.0)
(*qbDaq)(4) = theMaterials[2]->getStress();
if ((*qbDaq)(5) == 0.0)
(*qbDaq)(5) = theMaterials[3]->getStress();
// add geometric stiffness to local stiffness
this->addPDeltaStiff(kl);
}
// transform from local to global system
theMatrix.addMatrixTripleProduct(0.0, Tgl, kl, 1.0);
return theMatrix;
}
const Vector&
Isolator2spring::getStressResultant(void)
{
double Fy;
if (po < 1.0e-10) {
// No strength degradation
Fy = Fyo;
} else {
// Strength degradation based on bearing axial load
double p2 = x0(1)/po;
if (p2<0) {
p2 = 0.0;
}
Fy = Fyo*(1-exp(-p2));
}
// Material stresses using rate independent plasticity, return mapping algorithm
// Compute trial stress using elastic tangent
double fb_try = k1*(x0(2)-sP_n);
double xi_try = fb_try - q_n;
// Yield function
double Phi_try = fabs(xi_try) - Fy;
double fspr;
double dfsds;
double del_gam;
int sign;
// Elastic step
if (Phi_try <= 0.0) {
// Stress and tangent, update plastic deformation and back stress
fspr = fb_try;
dfsds = k1;
sP_n1 = sP_n;
q_n1 = q_n;
}
// Plastic step
else {
// Consistency parameter
del_gam = Phi_try/(k1+H);
sign = (xi_try < 0) ? -1 : 1;
// Return stress to yield surface
fspr = fb_try - del_gam*k1*sign;
dfsds = kbo;
// Update plastic deformation and back stress
sP_n1 = sP_n + del_gam*sign;
q_n1 = q_n + del_gam*H*sign;
}
// Nonlinear equilibrium and kinematic equations; want to find the
// zeros of these equations.
f0(0) = x0(0) - fspr + x0(1)*x0(3);
f0(1) = x0(0)*h - Pe*h*x0(3) + x0(1)*(x0(2)+h*x0(3));
f0(2) = x0(1) - kvo*x0(4);
f0(3) = utpt[0] - x0(2) - h*x0(3);
f0(4) = -utpt[1] - x0(2)*x0(3) - h/2.0*x0(3)*x0(3) - x0(4);
int iter = 0;
double normf0 = f0.Norm();
static Matrix dfinverse(5,5);
// Solve nonlinear equations using Newton's method
while (normf0 > tol) {
iter += 1;
// Formulate Jacobian of nonlinear equations
df(0,0) = 1.0;
df(0,1) = x0(3);
df(0,2) = -dfsds;
df(0,3) = x0(1);
df(0,4) = 0.0;
df(1,0) = h;
df(1,1) = x0(2) + h*x0(3);
df(1,2) = x0(1);
df(1,3) = (x0(1) - Pe)*h;
df(1,4) = 0.0;
df(2,0) = 0.0;
df(2,1) = 1.0;
df(2,2) = 0.0;
df(2,3) = 0.0;
df(2,4) = -kvo;
df(3,0) = 0.0;
df(3,1) = 0.0;
df(3,2) = -1.0;
df(3,3) = -h;
df(3,4) = 0.0;
df(4,0) = 0.0;
df(4,1) = 0.0;
df(4,2) = -x0(3);
df(4,3) = -(x0(2) + h*x0(3));
df(4,4) = -1.0;
df.Invert(dfinverse);
// Compute improved estimate of solution x0
x0 -= dfinverse*f0;
if (po > 1.0e-10) { // Update strength according to axial load
double p2 = x0(1)/po;
if (p2<0) {
p2 = 0.0;
}
Fy = Fyo*(1-exp(-p2));
}
// Apply plasticity theory again, return mapping algorithm
fb_try = k1*(x0(2) - sP_n);
xi_try = fb_try - q_n;
Phi_try = fabs(xi_try) - Fy;
// Elastic step
if (Phi_try <= 0.0) {
fspr = fb_try;
dfsds = k1;
sP_n1 = sP_n;
q_n1 = q_n;
}
// Plastic step
else {
del_gam = Phi_try/(k1+H);
sign = (xi_try < 0) ? -1 : 1;
fspr = fb_try - del_gam*k1*sign;
dfsds = kbo;
sP_n1 = sP_n + del_gam*sign;
q_n1 = q_n + del_gam*H*sign;
}
// Estimate the residual
f0(0) = x0(0) - fspr + x0(1)*x0(3);
f0(1) = x0(0)*h - Pe*h*x0(3) + x0(1)*(x0(2)+h*x0(3));
f0(2) = x0(1) - kvo*x0(4);
f0(3) = utpt[0] - x0(2) - h*x0(3);
f0(4) = -utpt[1] - x0(2)*x0(3) - h/2.0*x0(3)*x0(3) - x0(4);
normf0 = f0.Norm();
if (iter > 19) {
opserr << "WARNING! Iso2spring: Newton iteration failed. Norm Resid: " << normf0 << endln;
break;
}
}
// Compute stiffness matrix by three step process
double denom = h*dfsds*(Pe - x0(1)) - x0(1)*x0(1);
static Matrix fkin(3,2);
fkin(0,0) = 1.0;
fkin(1,0) = h;
fkin(2,0) = 0.0;
fkin(0,1) = -x0(3);
fkin(1,1) = -(x0(2) + h*x0(3));
fkin(2,1) = -1.0;
static Matrix feq(3,3);
feq(0,0) = (Pe-x0(1))*h/denom;
feq(0,1) = feq(1,0) = x0(1)/denom;
feq(1,1) = dfsds/denom;
feq(0,2) = feq(1,2) = feq(2,0) = feq(2,1) = 0.0;
feq(2,2) = 1.0/kvo;
static Matrix ftot(2,2);
static Matrix ktot(2,2);
ftot.Zero();
ftot.addMatrixTripleProduct(0.0,fkin,feq,1.0);
ftot.Invert(ktot);
ks(0,0) = ktot(0,0);
ks(1,0) = ktot(1,0);
ks(0,1) = ktot(0,1);
ks(1,1) = ktot(1,1);
ks(0,2) = ks(1,2) = ks(2,2) = ks(2,1) = ks(2,0) = 0.0;
// Compute force vector
s3(0) = x0(0);
s3(1) = -x0(1);
s3(2) = (x0(1)*utpt[0] + x0(0)*h)/2.0;
return s3;
}
const Matrix& ConstantPressureVolumeQuad :: getInitialStiff( )
{
int i, j, k, l, p, q ;
int jj, kk ;
static double tmp_shp[3][4] ; //shape functions
static double shp[3][4][4] ; //shape functions at each gauss point
static double vol_avg_shp[3][4] ; // volume averaged shape functions
double xsj ; // determinant jacaobian matrix
static Matrix sx(2,2) ; // inverse jacobian matrix
double dvol[4] ; //volume elements
double volume = 0.0 ; //volume of element
double pressure = 0.0 ; //constitutive pressure
static Vector strain(4) ; //strain in vector form
// static Vector sigBar(4) ; //stress in vector form
static Vector sig(4) ; //mixed stress in vector form
double trace = 0.0 ; //trace of the strain
static Matrix BJtran(2,4) ;
static Matrix BK(4,2) ;
static Matrix littleBJtran(2,1) ;
static Matrix littleBK(1,2) ;
static Matrix stiffJK(2,2) ; //nodeJ-nodeK 2x2 stiffness
static Vector residJ(2) ; //nodeJ residual
static Vector one(4) ; //rank 2 identity as a vector
static Matrix Pdev(4,4) ; //deviator projector
// static Matrix dd(4,4) ; //material tangent
static Matrix ddPdev(4,4) ;
static Matrix PdevDD(4,4) ;
static double Pdev_dd_Pdev_data[16];
static double Pdev_dd_one_data[4];
static double one_dd_Pdev_data[4];
static Matrix Pdev_dd_Pdev(Pdev_dd_Pdev_data, 4, 4);
static Matrix Pdev_dd_one(Pdev_dd_one_data, 4, 1);
static Matrix one_dd_Pdev(one_dd_Pdev_data, 1,4) ;
double bulk ;
static Matrix BJtranD(2,4) ;
static Matrix BJtranDone(2,1) ;
static Matrix littleBJoneD(2,4) ;
static Matrix littleBJtranBulk(2,1) ;
//zero stiffness and residual
stiff.Zero();
//one vector
one(0) = 1.0 ;
one(1) = 1.0 ;
one(2) = 1.0 ;
one(3) = 0.0 ;
//Pdev matrix
Pdev.Zero( ) ;
Pdev(0,0) = two3 ;
Pdev(0,1) = -one3 ;
Pdev(0,2) = -one3 ;
Pdev(1,0) = -one3 ;
Pdev(1,1) = two3 ;
Pdev(1,2) = -one3 ;
Pdev(2,0) = -one3 ;
Pdev(2,1) = -one3 ;
Pdev(2,2) = two3 ;
Pdev(3,3) = 1.0 ;
//zero stuff
volume = 0.0 ;
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ )
vol_avg_shp[k][l] = 0.0 ;
} //end for k
//gauss loop to compute volume averaged shape functions
for ( i = 0; i < 4; i++ ){
shape2d( sg[i], tg[i], xl, tmp_shp, xsj, sx ) ;
dvol[i] = wg[i] * xsj ; // multiply by radius for axisymmetry
volume += dvol[i] ;
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ ) {
shp[k][l][i] = tmp_shp[k][l] ;
vol_avg_shp[k][l] += tmp_shp[k][l] * dvol[i] ;
} // end for l
} //end for k
} //end for i
//compute volume averaged shape functions
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ )
vol_avg_shp[k][l] /= volume ;
} //end for k
//residual and tangent calculations gauss loop
for ( i = 0; i < 4; i++ ) {
static Matrix dd(4,4);
dd = materialPointers[i]->getInitialTangent( ) ;
dd *= dvol[i] ;
//Pdev_dd_Pdev = Pdev * dd * Pdev ;
Pdev_dd_Pdev.addMatrixTripleProduct(0.0,
Pdev,
dd,
1.0) ;
//Pdev_dd_one = one3 * ( Pdev * dd * oneMatrix ) ;
PdevDD.addMatrixProduct(0.0, Pdev, dd, 1.0) ;
Pdev_dd_one(0,0) = one3 * (PdevDD(0,0) + PdevDD(0,1) + PdevDD(0,2));
Pdev_dd_one(1,0) = one3 * (PdevDD(1,0) + PdevDD(1,1) + PdevDD(1,2));
Pdev_dd_one(2,0) = one3 * (PdevDD(2,0) + PdevDD(2,1) + PdevDD(2,2));
Pdev_dd_one(3,0) = one3 * (PdevDD(3,0) + PdevDD(3,1) + PdevDD(3,2));
//one_dd_Pdev = one3 * ( oneTran * dd * Pdev ) ;
ddPdev.addMatrixProduct(0.0, dd, Pdev, 1.0) ;
one_dd_Pdev(0,0) = one3 * (ddPdev(0,0) + ddPdev(1,0) + ddPdev(2,0));
one_dd_Pdev(0,1) = one3 * (ddPdev(0,1) + ddPdev(1,1) + ddPdev(2,1));
one_dd_Pdev(0,2) = one3 * (ddPdev(0,2) + ddPdev(1,2) + ddPdev(2,2));
one_dd_Pdev(0,3) = one3 * (ddPdev(0,3) + ddPdev(1,3) + ddPdev(2,3));
bulk = one9 * ( dd(0,0) + dd(0,1) + dd(0,2)
+ dd(1,0) + dd(1,1) + dd(1,2)
+ dd(2,0) + dd(2,1) + dd(2,2) ) ;
jj = 0 ;
for ( j = 0; j < 4; j++ ) {
double BJ00 = shp[0][j][i];
double BJ11 = shp[1][j][i];
double BJ30 = shp[1][j][i];
double BJ31 = shp[0][j][i];
BJtran.Zero( );
BJtran(0,0) = shp[0][j][i] ;
BJtran(1,1) = shp[1][j][i] ;
// BJ(2,0) for axi-symmetry
BJtran(0,3) = shp[1][j][i] ;
BJtran(1,3) = shp[0][j][i] ;
//compute residual
double ltBJ00 = vol_avg_shp[0][j] ;
double ltBJ01 = vol_avg_shp[1][j] ;
//BJtranD = BJtran * Pdev_dd_Pdev ;
// BJtranD.addMatrixProduct(0.0, BJtran, Pdev_dd_Pdev, 1.0);
//littleBJoneD = littleBJtran * one_dd_Pdev ;
// littleBJoneD.addMatrixProduct(0.0, littleBJtran, one_dd_Pdev, 1.0);
static double Adata[8];
static Matrix A(Adata, 2, 4);
// A = BJtranD;
// A += littleBJoneD;
for (int colA = 0, loc = 0, colPdev = 0; colA<4; colA++, colPdev += 4) {
double data3colA = Pdev_dd_Pdev_data[3+colPdev];
Adata[loc++] = BJ00*Pdev_dd_Pdev_data[colPdev] + BJ30*data3colA + ltBJ00*one_dd_Pdev_data[colA];
Adata[loc++] = BJ11*Pdev_dd_Pdev_data[1+colPdev] + BJ31*data3colA + ltBJ01*one_dd_Pdev_data[colA];
}
//BJtranDone = BJtran * Pdev_dd_one ;
// BJtranDone.addMatrixProduct(0.0, BJtran, Pdev_dd_one, 1.0);
//littleBJtranBulk = bulk * littleBJtran ;
// littleBJtranBulk = littleBJtran ;
// littleBJtranBulk *= bulk ;
double B1, B2;
// B1 = BJtranDone(0,0) + littleBJtranBulk(0,0);
// B2 = BJtranDone(1,0) + littleBJtranBulk(1,0);
B1 = BJ00*Pdev_dd_one_data[0] + BJ30*Pdev_dd_one_data[3] + ltBJ00 *bulk;
B2 = BJ11*Pdev_dd_one_data[1] + BJ31*Pdev_dd_one_data[3] + ltBJ01 *bulk;
int colkk, colkkP1;
for ( k = 0, kk=0, colkk =0, colkkP1 =8;
k < 4;
k++, kk += 2, colkk += 16, colkkP1 += 16 ) {
double BK00 = shp[0][k][i];
double BK11 = shp[1][k][i];
double BK30 = shp[1][k][i];
double BK31 = shp[0][k][i];
double littleBK00 = vol_avg_shp[0][k];
double littleBK01 = vol_avg_shp[1][k];
//compute stiffness matrix
stiff( jj, kk ) += Adata[0]*BK00 + Adata[6]*BK30 + B1 * littleBK00;
stiff( jj+1, kk ) += Adata[1]*BK00 + Adata[7]*BK30 + B2 * littleBK00;
stiff( jj, kk+1 ) += Adata[2]*BK11 + Adata[6]*BK31 + B1 * littleBK01;
stiff( jj+1, kk+1 ) += Adata[3]*BK11 + Adata[7]*BK31 + B2 * littleBK01;
} // end for k
jj += 2 ;
} // end for j
} //end for i
return stiff ;
}
//form residual and tangent
void ConstantPressureVolumeQuad :: formResidAndTangent( int tang_flag )
{
// strains ordered 00, 11, 22, 01
// i.e. 11, 22, 33, 12
//
// strain(0) = eps_00
// strain(1) = eps_11
// strain(2) = eps_22
// strain(3) = 2*eps_01
//
// same ordering for stresses but no 2
int i, j, k, l, p, q ;
int jj, kk ;
static double tmp_shp[3][4] ; //shape functions
static double shp[3][4][4] ; //shape functions at each gauss point
static double vol_avg_shp[3][4] ; // volume averaged shape functions
double xsj ; // determinant jacaobian matrix
static Matrix sx(2,2) ; // inverse jacobian matrix
double dvol[4] ; //volume elements
double volume = 0.0 ; //volume of element
double pressure = 0.0 ; //constitutive pressure
static Vector strain(4) ; //strain in vector form
// static Vector sigBar(4) ; //stress in vector form
static Vector sig(4) ; //mixed stress in vector form
double trace = 0.0 ; //trace of the strain
static Matrix BJtran(2,4) ;
static Matrix BK(4,2) ;
static Matrix littleBJtran(2,1) ;
static Matrix littleBK(1,2) ;
static Matrix stiffJK(2,2) ; //nodeJ-nodeK 2x2 stiffness
static Vector residJ(2) ; //nodeJ residual
static Vector one(4) ; //rank 2 identity as a vector
static Matrix Pdev(4,4) ; //deviator projector
// static Matrix dd(4,4) ; //material tangent
static Matrix ddPdev(4,4) ;
static Matrix PdevDD(4,4) ;
static double Pdev_dd_Pdev_data[16];
static double Pdev_dd_one_data[4];
static double one_dd_Pdev_data[4];
static Matrix Pdev_dd_Pdev(Pdev_dd_Pdev_data, 4, 4);
static Matrix Pdev_dd_one(Pdev_dd_one_data, 4, 1);
static Matrix one_dd_Pdev(one_dd_Pdev_data, 1,4) ;
double bulk ;
static Matrix BJtranD(2,4) ;
static Matrix BJtranDone(2,1) ;
static Matrix littleBJoneD(2,4) ;
static Matrix littleBJtranBulk(2,1) ;
//zero stiffness and residual
if ( tang_flag == 1 )
stiff.Zero();
else
resid.Zero();
//one vector
one(0) = 1.0 ;
one(1) = 1.0 ;
one(2) = 1.0 ;
one(3) = 0.0 ;
//Pdev matrix
Pdev.Zero( ) ;
Pdev(0,0) = two3 ;
Pdev(0,1) = -one3 ;
Pdev(0,2) = -one3 ;
Pdev(1,0) = -one3 ;
Pdev(1,1) = two3 ;
Pdev(1,2) = -one3 ;
Pdev(2,0) = -one3 ;
Pdev(2,1) = -one3 ;
Pdev(2,2) = two3 ;
Pdev(3,3) = 1.0 ;
//zero stuff
volume = 0.0 ;
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ )
vol_avg_shp[k][l] = 0.0 ;
} //end for k
//gauss loop to compute volume averaged shape functions
for ( i = 0; i < 4; i++ ){
shape2d( sg[i], tg[i], xl, tmp_shp, xsj, sx ) ;
dvol[i] = wg[i] * xsj ; // multiply by radius for axisymmetry
volume += dvol[i] ;
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ ) {
shp[k][l][i] = tmp_shp[k][l] ;
vol_avg_shp[k][l] += tmp_shp[k][l] * dvol[i] ;
} // end for l
} //end for k
} //end for i
//compute volume averaged shape functions
for ( k = 0; k < 3; k++ ){
for ( l = 0; l < 4; l++ )
vol_avg_shp[k][l] /= volume ;
} //end for k
//compute pressure if residual calculation
if (tang_flag != 1) {
pressure = 0.0 ;
for ( i = 0; i < 4; i++ ) {
const Vector &sigBar = materialPointers[i]->getStress( ) ;
pressure += one3 * ( sigBar(0) + sigBar(1) + sigBar(2) ) * dvol[i] ;
} // end for i
pressure /= volume ;
} // end if != tang_flag
//residual and tangent calculations gauss loop
for ( i = 0; i < 4; i++ ) {
if ( tang_flag == 1 ) { // compute matrices for stiffness calculation
static Matrix dd(4,4);
dd = materialPointers[i]->getTangent( ) ;
dd *= dvol[i] ;
//Pdev_dd_Pdev = Pdev * dd * Pdev ;
Pdev_dd_Pdev.addMatrixTripleProduct(0.0,
Pdev,
dd,
1.0) ;
//Pdev_dd_one = one3 * ( Pdev * dd * oneMatrix ) ;
PdevDD.addMatrixProduct(0.0, Pdev, dd, 1.0) ;
Pdev_dd_one(0,0) = one3 * (PdevDD(0,0) + PdevDD(0,1) + PdevDD(0,2));
Pdev_dd_one(1,0) = one3 * (PdevDD(1,0) + PdevDD(1,1) + PdevDD(1,2));
Pdev_dd_one(2,0) = one3 * (PdevDD(2,0) + PdevDD(2,1) + PdevDD(2,2));
Pdev_dd_one(3,0) = one3 * (PdevDD(3,0) + PdevDD(3,1) + PdevDD(3,2));
//one_dd_Pdev = one3 * ( oneTran * dd * Pdev ) ;
ddPdev.addMatrixProduct(0.0, dd, Pdev, 1.0) ;
one_dd_Pdev(0,0) = one3 * (ddPdev(0,0) + ddPdev(1,0) + ddPdev(2,0));
one_dd_Pdev(0,1) = one3 * (ddPdev(0,1) + ddPdev(1,1) + ddPdev(2,1));
one_dd_Pdev(0,2) = one3 * (ddPdev(0,2) + ddPdev(1,2) + ddPdev(2,2));
one_dd_Pdev(0,3) = one3 * (ddPdev(0,3) + ddPdev(1,3) + ddPdev(2,3));
bulk = one9 * ( dd(0,0) + dd(0,1) + dd(0,2)
+ dd(1,0) + dd(1,1) + dd(1,2)
+ dd(2,0) + dd(2,1) + dd(2,2) ) ;
} else { // compute stress for residual calculation
//stress for equilibrium
const Vector &sigBar = materialPointers[i]->getStress( ) ;
trace = sigBar(0) + sigBar(1) + sigBar(2) ;
sig = sigBar ;
//sig -= (one3*trace)*one ;
sig.addVector(1.0, one, -one3*trace ) ;
sig.addVector(1.0, one, pressure ) ;
//multilply by volume elements and compute
sig *= dvol[i] ;
}
//residual and tangent loop over nodes
jj = 0 ;
for ( j = 0; j < 4; j++ ) {
/********** expanding for efficiency the matrix operations that use these
BJ.Zero( );
BJ(0,0) = shp[0][j][i] ;
BJ(1,1) = shp[1][j][i] ;
// BJ(2,0) for axi-symmetry
BJ(3,0) = shp[1][j][i] ;
BJ(3,1) = shp[0][j][i] ;
littleBJ(0,0) = vol_avg_shp[0][j] ;
littleBJ(0,1) = vol_avg_shp[1][j] ;
// BJtran = this->transpose( 4, 2, BJ ) ;
for (p=0; p<2; p++) {
for (q=0; q<4; q++)
BJtran(p,q) = BJ(q,p) ;
}//end for p
for (p=0; p<2; p++) {
for (q=0; q<1; q++)
littleBJtran(p,q) = littleBJ(q,p) ;
}//end for p
**********************************************************************/
double BJ00 = shp[0][j][i];
double BJ11 = shp[1][j][i];
double BJ30 = shp[1][j][i];
double BJ31 = shp[0][j][i];
BJtran.Zero( );
BJtran(0,0) = shp[0][j][i] ;
BJtran(1,1) = shp[1][j][i] ;
// BJ(2,0) for axi-symmetry
BJtran(0,3) = shp[1][j][i] ;
BJtran(1,3) = shp[0][j][i] ;
//compute residual
if ( tang_flag == 1 ) { //stiffness matrix
double ltBJ00 = vol_avg_shp[0][j] ;
double ltBJ01 = vol_avg_shp[1][j] ;
//BJtranD = BJtran * Pdev_dd_Pdev ;
// BJtranD.addMatrixProduct(0.0, BJtran, Pdev_dd_Pdev, 1.0);
//littleBJoneD = littleBJtran * one_dd_Pdev ;
// littleBJoneD.addMatrixProduct(0.0, littleBJtran, one_dd_Pdev, 1.0);
static double Adata[8];
static Matrix A(Adata, 2, 4);
// A = BJtranD;
// A += littleBJoneD;
for (int colA = 0, loc = 0, colPdev = 0; colA<4; colA++, colPdev += 4) {
double data3colA = Pdev_dd_Pdev_data[3+colPdev];
Adata[loc++] = BJ00*Pdev_dd_Pdev_data[colPdev] + BJ30*data3colA + ltBJ00*one_dd_Pdev_data[colA];
Adata[loc++] = BJ11*Pdev_dd_Pdev_data[1+colPdev] + BJ31*data3colA + ltBJ01*one_dd_Pdev_data[colA];
}
//BJtranDone = BJtran * Pdev_dd_one ;
// BJtranDone.addMatrixProduct(0.0, BJtran, Pdev_dd_one, 1.0);
//littleBJtranBulk = bulk * littleBJtran ;
// littleBJtranBulk = littleBJtran ;
// littleBJtranBulk *= bulk ;
double B1, B2;
// B1 = BJtranDone(0,0) + littleBJtranBulk(0,0);
// B2 = BJtranDone(1,0) + littleBJtranBulk(1,0);
B1 = BJ00*Pdev_dd_one_data[0] + BJ30*Pdev_dd_one_data[3] + ltBJ00 *bulk;
B2 = BJ11*Pdev_dd_one_data[1] + BJ31*Pdev_dd_one_data[3] + ltBJ01 *bulk;
int colkk, colkkP1;
for ( k = 0, kk=0, colkk =0, colkkP1 =8;
k < 4;
k++, kk += 2, colkk += 16, colkkP1 += 16 ) {
/**************************************************************
REPLACING THESE LINES WITH THE 4 BELOW COMMENT FOR EFFICIENCY
BK.Zero( );
BK(0,0) = shp[0][k][i];
BK(1,1) = shp[1][k][i];
// BK(2,0) for axi-symmetry
BK(3,0) = shp[1][k][i];
BK(3,1) = shp[0][k][i];
**************************************************************/
double BK00 = shp[0][k][i];
double BK11 = shp[1][k][i];
double BK30 = shp[1][k][i];
double BK31 = shp[0][k][i];
double littleBK00 = vol_avg_shp[0][k];
double littleBK01 = vol_avg_shp[1][k];
//compute stiffness matrix
// stiffJK = ( BJtranD + littleBJoneD ) * BK
// + ( BJtranDone + littleBJtranBulk ) * littleBK ;
/**************************************************************
REPLACING THESE LINES WITH THE 4 BELOW COMMENT FOR EFFICIENCY
//stiffJK.addMatrixProduct(0.0, A, BK, 1.0);
//stiff( jj, kk ) += stiffJK(0,0) + B1 * littleBK00;
//stiff( jj+1, kk ) += stiffJK(1,0) + B2 * littleBK00;
//stiff( jj, kk+1 ) += stiffJK(0,1) + B1 * littleBK01;
//stiff( jj+1, kk+1 ) += stiffJK(1,1) + B2 * littleBK01;
***************************************************************/
// matrixData[ colkk + jj] += Adata[0]*BK00 + Adata[6]*BK30 + B1 * littleBK00;
// matrixData[ colkk + jj+1] += Adata[1]*BK00 + Adata[7]*BK30 + B2 * littleBK00;
// matrixData[colkkP1 + jj] += Adata[2]*BK11 + Adata[6]*BK31 + B1 * littleBK01;
// matrixData[colkkP1 + jj+1] += Adata[3]*BK11 + Adata[7]*BK31 + B2 * littleBK01;
stiff( jj, kk ) += Adata[0]*BK00 + Adata[6]*BK30 + B1 * littleBK00;
stiff( jj+1, kk ) += Adata[1]*BK00 + Adata[7]*BK30 + B2 * littleBK00;
stiff( jj, kk+1 ) += Adata[2]*BK11 + Adata[6]*BK31 + B1 * littleBK01;
stiff( jj+1, kk+1 ) += Adata[3]*BK11 + Adata[7]*BK31 + B2 * littleBK01;
} // end for k
} else { // residual calculation
//residJ = BJtran * sig;
residJ.addMatrixVector(0.0, BJtran, sig, 1.0);
resid( jj ) += residJ(0);
resid( jj+1 ) += residJ(1);
}
jj += 2 ;
} // end for j
} //end for i
return ;
}
const Matrix& TwentyEightNodeBrickUP::getStiff( int flag )
{
if (flag != 0 && flag != 1) {
opserr << "FATAL TwentyEightNodeBrickUP::getStiff() - illegal use\n";
exit(-1);
}
if (flag == 0 && Ki != 0)
return *Ki;
int i, j ;
static double xsj ; // determinant jacaobian matrix
double volume = 0.;
//-------------------------------------------------------
int j3, j3m1, j3m2, ik, ib, jk, jb;
static Matrix B(6,nenu*3);
static Matrix BTDB(nenu*3,nenu*3);
static Matrix D(6, 6);
B.Zero();
BTDB.Zero();
stiff.Zero();
//compute basis vectors and local nodal coordinates
computeBasis( ) ;
for( i = 0; i < nintu; i++ ) {
// compute Jacobian and global shape functions
Jacobian3d(i, xsj, 0);
//volume element to also be saved
dvolu[i] = wu[i] * xsj ;
volume += dvolu[i];
} // end for i
//printf("volume = %f\n", volume);
// for( i = 0; i < nintu; i++ ) {
// for(int j = 0; j < nenu; j++ ) {
// printf("%5d %5d %15.6e %15.6e %15.6e %15.6e\n", i,j,
// shgu[0][j][i], shgu[1][j][i], shgu[2][j][i], shgu[3][j][i]);
// }
// }
// exit(-1);
// Loop over the integration points
for (i = 0; i < nintu; i++) {
// Get the material tangent
if( flag == 0 )
D = materialPointers[i]->getInitialTangent();
else
D = materialPointers[i]->getTangent();
//const Matrix &D = materialPointers[i]->getTangent();
for (j=0; j<nenu; j++) {
j3 = 3*j+2;
j3m1 = j3 - 1;
j3m2 = j3 - 2;
B(0,j3m2) = shgu[0][j][i];
B(0,j3m1) = 0.;
B(0,j3 ) = 0.;
B(1,j3m2) = 0.;
B(1,j3m1) = shgu[1][j][i];
B(1,j3 ) = 0.;
B(2,j3m2) = 0.;
B(2,j3m1) = 0.;
B(2,j3 ) = shgu[2][j][i];
B(3,j3m2) = shgu[1][j][i];
B(3,j3m1) = shgu[0][j][i];
B(3,j3 ) = 0.;
B(4,j3m2) = 0.;
B(4,j3m1) = shgu[2][j][i];
B(4,j3 ) = shgu[1][j][i];
B(5,j3m2) = shgu[2][j][i];
B(5,j3m1) = 0.;
B(5,j3 ) = shgu[0][j][i];
}
// Perform numerical integration
//K = K + (B^ D * B) * intWt(i) * detJ;
BTDB.addMatrixTripleProduct(1.0, B, D, dvolu[i]);
}
for (i = 0; i < nenu; i++) {
if (i<nenp)
ik = i*4;
else
ik = nenp*4 + (i-nenp)*3;
ib = i*3;
for (j = 0; j < nenu; j++) {
if (j<nenp)
jk = j*4;
else
jk = nenp*4 + (j-nenp)*3;
jb = j*3;
for( int i1 = 0; i1 < 3; i1++)
for(int j1 = 0; j1 < 3; j1++) {
stiff(ik+i1, jk+j1) = BTDB(ib+i1,jb+j1);
}
}
}
if( flag == 1) {
return stiff;
}
Ki = new Matrix(stiff);
if (Ki == 0) {
opserr << "FATAL TwentyEightNodeBrickUP::getStiff() -";
opserr << "ran out of memory\n";
exit(-1);
}
return *Ki;
}
const Matrix &
CorotTrussSection::getTangentStiff(void)
{
static Matrix kl(3,3);
// Material stiffness
//
// Get material tangent
int order = theSection->getOrder();
const ID &code = theSection->getType();
const Matrix &ks = theSection->getSectionTangent();
const Vector &s = theSection->getStressResultant();
double EA = 0.0;
double q = 0.0;
int i,j;
for (i = 0; i < order; i++) {
if (code(i) == SECTION_RESPONSE_P) {
EA += ks(i,i);
q += s(i);
}
}
EA /= (Ln*Ln*Lo);
for (i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
kl(i,j) = EA*d21[i]*d21[j];
// Geometric stiffness
//
// Get material stress
double SA = q/(Ln*Ln*Ln);
double SL = q/Ln;
for (i = 0; i < 3; i++) {
kl(i,i) += SL;
for (j = 0; j < 3; j++)
kl(i,j) -= SA*d21[i]*d21[j];
}
// Compute R'*kl*R
static Matrix kg(3,3);
kg.addMatrixTripleProduct(0.0, R, kl, 1.0);
Matrix &K = *theMatrix;
K.Zero();
// Copy stiffness into appropriate blocks in element stiffness
int numDOF2 = numDOF/2;
for (i = 0; i < numDIM; i++) {
for (j = 0; j < numDIM; j++) {
K(i,j) = kg(i,j);
K(i,j+numDOF2) = -kg(i,j);
K(i+numDOF2,j) = -kg(i,j);
K(i+numDOF2,j+numDOF2) = kg(i,j);
}
}
return *theMatrix;
}
