int AbaqusUserMaterial :: giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep)
{
AbaqusUserMaterialStatus *ms = static_cast< AbaqusUserMaterialStatus * >( this->giveStatus(gp) );
if ( type == IST_Undefined || type == IST_AbaqusStateVector ) {
// The undefined value is used to just dump the entire state vector.
answer = ms->giveStateVector();
return 1;
} else if ( type == IST_StressTensor ) {
answer = ms->giveStressVector();
answer.add(initialStress);
return 1;
} else {
return StructuralMaterial :: giveIPValue(answer, gp, type, tStep);
}
}
void AbaqusUserMaterial :: giveRealStressVector_3d(FloatArray &answer, GaussPoint *gp,
const FloatArray &reducedStrain, TimeStep *tStep)
{
AbaqusUserMaterialStatus *ms = static_cast< AbaqusUserMaterialStatus * >( this->giveStatus(gp) );
/* User-defined material name, left justified. Some internal material models are given names starting with
* the “ABQ_” character string. To avoid conflict, you should not use “ABQ_” as the leading string for
* CMNAME. */
//char cmname[80];
// Sizes of the tensors.
int ndi = 3;
int nshr = 3;
int ntens = ndi + nshr;
FloatArray strain = ms->giveStrainVector();
FloatArray stress = ms->giveStressVector();
// adding the initial stress
stress.add(initialStress);
FloatArray strainIncrement;
strainIncrement.beDifferenceOf(reducedStrain, strain);
FloatArray state = ms->giveStateVector();
FloatMatrix jacobian(ntens, ntens);
int numProperties = this->properties.giveSize();
// Temperature and increment
double temp = 0.0, dtemp = 0.0;
// Times and increment
double dtime = tStep->giveTimeIncrement();
///@todo Check this. I'm just guessing. Maybe intrinsic time instead?
double time [ 2 ] = {
tStep->giveTargetTime() - dtime, tStep->giveTargetTime()
};
double pnewdt = 1.0; ///@todo Right default value? umat routines may change this (although we ignore it)
/* Specific elastic strain energy, plastic dissipation, and “creep” dissipation, respectively. These are passed
* in as the values at the start of the increment and should be updated to the corresponding specific energy
* values at the end of the increment. They have no effect on the solution, except that they are used for
* energy output. */
double sse, spd, scd;
// Outputs only in a fully coupled thermal-stress analysis:
double rpl = 0.0; // Volumetric heat generation per unit time at the end of the increment caused by mechanical working of the material.
FloatArray ddsddt(ntens); // Variation of the stress increments with respect to the temperature.
FloatArray drplde(ntens); // Variation of RPL with respect to the strain increments.
double drpldt = 0.0; // Variation of RPL with respect to the temperature.
/* An array containing the coordinates of this point. These are the current coordinates if geometric
* nonlinearity is accounted for during the step (see “Procedures: overview,” Section 6.1.1); otherwise,
* the array contains the original coordinates of the point */
FloatArray coords;
gp->giveElement()->computeGlobalCoordinates( coords, gp->giveNaturalCoordinates() );
/* Rotation increment matrix. This matrix represents the increment of rigid body rotation of the basis
* system in which the components of stress (STRESS) and strain (STRAN) are stored. It is provided so
* that vector- or tensor-valued state variables can be rotated appropriately in this subroutine: stress and
* strain components are already rotated by this amount before UMAT is called. This matrix is passed in
* as a unit matrix for small-displacement analysis and for large-displacement analysis if the basis system
* for the material point rotates with the material (as in a shell element or when a local orientation is used).*/
FloatMatrix drot(3, 3);
drot.beUnitMatrix();
/* Characteristic element length, which is a typical length of a line across an element for a first-order
* element; it is half of the same typical length for a second-order element. For beams and trusses it is a
* characteristic length along the element axis. For membranes and shells it is a characteristic length in
* the reference surface. For axisymmetric elements it is a characteristic length in the
* plane only.
* For cohesive elements it is equal to the constitutive thickness.*/
double celent = 0.0; /// @todo Include the characteristic element length
/* Array containing the deformation gradient at the beginning of the increment. See the discussion
* regarding the availability of the deformation gradient for various element types. */
FloatMatrix dfgrd0(3, 3);
dfgrd0.beUnitMatrix();
/* Array containing the deformation gradient at the end of the increment. The components of this array
* are set to zero if nonlinear geometric effects are not included in the step definition associated with
* this increment. See the discussion regarding the availability of the deformation gradient for various
* element types. */
FloatMatrix dfgrd1(3, 3);
dfgrd1.beUnitMatrix();
int noel = gp->giveElement()->giveNumber(); // Element number.
int npt = 0; // Integration point number.
int layer = 0; // Layer number (for composite shells and layered solids)..
int kspt = 0; // Section point number within the current layer.
int kstep = 0; // Step number.
int kinc = 0; // Increment number.
///@todo No idea about these parameters
double predef;
double dpred;
// Change to Abaqus's component order
stress.changeComponentOrder();
strain.changeComponentOrder();
strainIncrement.changeComponentOrder();
// printf("stress oofem: "); stress.printYourself();
OOFEM_LOG_DEBUG("AbaqusUserMaterial :: giveRealStressVector_3d - Calling subroutine");
this->umat(stress.givePointer(), // STRESS
state.givePointer(), // STATEV
jacobian.givePointer(), // DDSDDE
& sse, // SSE
& spd, // SPD
& scd, // SCD
& rpl, // RPL
ddsddt.givePointer(), // DDSDDT
drplde.givePointer(), // DRPLDE
& drpldt, // DRPLDT
strain.givePointer(), // STRAN
strainIncrement.givePointer(), // DSTRAN
time, // TIME
& dtime, // DTIME
& temp, // TEMP
& dtemp, // DTEMP
& predef, // PREDEF
& dpred, // DPRED
this->cmname, // CMNAME
& ndi, // NDI
& nshr, // NSHR
& ntens, // NTENS
& numState, // NSTATV
properties.givePointer(), // PROPS
& numProperties, // NPROPS
coords.givePointer(), // COORDS
drot.givePointer(), // DROT
& pnewdt, // PNEWDT
& celent, // CELENT
dfgrd0.givePointer(), // DFGRD0
dfgrd1.givePointer(), // DFGRD1
& noel, // NOEL
& npt, // NPT
& layer, // LAYER
& kspt, // KSPT
& kstep, // KSTEP
& kinc); // KINC
// Change to OOFEM's component order
stress.changeComponentOrder();
// subtracking the initial stress
stress.subtract(initialStress);
strain.changeComponentOrder();
strainIncrement.changeComponentOrder();
jacobian.changeComponentOrder();
ms->letTempStrainVectorBe(reducedStrain);
ms->letTempStressVectorBe(stress);
ms->letTempStateVectorBe(state);
ms->letTempTangentBe(jacobian);
answer = stress;
OOFEM_LOG_DEBUG("AbaqusUserMaterial :: giveRealStressVector - Calling subroutine was successful");
}
