Esempio n. 1
0
// 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;
}
Esempio n. 2
0
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 

}
Esempio n. 5
0
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;
}
Esempio n. 7
0
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);
  }
}
Esempio n. 9
0
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;
}
Esempio n. 10
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" ) ;

}
Esempio n. 12
0
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);
  }
}
Esempio n. 13
0
// 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;
  }
}
Esempio n. 14
0
//*********************************************************************
//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;
}
Esempio n. 15
0
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);

}
Esempio n. 16
0
//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 
}
Esempio n. 17
0
// 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();



}
Esempio n. 20
0
// 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);
	}
}
Esempio n. 21
0
// 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;



}
Esempio n. 23
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);
	}
}
Esempio n. 24
0
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;
}