// constructors:
WSection2d::WSection2d(int tag, NDMaterial &theMat,
double D, double Tw, double Bf, double Tf,
int Nfdw, int Nftf, double shape, double flag):
SectionForceDeformation(tag, SEC_TAG_WSection2d),
theFibers(0), yFibers(0), AFibers(0), e(6),
d(D), tw(Tw), bf(Bf), tf(Tf), nfdw(Nfdw), nftf(Nftf), shapeFactor(shape)
{
int numFibers = nfdw + 2*nftf;
theFibers = new NDMaterial*[numFibers];
yFibers = new double[numFibers];
AFibers = new double[numFibers];
for (int i = 0; i < numFibers; i++) {
theFibers[i] = flag ? theMat.getCopy("BeamFiber") :
theMat.getCopy("TimoshenkoFiber");
if (theFibers[i] == 0)
opserr << "WSection2d::WSection2d -- failed to get copy of beam fiber" << endln;
}
double dw = d-2*tf;
double a_f = bf*tf/nftf;
double a_w = dw*tw/nfdw;
int loc = 0;
double yIncr = tf/nftf;
double yStart = 0.5*d - 0.5*yIncr;
for (loc = 0; loc < nftf; loc++) {
AFibers[loc] = AFibers[numFibers-loc-1] = a_f;
yFibers[loc] = yStart - yIncr*loc;
yFibers[numFibers-loc-1] = -yFibers[loc];
}
yIncr = dw/nfdw;
yStart = 0.5*dw - 0.5*yIncr;
int count = 0;
for ( ; loc < numFibers-nftf; loc++, count++) {
AFibers[loc] = a_w;
yFibers[loc] = yStart - yIncr*count;
}
code(0) = SECTION_RESPONSE_P;
code(1) = SECTION_RESPONSE_MZ;
code(2) = SECTION_RESPONSE_MY;
code(3) = SECTION_RESPONSE_VY;
code(4) = SECTION_RESPONSE_VZ;
code(5) = SECTION_RESPONSE_T;
}
ZeroLengthND::ZeroLengthND(int tag, int dim, int Nd1, int Nd2,
const Vector& x, const Vector& yprime,
NDMaterial &theNDmat) :
Element(tag, ELE_TAG_ZeroLengthND),
connectedExternalNodes(2),
dimension(dim), numDOF(0),
transformation(3,3), A(0), v(0), e(0.0), K(0), P(0),
end1Ptr(0), end2Ptr(0), theNDMaterial(0), the1DMaterial(0), order(0)
{
// Obtain copy of Nd material model
theNDMaterial = theNDmat.getCopy();
if (theNDMaterial == 0) {
opserr << "ZeroLengthND::zeroLengthND-- failed to get copy of NDMaterial\n";
exit(-1);
}
// Get the material order
order = theNDMaterial->getOrder();
// Check material order
if (order < 2 || order > 3) {
opserr << "ZeroLengthND:: -- NDMaterial not of order 2 or 3\n";
exit(-1);
}
// Set up the transformation matrix of direction cosines
this->setUp(Nd1, Nd2, x, yprime);
}
//full constructor
PlateFromPlaneStressMaterialThermal::PlateFromPlaneStressMaterialThermal(
int tag, NDMaterial &ndMat, double g ) :
NDMaterial( tag, ND_TAG_PlateFromPlaneStressMaterialThermal ),
strain(5),gmod(g)
{
theMat = ndMat.getCopy("PlaneStress") ;
}
//full constructor
ConstantPressureVolumeQuad :: ConstantPressureVolumeQuad(
int tag,
int node1,
int node2,
int node3,
int node4,
NDMaterial &theMaterial ) :
Element( tag, ELE_TAG_ConstantPressureVolumeQuad ),
connectedExternalNodes(4), load(0)
{
connectedExternalNodes(0) = node1 ;
connectedExternalNodes(1) = node2 ;
connectedExternalNodes(2) = node3 ;
connectedExternalNodes(3) = node4 ;
int i ;
for ( i = 0 ; i < 4; i++ ) {
materialPointers[i] = theMaterial.getCopy("AxiSymmetric2D") ;
if (materialPointers[i] == 0) {
opserr << "ConstantPressureVolumeQuad::constructor - failed to get a material of type: AxiSymmetric2D\n";
exit(-1);
} //end if
} //end for i
}
GenericSectionNd::GenericSectionNd(int tag, NDMaterial &m, const ID &mCode)
:SectionForceDeformation(tag,SEC_TAG_GenericNd),
otherDbTag(0), theModel(0), code(0)
{
theModel = m.getCopy();
if (theModel == 0) {
g3ErrorHandler->fatal("%s -- failed to get copy of material model",
"GenericSectionNd::GenericSectionNd");
}
order = theModel->getOrder();
code = new ID(mCode);
if (code == 0) {
g3ErrorHandler->fatal("%s -- failed to allocate section ID",
"GenericSectionNd::GenericSectionNd");
}
if (order != code->Size()) {
g3ErrorHandler->warning("%s -- code size does not match order of material model",
"GenericSectionNd::GenericSectionNd");
}
}
NineFourNodeQuadUP::NineFourNodeQuadUP(int tag,
int nd1, int nd2, int nd3, int nd4,int nd5, int nd6, int nd7, int nd8,int nd9,
NDMaterial &m, const char *type, double t, double bulk, double r,
double p1, double p2, double b1, double b2)
:Element (tag, ELE_TAG_Nine_Four_Node_QuadUP),
theMaterial(0), connectedExternalNodes(9),
Ki(0), Q(22), thickness(t), kc(bulk), rho(r)
{
this->shapeFunction(wu, nintu, nenu, 0);
/* for( int L = 0; L < nintu; L++) {
for( int j = 0; j < nenu; j++) {
printf("%5d %5d %15.6e %15.6e %15.6e\n", L+1, j+1,
shlu[0][j][L],shlu[1][j][L],shlu[2][j][L]);
}
}
exit(-1);
*/
this->shapeFunction(wp, nintp, nenp, 1);
this->shapeFunction(wp, nintp, nenu, 2);
// Body forces
b[0] = b1;
b[1] = b2;
// Permeabilities
perm[0] = p1;
perm[1] = p2;
// Allocate arrays of pointers to NDMaterials
theMaterial = new NDMaterial *[nintu];
if (theMaterial == 0) {
opserr << "NineFourNodeQuadUP::NineFourNodeQuadUP - failed allocate material model pointer\n";
exit(-1);
}
for (int i = 0; i < nintu; i++) {
// Get copies of the material model for each integration point
theMaterial[i] = m.getCopy(type);
// Check allocation
if (theMaterial[i] == 0) {
opserr << "NineFourNodeQuadUP::NineFourNodeQuadUP -- failed to get a copy of material model\n";
exit(-1);
}
}
// Set connected external node IDs
connectedExternalNodes(0) = nd1;
connectedExternalNodes(1) = nd2;
connectedExternalNodes(2) = nd3;
connectedExternalNodes(3) = nd4;
connectedExternalNodes(4) = nd5;
connectedExternalNodes(5) = nd6;
connectedExternalNodes(6) = nd7;
connectedExternalNodes(7) = nd8;
connectedExternalNodes(8) = nd9;
}
FourNodeQuadUP::FourNodeQuadUP(int tag, int nd1, int nd2, int nd3, int nd4,
NDMaterial &m, const char *type, double t, double bulk,
double r, double p1, double p2, double b1, double b2, double p)
:Element (tag, ELE_TAG_FourNodeQuadUP),
theMaterial(0), connectedExternalNodes(4),
nd1Ptr(0), nd2Ptr(0), nd3Ptr(0), nd4Ptr(0), Ki(0),
Q(12), pressureLoad(12), applyLoad(0), thickness(t), kc(bulk), rho(r), pressure(p),
end1InitDisp(0),end2InitDisp(0),end3InitDisp(0),end4InitDisp(0)
{
pts[0][0] = -0.5773502691896258;
pts[0][1] = -0.5773502691896258;
pts[1][0] = 0.5773502691896258;
pts[1][1] = -0.5773502691896258;
pts[2][0] = 0.5773502691896258;
pts[2][1] = 0.5773502691896258;
pts[3][0] = -0.5773502691896258;
pts[3][1] = 0.5773502691896258;
wts[0] = 1.0;
wts[1] = 1.0;
wts[2] = 1.0;
wts[3] = 1.0;
// Body forces
b[0] = b1;
b[1] = b2;
// Permeabilities
perm[0] = p1;
perm[1] = p2;
// Allocate arrays of pointers to NDMaterials
theMaterial = new NDMaterial *[4];
if (theMaterial == 0) {
opserr << "FourNodeQuadUP::FourNodeQuadUP - failed allocate material model pointer\n";
exit(-1);
}
for (int i = 0; i < 4; i++) {
// Get copies of the material model for each integration point
theMaterial[i] = m.getCopy(type);
// Check allocation
if (theMaterial[i] == 0) {
opserr << "FourNodeQuadUP::FourNodeQuadUP -- failed to get a copy of material model\n";
exit(-1);
}
}
// Set connected external node IDs
connectedExternalNodes(0) = nd1;
connectedExternalNodes(1) = nd2;
connectedExternalNodes(2) = nd3;
connectedExternalNodes(3) = nd4;
}
PlaneStressFiberMaterial::PlaneStressFiberMaterial(int tag, NDMaterial &theMat)
: NDMaterial(tag, ND_TAG_PlaneStressFiberMaterial),
Tstrain22(0.0), Cstrain22(0.0), twoDtgLastCommit(3,3), theMaterial(0), strain(2)
{
// Get a copy of the material
theMaterial = theMat.getCopy();
if (theMaterial == 0) {
opserr << "PlaneStressFiberMaterial::PlaneStressFiberMaterial -- failed to get copy of material\n";
exit(-1);
}
}
Tri31::Tri31(int tag, int nd1, int nd2, int nd3,
NDMaterial &m, const char *type, double t,
double p, double r, double b1, double b2)
:Element (tag, ELE_TAG_Tri31),
theMaterial(0), connectedExternalNodes(3),
Q(6), pressureLoad(6), thickness(t), pressure(p), rho(r), Ki(0)
{
pts[0][0] = 0.333333333333333;
pts[0][1] = 0.333333333333333;
wts[0] = 0.5;
if (strcmp(type,"PlaneStrain") != 0 && strcmp(type,"PlaneStress") != 0
&& strcmp(type,"PlaneStrain2D") != 0 && strcmp(type,"PlaneStress2D") != 0) {
opserr << "Tri31::Tri31 -- improper material type: " << type << "for Tri31\n";
exit(-1);
}
// Body forces
b[0] = b1;
b[1] = b2;
numgp = 1;
numnodes = 3;
// Allocate arrays of pointers to NDMaterials
theMaterial = new NDMaterial *[numgp];
if (theMaterial == 0) {
opserr << "Tri31::Tri31 - failed allocate material model pointer\n";
exit(-1);
}
int i;
for (i = 0; i < numgp; i++) {
// Get copies of the material model for each integration point
theMaterial[i] = m.getCopy(type);
// Check allocation
if (theMaterial[i] == 0) {
opserr << "Tri31::Tri31 -- failed to get a copy of material model\n";
exit(-1);
}
}
// Set connected external node IDs
connectedExternalNodes(0) = nd1;
connectedExternalNodes(1) = nd2;
connectedExternalNodes(2) = nd3;
for (i=0; i<numnodes; i++) theNodes[i] = 0;
}
// full constructor
SSPquad::SSPquad(int tag, int Nd1, int Nd2, int Nd3, int Nd4, NDMaterial &theMat,
const char *type, double thick, double b1, double b2)
:Element(tag,ELE_TAG_SSPquad),
theMaterial(0),
mExternalNodes(SSPQ_NUM_NODE),
mTangentStiffness(SSPQ_NUM_DOF,SSPQ_NUM_DOF),
mInternalForces(SSPQ_NUM_DOF),
Q(SSPQ_NUM_DOF),
mMass(SSPQ_NUM_DOF,SSPQ_NUM_DOF),
mNodeCrd(2,4),
mStrain(3),
mStress(3),
Mmem(3,SSPQ_NUM_DOF),
Kmem(SSPQ_NUM_DOF,SSPQ_NUM_DOF),
Kstab(SSPQ_NUM_DOF,SSPQ_NUM_DOF),
mThickness(thick),
applyLoad(0)
{
mExternalNodes(0) = Nd1;
mExternalNodes(1) = Nd2;
mExternalNodes(2) = Nd3;
mExternalNodes(3) = Nd4;
mThickness = thick;
b[0] = b1;
b[1] = b2;
appliedB[0] = 0.0;
appliedB[1] = 0.0;
// get copy of the material object
NDMaterial *theMatCopy = theMat.getCopy(type);
if (theMatCopy != 0) {
theMaterial = (NDMaterial *)theMatCopy;
} else {
opserr << "SSPquad::SSPquad - failed to get copy of material model\n";;
}
// check material
if (theMaterial == 0) {
opserr << "SSPquad::SSPquad - failed to allocate material model pointer\n";
exit(-1);
}
// check the type
if (strcmp(type,"PlaneStrain") != 0 && strcmp(type,"PlaneStress") != 0) {
opserr << "SSPquad::SSPquad - improper material type: " << type << "for SSPquad\n";
exit(-1);
}
}
//full constructor
MembranePlateFiberSection::MembranePlateFiberSection(
int tag,
double thickness,
NDMaterial &Afiber ) :
SectionForceDeformation( tag, SEC_TAG_MembranePlateFiberSection ),
strainResultant(8)
{
this->h = thickness ;
int i ;
for ( i = 0; i < numFibers; i++ )
theFibers[i] = Afiber.getCopy( "PlateFiber" ) ;
}
BeamFiberMaterial::BeamFiberMaterial(int tag, NDMaterial &theMat)
: NDMaterial(tag, ND_TAG_BeamFiberMaterial),
Tstrain22(0.0), Tstrain33(0.0), Tgamma23(0.0),
Cstrain22(0.0), Cstrain33(0.0), Cgamma23(0.0),
theMaterial(0), strain(3)
{
// Get a copy of the material
theMaterial = theMat.getCopy("ThreeDimensional");
if (theMaterial == 0) {
opserr << "BeamFiberMaterial::BeamFiberMaterial -- failed to get copy of material\n";
exit(-1);
}
}
// constructor:
BiaxialFiber2d::BiaxialFiber2d(int tag,
NDMaterial &theMat,
double Area, double position):
Fiber(tag, FIBER_TAG_Biaxial2d),
theMaterial(0), area(Area), y(-position)
{
theMaterial = theMat.getCopy("BeamFiber2d"); // get a copy of the MaterialModel
if (theMaterial == 0) {
opserr <<"BiaxialFiber2d::BiaxialFiber2d -- failed to get copy of NDMaterial\n";
exit(-1);
}
if (code(0) != SECTION_RESPONSE_P) {
code(0) = SECTION_RESPONSE_P;
code(1) = SECTION_RESPONSE_MZ;
code(2) = SECTION_RESPONSE_VY;
}
}
//*********************************************************************
//full constructor
BbarBrick::BbarBrick( int tag,
int node1,
int node2,
int node3,
int node4,
int node5,
int node6,
int node7,
int node8,
NDMaterial &theMaterial,
double b1, double b2, double b3) :
Element( tag, ELE_TAG_BbarBrick ),
connectedExternalNodes(8), applyLoad(0), load(0), Ki(0)
{
connectedExternalNodes(0) = node1 ;
connectedExternalNodes(1) = node2 ;
connectedExternalNodes(2) = node3 ;
connectedExternalNodes(3) = node4 ;
connectedExternalNodes(4) = node5 ;
connectedExternalNodes(5) = node6 ;
connectedExternalNodes(6) = node7 ;
connectedExternalNodes(7) = node8 ;
int i ;
for ( i=0; i<8; i++ ) {
materialPointers[i] = theMaterial.getCopy("ThreeDimensional") ;
if (materialPointers[i] == 0) {
opserr <<"BbarBrick::constructor - failed to get a material of type: ThreeDimensional\n";
exit(-1);
} //end if
} //end for i
// Body forces
b[0] = b1;
b[1] = b2;
b[2] = b3;
}
BiaxialFiber3d::BiaxialFiber3d(int tag,
NDMaterial &theMat,
double Area, const Vector &position, double perpTheta)
:Fiber(tag, FIBER_TAG_Biaxial3d),
area(Area), R(perpTheta)
{
theMaterial = theMat.getCopy("BeamFiber2d"); // get a copy of the MaterialModel
if (theMaterial == 0) {
opserr << "BiaxialFiber3d::BiaxialFiber3d -- failed to get copy of NDMaterial\n";
exit(-1);
}
if (code(0) != SECTION_RESPONSE_P) {
code(0) = SECTION_RESPONSE_P;
code(1) = SECTION_RESPONSE_MZ;
code(2) = SECTION_RESPONSE_VY;
}
as[0] = -position(0);
as[1] = position(1);
}
//full constructor
NineNodeMixedQuad :: NineNodeMixedQuad( int tag,
int node1,
int node2,
int node3,
int node4,
int node5,
int node6,
int node7,
int node8,
int node9,
NDMaterial &theMaterial ) :
Element( tag, ELE_TAG_NineNodeMixedQuad ),
connectedExternalNodes(9) , load(0), Ki(0)
{
connectedExternalNodes(0) = node1 ;
connectedExternalNodes(1) = node2 ;
connectedExternalNodes(2) = node3 ;
connectedExternalNodes(3) = node4 ;
connectedExternalNodes(4) = node5 ;
connectedExternalNodes(5) = node6 ;
connectedExternalNodes(6) = node7 ;
connectedExternalNodes(7) = node8 ;
connectedExternalNodes(8) = node9 ;
int i ;
for ( i=0 ; i<9; i++ ) {
materialPointers[i] = theMaterial.getCopy("AxiSymmetric2D") ;
if (materialPointers[i] == 0) {
opserr << "NineNodeMixedQuad::constructor() - failed to get a material of type: AxiSymmetric2D\n";
} //end if
} //end for i
}
// constructors:
TimoshenkoSection2d::TimoshenkoSection2d(int tag, int num, Fiber **fibers):
SectionForceDeformation(tag, SEC_TAG_TimoshenkoSection2d),
numFibers(num), theMaterials(0), matData(0), yh(0.0), zh(0.0),
yBar(0.0), zBar(0.0), e(3), eCommit(3), s(0), ks(0)
{
if (numFibers != 0) {
theMaterials = new NDMaterial*[numFibers];
if (theMaterials == 0) {
opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to allocate Material pointers\n";
exit(-1);
}
matData = new double [numFibers*3];
if (matData == 0) {
opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to allocate double array for material data\n";
exit(-1);
}
double Qz = 0.0;
double Qy = 0.0;
double a = 0.0;
double yHmin=0, zHmin=0, yHmax=0, zHmax=0;
NDMaterial *theMat;
for (int i = 0; i < numFibers; i++) {
double yLoc, zLoc, Area;
fibers[i]->getFiberLocation(yLoc, zLoc);
Area = fibers[i]->getArea();
theMat = fibers[i]->getNDMaterial();
if (theMat == 0) {
opserr << "TimoshenkoSection3d::TimoshenkoSection3d -- failed to get fiber information" << endln;
}
Qz += yLoc*Area;
Qy += zLoc*Area;
a += Area;
matData[i*3] = yLoc;
matData[i*3+1] = zLoc;
matData[i*3+2] = Area;
theMaterials[i] = theMat->getCopy("BeamFiber2d") ; // theMat.getCopy("TimoshenkoFiber");
if (theMaterials[i] == 0)
opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to get copy of beam fiber" << endln;
if (yLoc < yHmin ) yHmin=yLoc;
if (zLoc < zHmin ) zHmin=zLoc;
if (yLoc > yHmax ) yHmax=yLoc;
if (zLoc > zHmax ) zHmax=zLoc;
}
yBar = Qz/a;
zBar = Qy/a;
zh = yHmax - yHmin;
yh = zHmax - zHmin;
}
s = new Vector(sData, 3);
ks = new Matrix(kData, 3, 3);
for (int i=0; i<9; i++)
kData[i] = 0.0;
for (int i=0; i<3; i++)
sData[i] = 0.0;
code(0) = SECTION_RESPONSE_P;
code(1) = SECTION_RESPONSE_MZ;
code(2) = SECTION_RESPONSE_VY;
}
FourNodeQuadWithSensitivity::FourNodeQuadWithSensitivity(int tag, int nd1, int nd2, int nd3, int nd4,
NDMaterial &m, const char *type, double t,
double p, double r, double b1, double b2)
:Element (tag, ELE_TAG_FourNodeQuadWithSensitivity),
theMaterial(0), connectedExternalNodes(4),
Q(8), pressureLoad(8), applyLoad(0), thickness(t), rho(r), pressure(p), Ki(0)
{
pts[0][0] = -0.5773502691896258;
pts[0][1] = -0.5773502691896258;
pts[1][0] = 0.5773502691896258;
pts[1][1] = -0.5773502691896258;
pts[2][0] = 0.5773502691896258;
pts[2][1] = 0.5773502691896258;
pts[3][0] = -0.5773502691896258;
pts[3][1] = 0.5773502691896258;
wts[0] = 1.0;
wts[1] = 1.0;
wts[2] = 1.0;
wts[3] = 1.0;
if (strcmp(type,"PlaneStrain") != 0 && strcmp(type,"PlaneStress") != 0
&& strcmp(type,"PlaneStrain2D") != 0 && strcmp(type,"PlaneStress2D") != 0) {
opserr << "FourNodeQuadWithSensitivity::FourNodeQuadWithSensitivity -- improper material type: " << type << "for FourNodeQuadWithSensitivity\n";
exit(-1);
}
// Body forces
b[0] = b1;
b[1] = b2;
// Allocate arrays of pointers to NDMaterials
theMaterial = new NDMaterial *[4];
if (theMaterial == 0) {
opserr << "FourNodeQuadWithSensitivity::FourNodeQuadWithSensitivity - failed allocate material model pointer\n";
exit(-1);
}
int i;
for (i = 0; i < 4; i++) {
// Get copies of the material model for each integration point
theMaterial[i] = m.getCopy(type);
// Check allocation
if (theMaterial[i] == 0) {
opserr << "FourNodeQuadWithSensitivity::FourNodeQuadWithSensitivity -- failed to get a copy of material model\n";
exit(-1);
}
}
// Set connected external node IDs
connectedExternalNodes(0) = nd1;
connectedExternalNodes(1) = nd2;
connectedExternalNodes(2) = nd3;
connectedExternalNodes(3) = nd4;
for (i=0; i<4; i++)
theNodes[i] = 0;
// AddingSensitivity:BEGIN ////////////////////////////////
parameterID = 0;
// AddingSensitivity:END /////////////////////////////////
}
TwentyEightNodeBrickUP::TwentyEightNodeBrickUP(int tag,
int node1,
int node2,
int node3,
int node4,
int node5,
int node6,
int node7,
int node8,
int node9,
int node10,
int node11,
int node12,
int node13,
int node14,
int node15,
int node16,
int node17,
int node18,
int node19,
int node20,
NDMaterial &theMaterial, double bulk, double rhof,
double p1, double p2, double p3,
double b1, double b2, double b3) :Element( tag, ELE_TAG_Twenty_Eight_Node_BrickUP ),
connectedExternalNodes(20), applyLoad(0), load(0), Ki(0), kc(bulk), rho(rhof)
{
connectedExternalNodes(0) = node1 ;
connectedExternalNodes(1) = node2 ;
connectedExternalNodes(2) = node3 ;
connectedExternalNodes(3) = node4 ;
connectedExternalNodes(4) = node5 ;
connectedExternalNodes(5) = node6 ;
connectedExternalNodes(6) = node7 ;
connectedExternalNodes(7) = node8 ;
connectedExternalNodes(8) = node9 ;
connectedExternalNodes(9) = node10 ;
connectedExternalNodes(10) = node11 ;
connectedExternalNodes(11) = node12 ;
connectedExternalNodes(12) = node13 ;
connectedExternalNodes(13) = node14 ;
connectedExternalNodes(14) = node15 ;
connectedExternalNodes(15) = node16 ;
connectedExternalNodes(16) = node17 ;
connectedExternalNodes(17) = node18 ;
connectedExternalNodes(18) = node19 ;
connectedExternalNodes(19) = node20 ;
int i ;
// Allocate arrays of pointers to NDMaterials
materialPointers = new NDMaterial *[nintu];
if (materialPointers == 0) {
opserr << "TwentyEightNodeBrickUP::TwentyEightNodeBrickUP - failed allocate material model pointer\n";
exit(-1);
}
for ( i=0; i<nintu; i++ ) {
materialPointers[i] = theMaterial.getCopy("ThreeDimensional") ;
if (materialPointers[i] == 0) {
opserr <<"TwentyEightNodeBrickUP::constructor - failed to get a material of type: ThreeDimensional\n";
exit(-1);
} //end if
} //end for i
// Body forces
b[0] = b1;
b[1] = b2;
b[2] = b3;
// Permeabilities
perm[0] = p1;
perm[1] = p2;
perm[2] = p3;
//printf("b %15.6e %15.6e %15.6e perm %15.6e %15.6e %15.6e\n", b1, b2,b3,p1,p2,p3);
// calculate local shape functions and derivatives
compuLocalShapeFunction();
}
// full constructor
SSPquadUP::SSPquadUP(int tag, int Nd1, int Nd2, int Nd3, int Nd4, NDMaterial &theMat,
double thick, double Kf, double Rf, double k1, double k2,
double eVoid, double alpha, double b1, double b2)
:Element(tag,ELE_TAG_SSPquadUP),
theMaterial(0),
mExternalNodes(SQUP_NUM_NODE),
mTangentStiffness(SQUP_NUM_DOF,SQUP_NUM_DOF),
mInternalForces(SQUP_NUM_DOF),
Q(SQUP_NUM_DOF),
mMass(SQUP_NUM_DOF,SQUP_NUM_DOF),
mDamp(SQUP_NUM_DOF,SQUP_NUM_DOF),
mNodeCrd(2,4),
dN(4,2),
Mmem(3,8),
Kstab(8,8),
mSolidK(8,8),
mSolidM(8,8),
mPerm(4,4),
mThickness(thick),
fBulk(Kf),
fDens(Rf),
mAlpha(alpha),
mPorosity(0),
applyLoad(0)
{
mExternalNodes(0) = Nd1;
mExternalNodes(1) = Nd2;
mExternalNodes(2) = Nd3;
mExternalNodes(3) = Nd4;
mThickness = thick;
fBulk = Kf;
fDens = Rf;
mAlpha = alpha;
b[0] = b1;
b[1] = b2;
appliedB[0] = 0.0;
appliedB[1] = 0.0;
perm[0] = k1;
perm[1] = k2;
mPorosity = eVoid/(1.0 + eVoid);
const char *type = "PlaneStrain";
// get copy of the material object
NDMaterial *theMatCopy = theMat.getCopy(type);
if (theMatCopy != 0) {
theMaterial = (NDMaterial *)theMatCopy;
} else {
opserr << "SSPquadUP::SSPquadUP - failed to get copy of material model\n";;
}
// check material
if (theMaterial == 0) {
opserr << "SSPquadUP::SSPquadUP - failed to allocate material model pointer\n";
exit(-1);
}
}
// constructors
BeamContact2D::BeamContact2D(int tag, int Nd1, int Nd2, int NdS, int NdL, NDMaterial &theMat,
double width, double tolG, double tolF, int cSwitch)
:Element(tag,ELE_TAG_BeamContact2D),
theMaterial(0),
mExternalNodes(BC2D_NUM_NODE),
mTangentStiffness(BC2D_NUM_DOF, BC2D_NUM_DOF),
mInternalForces(BC2D_NUM_DOF),
mEye1(BC2D_NUM_DIM, BC2D_NUM_DIM),
mEyeS(BC2D_NUM_DIM, BC2D_NUM_DIM),
mg_xi(BC2D_NUM_DIM),
mNormal(BC2D_NUM_DIM),
mShape(4),
mDshape(4),
mBn(BC2D_NUM_DOF-2),
mBs(BC2D_NUM_DOF-2),
ma_1(BC2D_NUM_DIM),
mb_1(BC2D_NUM_DIM),
mc_1(BC2D_NUM_DIM),
mIcrd_a(BC2D_NUM_DIM),
mIcrd_b(BC2D_NUM_DIM),
mIcrd_s(BC2D_NUM_DIM),
mDcrd_a(BC2D_NUM_DIM),
mDcrd_b(BC2D_NUM_DIM),
mDcrd_s(BC2D_NUM_DIM),
mDisp_a_n(3),
mDisp_b_n(3),
mIniContact(cSwitch)
{
mExternalNodes(0) = Nd1;
mExternalNodes(1) = Nd2;
mExternalNodes(2) = NdS;
mExternalNodes(3) = NdL;
mRadius = width/2;
mGapTol = tolG;
mForceTol = tolF;
mIniContact = cSwitch;
if (mIniContact == 0) {
inContact = true;
was_inContact = true;
to_be_released = false;
should_be_released = false;
in_bounds = true;
} else {
inContact = false;
was_inContact = false;
to_be_released = false;
should_be_released = false;
in_bounds = true;
}
mGap = 0.0;
mLambda = 0.0;
// get copy of the material object
NDMaterial *theMatCopy = theMat.getCopy("ContactMaterial2D");
if (theMatCopy != 0) {
theMaterial = (ContactMaterial2D *)theMatCopy;
} else {
opserr << "BeamContact2D::BeamContact2D - material needs to be of type ContactMaterial2D for ele: " << this->getTag() << endln;
}
// check material
if (theMaterial == 0) {
opserr << "BeamContact2D::BeamContact2D - failed allocate material model pointer\n";
exit(-1);
}
}
TotalLagrangianFD8NodeBrick::TotalLagrangianFD8NodeBrick(int tag,
int node_numb_1, int node_numb_2, int node_numb_3, int node_numb_4,
int node_numb_5, int node_numb_6, int node_numb_7, int node_numb_8,
NDMaterial &m, double b1, double b2, double b3)
:Element(tag, ELE_TAG_TotalLagrangianFD8NodeBrick ),
theMaterial(0), connectedExternalNodes(NumNodes), Q(0), bf(NumDof), Ki(0)
{
connectedExternalNodes( 0) = node_numb_1;
connectedExternalNodes( 1) = node_numb_2;
connectedExternalNodes( 2) = node_numb_3;
connectedExternalNodes( 3) = node_numb_4;
connectedExternalNodes( 4) = node_numb_5;
connectedExternalNodes( 5) = node_numb_6;
connectedExternalNodes( 6) = node_numb_7;
connectedExternalNodes( 7) = node_numb_8;
bf(0) = b1;
bf(1) = b2;
bf(2) = b3;
theMaterial = new NDMaterial *[NumTotalGaussPts];
if (theMaterial == 0) {
opserr<<"FiniteDeformationElastic3D::FiniteDeformationElastic3D -- failed allocate material model pointer\n";
exit(-1);
}
int i;
for (i=0; i<NumTotalGaussPts; i++) {
theMaterial[i] = m.getCopy();
if (theMaterial[i] == 0) {
opserr<<"FiniteDeformationElastic3D::FiniteDeformationElastic3D -- failed allocate material model pointer\n";
exit(-1);
}
}
rho = m.getRho();
for (i=0; i<NumNodes; i++) theNodes[i] = 0;
}
// constructors
BeamContact2Dp::BeamContact2Dp(int tag, int Nd1, int Nd2, int NdS, NDMaterial &theMat, double width, double pen, int cSwitch)
:Element(tag,ELE_TAG_BeamContact2Dp),
theMaterial(0),
mExternalNodes(BC2D_NUM_NODE),
mTangentStiffness(BC2D_NUM_DOF, BC2D_NUM_DOF),
mInternalForces(BC2D_NUM_DOF),
mEye1(BC2D_NUM_DIM, BC2D_NUM_DIM),
mEyeS(BC2D_NUM_DIM, BC2D_NUM_DIM),
mg_xi(BC2D_NUM_DIM),
mNormal(BC2D_NUM_DIM),
mShape(4),
mDshape(4),
mBn(BC2D_NUM_DOF),
mBs(BC2D_NUM_DOF),
ma_1(BC2D_NUM_DIM),
mb_1(BC2D_NUM_DIM),
mc_1(BC2D_NUM_DIM),
mIcrd_a(BC2D_NUM_DIM),
mIcrd_b(BC2D_NUM_DIM),
mIcrd_s(BC2D_NUM_DIM),
mDcrd_a(BC2D_NUM_DIM),
mDcrd_b(BC2D_NUM_DIM),
mDcrd_s(BC2D_NUM_DIM),
mDisp_a_n(3),
mDisp_b_n(3)
{
mExternalNodes(0) = Nd1;
mExternalNodes(1) = Nd2;
mExternalNodes(2) = NdS;
// input parameters
mRadius = width/2.0;
mPenalty = pen;
mIniContact = cSwitch;
// initialize contact state
if (mIniContact == 0) {
inContact = true;
was_inContact = true;
in_bounds = true;
} else {
inContact = false;
was_inContact = false;
in_bounds = true;
}
// initialize penetration function and contact force
mGap = 0.0;
mLambda = 0.0;
// get copy of the material object
NDMaterial *theMatCopy = theMat.getCopy("ContactMaterial2D");
if (theMatCopy != 0) {
theMaterial = (ContactMaterial2D *)theMatCopy;
} else {
opserr << "BeamContact2Dp::BeamContact2Dp - material needs to be of type ContactMaterial2D for ele: " << this->getTag() << endln;
}
// check material
if (theMaterial == 0) {
opserr << "BeamContact2Dp::BeamContact2Dp - failed allocate material model pointer\n";
exit(-1);
}
}
int
TimoshenkoSection2d::addFiber(Fiber &newFiber)
{
// need to create larger arrays
int newSize = numFibers+1;
NDMaterial **newArray = new NDMaterial *[newSize];
double *newMatData = new double [3 * newSize];
if (newArray == 0 || newMatData == 0) {
opserr <<"TimoshenkoSection2d::addFiber -- failed to allocate Fiber pointers\n";
return -1;
}
// copy the old pointers and data
int i;
for (i = 0; i < numFibers; i++) {
newArray[i] = theMaterials[i];
newMatData[3*i] = matData[3*i];
newMatData[3*i+1] = matData[3*i+1];
newMatData[3*i+2] = matData[3*i+2];
}
// set the new pointers and data
double yLoc, zLoc, Area;
newFiber.getFiberLocation(yLoc, zLoc);
Area = newFiber.getArea();
newMatData[numFibers*3] = yLoc;
newMatData[numFibers*3+1] = zLoc;
newMatData[numFibers*3+2] = Area;
NDMaterial *theMat = newFiber.getNDMaterial();
newArray[numFibers] = theMat->getCopy("BeamFiber2d");
if (newArray[numFibers] == 0) {
opserr <<"TimoshenkoSection2d::addFiber -- failed to get copy of a Material\n";
delete [] newMatData;
return -1;
}
numFibers++;
if (theMaterials != 0) {
delete [] theMaterials;
delete [] matData;
}
theMaterials = newArray;
matData = newMatData;
double Qz = 0.0;
double Qy = 0.0;
double A = 0.0;
// Recompute centroid
for (i = 0; i < numFibers; i++) {
yLoc = matData[3*i];
zLoc = matData[3*i+1];
Area = matData[3*i+2];
A += Area;
Qz += yLoc*Area;
Qy += zLoc*Area;
}
yBar = Qz/A;
zBar = Qy/A;
return 0;
}