double
HydratingHeMoMaterial :: giveCharacteristicValue(MatResponseMode rmode, GaussPoint *gp, TimeStep *tStep)
{
double answer = 0;
if ( ( rmode >= Capacity_ww ) && ( rmode <= Capacity_wh ) ) { // standard HeMoTK values
answer = HeMoTKMaterial :: giveCharacteristicValue(rmode, gp, tStep);
if ( castAt && ( tStep->giveTargetTime() < castAt ) ) {
answer *= PRECAST_CAPACITY_COEFF; // ~Zero capacity before cast
}
} else if ( ( rmode >= IntSource_ww ) && ( rmode <= IntSource_wh ) ) { // Internal source values
if ( !hydrationLHS ) {
answer = 0;
} else if ( hydrationModel ) { //!!! better via HydrationModelInterface
FloatArray vec = static_cast< TransportMaterialStatus * >( giveStatus(gp) )->giveTempField();
if ( vec.giveSize() < 2 ) {
vec.resize(2);
vec.at(2) = 1.0; // saturated if undefined
} else {
vec.at(2) = inverse_sorption_isotherm( vec.at(2) ); // compute relative humidity
}
answer = hydrationModel->giveCharacteristicValue(vec, rmode, gp, tStep)
/ tStep->giveTimeIncrement();
if ( ( rmode == IntSource_ww ) || ( rmode == IntSource_hw ) ) {
answer *= give_dphi_dw( vec.at(2) );
}
}
} else {
OOFEM_ERROR("unknown MatResponseMode (%s)", __MatResponseModeToString(rmode) );
}
return answer;
}
double
HydratingIsoHeatMaterial :: giveCharacteristicValue(MatResponseMode rmode, GaussPoint *gp, TimeStep *tStep)
{
double answer = 0;
FloatArray vec;
if ( rmode == Capacity ) {
if ( castAt && ( tStep->giveTargetTime() < castAt ) ) {
answer = this->give('c', gp, tStep) * this->give('d', gp, tStep) / 1000; // Zero capacity before cast
} else {
answer = this->give('c', gp, tStep) * this->give('d', gp, tStep);
}
} else if ( !hydrationLHS ) {
answer = 0;
} else if ( hydrationModel ) { //!!! better via HydrationModelInterface
vec = static_cast< TransportMaterialStatus * >( giveStatus(gp) )->giveTempField();
if ( vec.giveSize() < 2 ) {
vec.resize(2);
vec.at(2) = 1.; // saturated if undefined
}
answer = hydrationModel->giveCharacteristicValue(vec, rmode, gp, tStep)
/ tStep->giveTimeIncrement();
} else {
OOFEM_ERROR("unknown MatResponseMode (%s)", __MatResponseModeToString(rmode) );
}
return answer;
}
double
AnisotropicMassTransferMaterial :: giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime)
{
_error2( "giveCharacteristicValue : unknown mode (%s)", __MatResponseModeToString(mode) );
return 0.;
}
double
AnisotropicMassTransferMaterial :: giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
OOFEM_ERROR("unknown mode (%s)", __MatResponseModeToString(mode) );
return 0.;
}
bool
HeMoTKMaterial :: isCharacteristicMtrxSymmetric(MatResponseMode mode)
{
if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) {
return false;
} else {
_error2( "isCharacteristicMtrxSymmetric : unknown mode (%s)", __MatResponseModeToString(mode) );
}
return false; // to make compiler happy
}
double
IsotropicMoistureTransferMaterial :: giveCharacteristicValue(MatResponseMode mode,
GaussPoint *gp,
TimeStep *tStep)
{
if ( mode == Capacity ) {
return ( this->giveMoistureCapacity(gp, tStep) );
} else {
OOFEM_ERROR("unknown mode (%s)", __MatResponseModeToString(mode) );
}
return 0.;
}
double
IsotropicHeatTransferMaterial :: giveCharacteristicValue(MatResponseMode mode,
GaussPoint *gp,
TimeStep *atTime)
{
if ( mode == Capacity ) {
return ( capacity * this->give('d', gp) );
} else {
_error2( "giveCharacteristicValue : unknown mode (%s)", __MatResponseModeToString(mode) );
}
return 0.;
}
void
HeMoTKMaterial :: giveCharacteristicMatrix(FloatMatrix &answer,
MatResponseMode mode,
GaussPoint *gp,
TimeStep *tStep)
{
/*
* returns constitutive matrix of receiver
*/
if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) {
this->computeConductivityMtrx(answer, mode, gp, tStep);
} else {
OOFEM_ERROR("unknown mode (%s)", __MatResponseModeToString(mode) );
}
}
double
HydratingConcreteMat :: giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime)
{
if ( mode == Capacity ) {
return ( giveConcreteCapacity(gp) * giveConcreteDensity(gp) );
} else if ( mode == IntSource ) { //for nonlinear solver, return dHeat/dTemperature
HydratingConcreteMatStatus *ms = ( HydratingConcreteMatStatus * ) this->giveStatus(gp);
//it suffices to compute derivative of scaling Arrhenius equation with respect to temporary temperature
double stateVec = ms->giveStateVector().at(1) + 273.15;
double tempStateVec = ms->giveTempStateVector().at(1) + 273.15;
return this->activationEnergy / ( 8.314 * tempStateVec * tempStateVec) * exp(1. / stateVec - 1. / tempStateVec ) ;
} else {
OOFEM_ERROR2( "giveCharacteristicValue : unknown mode (%s)\n", __MatResponseModeToString(mode) );
}
return 0.;
}
void
SimpleInterfaceMaterial :: giveStiffnessMatrix(FloatMatrix &answer,
MatResponseMode rMode,
GaussPoint *gp, TimeStep *tStep)
//
// Returns characteristic material stiffness matrix of the receiver
//
{
MaterialMode mMode = gp->giveElement()->giveMaterialMode();
FloatArray strainVector;
StructuralElement *el = static_cast< StructuralElement * >( gp->giveElement() );
double normalStrain;
el->computeStrainVector(strainVector, gp, tStep);
normalStrain = strainVector.at(1);
answer.zero();
switch ( mMode ) {
case _1dInterface:
answer.resize(1, 1);
if ( rMode == SecantStiffness || rMode == TangentStiffness ) {
if ( normalStrain + normalClearance <= 0 ) {
answer.at(1, 1) = this->kn; //in compression and after the clearance gap closed
} else {
answer.at(1, 1) = this->kn * this->stiffCoeff;
}
} else {
if ( rMode == ElasticStiffness ) {
answer.at(1, 1) = this->kn;
} else {
OOFEM_ERROR("unknown MatResponseMode (%s)", __MatResponseModeToString(rMode) );
}
}
return;
case _2dInterface:
answer.resize(2, 2);
if ( rMode == SecantStiffness || rMode == TangentStiffness ) {
if ( normalStrain + normalClearance <= 0. ) {
answer.at(1, 1) = answer.at(2, 2) = this->kn; //in compression and after the clearance gap closed
} else {
answer.at(1, 1) = answer.at(2, 2) = this->kn * this->stiffCoeff;
}
} else {
if ( rMode == ElasticStiffness ) {
answer.at(1, 1) = answer.at(2, 2) = this->kn;
} else {
OOFEM_ERROR("unknown MatResponseMode (%s)", __MatResponseModeToString(rMode) );
}
}
return;
case _3dInterface:
answer.resize(3, 3);
if ( rMode == SecantStiffness || rMode == TangentStiffness ) {
if ( normalStrain + normalClearance <= 0. ) {
answer.at(1, 1) = answer.at(2, 2) = answer.at(3, 3) = this->kn; //in compression and after the clearance gap closed
} else {
answer.at(1, 1) = answer.at(2, 2) = answer.at(3, 3) = this->kn * this->stiffCoeff;
}
} else {
if ( rMode == ElasticStiffness ) {
answer.at(1, 1) = answer.at(2, 2) = answer.at(3, 3) = this->kn;
} else {
OOFEM_ERROR("unknown MatResponseMode (%s)", __MatResponseModeToString(rMode) );
}
}
return;
default:
StructuralMaterial :: giveStiffnessMatrix(answer, rMode, gp, tStep);
}
}
void
CebFipSlip90Material :: give1dInterfaceMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode rMode,
GaussPoint *gp, TimeStep *atTime)
{
double kappa;
CebFipSlip90MaterialStatus *status = ( CebFipSlip90MaterialStatus * ) this->giveStatus(gp);
answer.resize(1, 1);
if ( ( rMode == ElasticStiffness ) || ( rMode == SecantStiffness ) ) {
kappa = status->giveKappa();
if ( kappa > 0.0 ) {
answer.at(1, 1) = ( this->computeBondForce(kappa) / kappa );
} else {
answer.at(1, 1) = computeBondForceStiffness(0.0);
}
} else if ( rMode == TangentStiffness ) {
answer.at(1, 1) = computeBondForceStiffness( status->giveTempKappa() );
} else {
_error2( "give2dInterfaceMaterialStiffnessMatrix: unknown MatResponseMode (%s)", __MatResponseModeToString(rMode) );
}
}
