void KelvinChainSolidMaterial :: giveEigenStrainVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep, ValueModeType mode) // // computes the strain due to creep at constant stress during the increment // (in fact, the INCREMENT of creep strain is computed for mode == VM_Incremental) // { int mu; double betaMu; double v; FloatArray *sigmaVMu = NULL, reducedAnswer, help; FloatMatrix C; KelvinChainSolidMaterialStatus *status = static_cast< KelvinChainSolidMaterialStatus * >( this->giveStatus(gp) ); if ( (tStep->giveIntrinsicTime() < this->castingTime) ) { OOFEM_ERROR("Attempted to evaluate creep strain for time lower than casting time"); } if ( this->EparVal.isEmpty() ) { this->updateEparModuli(0., gp, tStep); // stiffnesses are time independent (evaluated at time t = 0.) } if ( mode == VM_Incremental ) { for ( mu = 1; mu <= nUnits; mu++ ) { betaMu = this->computeBetaMu(gp, tStep, mu); sigmaVMu = & status->giveHiddenVarsVector(mu); // JB if ( sigmaVMu->isNotEmpty() ) { help.zero(); help.add(* sigmaVMu); help.times( ( 1.0 - betaMu ) / this->giveEparModulus(mu) ); reducedAnswer.add(help); } } if ( sigmaVMu->isNotEmpty() ) { help = reducedAnswer; this->giveUnitComplianceMatrix(C, gp, tStep); reducedAnswer.beProductOf(C, help); v = this->computeSolidifiedVolume(gp, tStep); reducedAnswer.times(1. / v); } answer = reducedAnswer; } else { /* error - total mode not implemented yet */ OOFEM_ERROR("mode is not supported"); } }
double J2MPlasticMaterial :: computeYieldValueAt(GaussPoint *gp, int isurf, const FloatArray &stressVector, const FloatArray &stressSpaceHardeningVars) { double f; FloatArray helpVector, backStress; if ( this->kinematicHardeningFlag ) { if ( stressVector.isNotEmpty() ) { this->giveStressBackVector(backStress, stressSpaceHardeningVars); helpVector = stressVector; helpVector.add(backStress); } else { return -k; } } else { helpVector = stressVector; } f = sqrt( this->computeJ2InvariantAt(helpVector) ); //if (this->kinematicHardeningFlag) delete helpVector; return f + sqrt(1. / 3.) * this->giveIsotropicHardeningVar(stressSpaceHardeningVars) - this->k; }
void Beam2d :: giveEndForcesVector(FloatArray &answer, TimeStep *tStep) { // stress equivalent vector in nodes (vector of internal forces) FloatArray load; this->giveInternalForcesVector(answer, tStep, false); // subtract exact end forces due to nonnodal loading this->computeLocalForceLoadVector(load, tStep, VM_Total); if ( load.isNotEmpty() ) { answer.subtract(load); } }
void J2Mat :: computeStressGradientVector(FloatArray &answer, functType ftype, int isurf, GaussPoint *gp, const FloatArray &stressVector, const FloatArray &strainSpaceHardeningVars) { /* stress gradient of yield function in full stress - strain space */ double f, ax, ay, az, sx, sy, sz; FloatArray helpVector, backStress; answer.resize(6); answer.zero(); if ( this->kinematicHardeningFlag ) { if ( stressVector.isNotEmpty() ) { this->giveStressBackVector(backStress, gp, strainSpaceHardeningVars); helpVector = stressVector; helpVector.add(backStress); } else { return; } } else { helpVector = stressVector; } f = sqrt( this->computeJ2InvariantAt(helpVector) ); // check for yield value zero value if ( fabs(f) < 1.e-6 ) { return; } ax = helpVector.at(1); ay = helpVector.at(2); az = helpVector.at(3); sx = ( 2. / 3. ) * ax - ( 1. / 3. ) * ay - ( 1. / 3. ) * az; sy = ( 2. / 3. ) * ay - ( 1. / 3. ) * ax - ( 1. / 3. ) * az; sz = ( 2. / 3. ) * az - ( 1. / 3. ) * ay - ( 1. / 3. ) * ax; answer.at(1) = 0.5 * sx / f; answer.at(2) = 0.5 * sy / f; answer.at(3) = 0.5 * sz / f; answer.at(4) = helpVector.at(4) / f; answer.at(5) = helpVector.at(5) / f; answer.at(6) = helpVector.at(6) / f; }
void GradDpElement :: computeLocForceLoadVector(FloatArray &answer, TimeStep *tStep, ValueModeType mode) // computes the part of load vector, which is imposed by force loads acting // on element volume (surface). // When reactions forces are computed, they are computed from element::GiveRealStressVector // in this vector a real forces are stored (temperature part is subtracted). // so we need further sobstract part corresponding to non-nodeal loading. { FloatMatrix T; NLStructuralElement *elem = this->giveNLStructuralElement(); elem->computeLocalForceLoadVector(answer, tStep, mode); // transform result from global cs to nodal cs. if necessary if ( answer.isNotEmpty() ) { if ( elem->computeGtoLRotationMatrix(T) ) { // first back to global cs from element local answer.rotatedWith(T, 't'); } } else { answer.resize(locSize); answer.zero(); } }