void HeMoKunzelMaterial :: matcond1d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *atTime) { double k = 0.0, h = 0.0, t = 0.0; TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; // s = status->giveTempStateVector(); s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("matcond1d: undefined state vector"); } h = s.at(2); t = s.at(1); if ( mode == Conductivity_ww ) { k = perm_mm(h, t); } else if ( mode == Conductivity_wh ) { k = perm_mh(h, t); } else if ( mode == Conductivity_hw ) { k = perm_hm(h, t); } else if ( mode == Conductivity_hh ) { k = perm_hh(h, t); } else { OOFEM_ERROR("Unknown MatResponseMode"); } d.resize(1, 1); d.at(1, 1) = k; }
void HeMoTKMaterial :: giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); double w = field.at(2); double t = field.at(1); FloatArray ans_w, ans_t; FloatArray grad_w, grad_t; int size = grad.giveSize() / 2; for ( int i = 1; i <= size; ++i ) { grad_w.at(i) = grad.at(i); } for ( int i = size + 1; i <= size * 2; ++i ) { grad_t.at(i) = grad.at(i); } ans_w.beScaled(perm_ww(w, t), grad_w); ans_w.beScaled(perm_wt(w, t), grad_t); ans_t.beScaled(perm_ww(w, t) * get_latent(w, t), grad_w); ans_t.beScaled(get_chi(w, t) + get_latent(w, t) * perm_wt(w, t), grad_t); answer.resize(size * 2); answer.zero(); answer.addSubVector(ans_w, 1); answer.addSubVector(ans_t, size + 1); ms->setTempField(field); ms->setTempGradient(grad); ms->setTempFlux(answer); }
void TransportMaterial :: updateInternalState(const FloatArray &stateVec, GaussPoint *gp, TimeStep *) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); if ( ms ) { ms->letTempStateVectorBe(stateVec); } }
double HeMoKunzelMaterial :: computeCapacityCoeff(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { // if (gp->giveElement()->giveNumber() == 4) // double bzzz = 20; if ( mode == Capacity_ww ) { TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; double h; double dw_dh; // s = status->giveTempStateVector(); s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("computeCapacityCoeff: undefined state vector"); } h = s.at(2); dw_dh = this->sorptionIsothermDerivative(h); return dw_dh; // CONSTANT //return 10.; } else if ( mode == Capacity_wh ) { return 0.0; } else if ( mode == Capacity_hw ) { return 0.0; } else if ( mode == Capacity_hh ) { TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; double h, w; double dHs_dT, dHw_dT; //s = status->giveTempStateVector(); s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("computeCapacityCoeff: undefined state vector"); } h = s.at(2); w = this->sorptionIsotherm(h); dHs_dT = cs * give('d', NULL); dHw_dT = cw * w; return ( dHs_dT + dHw_dT ); // CONSTANT return 1.7e6; } else { OOFEM_ERROR("Unknown MatResponseMode"); } return 0.0; // to make compiler happy }
void IsotropicMoistureTransferMaterial :: giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); ///@todo Shouldn't the permeability typically depend on the primary field and/or its gradient? answer.beScaled(-this->givePermeability(gp, tStep), grad); ms->setTempField(field); ms->setTempGradient(grad); ms->setTempFlux(answer); }
void AnisotropicMassTransferMaterial :: giveFluxVector(FloatArray& answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); answer.beProductOf(k, grad); answer.negated(); ms->setTempField(field); ms->setTempGradient(grad); ms->setTempFlux(answer); }
void NonlinearMassTransferMaterial :: giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); double gradPNorm = grad.computeNorm(); answer.beScaled( -(1. + C * pow(gradPNorm, alpha)), grad); ms->setTempGradient(grad); ms->setTempField(field); ms->setTempFlux(answer); }
void HydratingHeMoMaterial :: updateInternalState(const FloatArray &vec, GaussPoint *gp, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray aux; if ( ms ) { ms->letTempStateVectorBe(vec); if ( hydration ) { /* OBSOLETE * FloatArray s = ms->giveStateVector (); * if (vec.isEmpty()) OOFEM_ERROR("empty new state vector"); * aux.resize(2); * aux.at(1) = vec.at(1); * if (s.isEmpty()||(tStep->giveTime()<=0)) aux.at(2) = initialHydrationDegree; // apply initial conditions * else { * aux.at(2) = s.at(2); * if (!castAt || (tStep->giveTime()>=castAt)) aux.at(2) += hydrationModel->dksi (s.at(2), vec.at(1), tStep->giveTimeIncrement()); // compute hydration degree increment * } */ // it is necessary to convert the passed state vector to relative humidity expected by the hydration model //!!! might be cleaner to choose wc / h in hydration model, but it must be defined which one is passed anyway; so relative humidity was chosen //!!! also, the humidity vector might be evaluated by a function (ensure 2 elements and set humidity) FloatArray vech = vec; if ( vech.giveSize() >= 2 ) { vech.at(2) = inverse_sorption_isotherm( vec.at(2) ); // compute relative humidity } else { vech.resize(2); vech.at(2) = 1.; // saturated if undefined } HydrationModelInterface :: updateInternalState(vech, gp, tStep); // additional file output !!! if ( teplotaOut && ( gp->giveNumber() == 1 ) && giveStatus(gp) ) { FILE *vyst = fopen("teplota.out", "a"); computeInternalSourceVector(aux, gp, tStep, VM_Incremental); if ( aux.isEmpty() ) { aux.resize(1); aux.zero(); } aux.times( 1. / give('d', gp) ); fprintf( vyst, "Elem %.3d krok %.2d: t= %.0f, dt=%.0f, %ld. it, ksi= %.12f, T= %.8f, heat=%.8f\n", gp->giveElement()->giveNumber(), tStep->giveNumber(), tStep->giveTargetTime(), tStep->giveTimeIncrement(), tStep->giveSolutionStateCounter(), giveHydrationDegree(gp, tStep, VM_Total), vec.at(1), aux.at(1) * tStep->giveTimeIncrement() ); fclose(vyst); } } } }
int NonlinearMassTransferMaterial :: giveIPValue(FloatArray &answer, GaussPoint *aGaussPoint, InternalStateType type, TimeStep *atTime) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(aGaussPoint) ); switch ( type ) { case IST_Velocity: answer = ms->giveFlux(); break; case IST_PressureGradient: answer = ms->giveGradient(); break; default: return TransportMaterial :: giveIPValue(answer, aGaussPoint, type, atTime); } return 1; }
void HeMoTKMaterial :: matcond3d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *atTime) // function creates conductivity matrix of the // isotropic heat material for 3D problems // // d - conductivity matrix of the material // 25.9.2001 { double k = 0.0, w = 0.0, t = 0.0; TransportMaterialStatus *status = ( TransportMaterialStatus * ) this->giveStatus(gp); FloatArray s; // w = Tm->ip[ipp].av[0]; // t = Tm->ip[ipp].av[1]; s = status->giveTempStateVector(); if ( s.isEmpty() ) { _error("matcond3d: undefined state vector"); } w = s.at(2); t = s.at(1); if ( mode == Conductivity_ww ) { k = perm_ww(w, t); } else if ( mode == Conductivity_wh ) { k = perm_wt(w, t); } else if ( mode == Conductivity_hw ) { k = perm_ww(w, t) * get_latent(w, t); } else if ( mode == Conductivity_hh ) { k = get_chi(w, t) + get_latent(w, t) * perm_wt(w, t); } else { _error("Unknown MatResponseMode"); } d.resize(3, 3); d.at(1, 1) = k; d.at(1, 2) = 0.0; d.at(1, 3) = 0.0; d.at(2, 1) = 0.0; d.at(2, 2) = k; d.at(2, 3) = 0.0; d.at(3, 1) = 0.0; d.at(3, 2) = 0.0; d.at(3, 3) = k; }
void NonlinearMassTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { MaterialMode mMode = gp->giveMaterialMode(); TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray eps = status->giveTempGradient(); double gradPNorm; FloatMatrix t1, t2; gradPNorm = eps.computeNorm(); t1.beDyadicProductOf(eps, eps); if ( gradPNorm != 0.0 ) { t1.times( C * alpha * pow(gradPNorm, alpha - 2) ); } switch ( mMode ) { case _1dHeat: t2.resize(1, 1); t2.at(1, 1) = 1; break; case _2dHeat: t2.resize(2, 2); t2.at(1, 1) = t2.at(2, 2) = 1; break; case _3dHeat: t2.resize(3, 3); t2.at(1, 1) = t2.at(2, 2) = t2.at(3, 3) = 1; break; default: _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) ); } answer.beEmptyMtrx(); answer.add(t1); answer.add(1 + C * pow(gradPNorm, alpha), t2); }
double HeMoTKMaterial :: giveHumidity(GaussPoint *gp, ValueModeType mode) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); const FloatArray &tempState = ms->giveTempField(); if ( tempState.giveSize() < 2 ) { OOFEM_ERROR("undefined moisture status!"); } FloatArray state = ms->giveField(); if ( mode == VM_Total ) { return inverse_sorption_isotherm( tempState.at(2) ); } else if ( mode == VM_Incremental ) { return inverse_sorption_isotherm( tempState.at(2) ) - inverse_sorption_isotherm( state.at(2) ); } else if ( mode == VM_Velocity ) { // VM_Previous return inverse_sorption_isotherm( state.at(2) ); } return 1.; }
void HydratingIsoHeatMaterial :: updateInternalState(const FloatArray &vec, GaussPoint *gp, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray aux; if ( ms ) { ms->letTempStateVectorBe(vec); if ( hydration ) { /* OBSOLETE * FloatArray s = ms->giveStateVector (); * if (vec.isEmpty()) OOFEM_ERROR("empty new state vector"); * aux.resize(2); * aux.at(1) = vec.at(1); * if (s.isEmpty()||(tStep->giveTime()<=0)) aux.at(2) = initialHydrationDegree; // apply initial conditions * else { * aux.at(2) = s.at(2); * if (!castAt || (tStep->giveTime()>=castAt)) aux.at(2) += hydrationModel->dksi (s.at(2), vec.at(1), tStep->giveTimeIncrement()); // compute hydration degree increment * } */ HydrationModelInterface :: updateInternalState(vec, gp, tStep); // additional file output !!! if ( ( gp->giveNumber() == 1 ) && giveStatus(gp) ) { FILE *vyst = fopen("teplota.out", "a"); computeInternalSourceVector(aux, gp, tStep, VM_Incremental); if ( aux.isEmpty() ) { aux.resize(1); aux.zero(); } aux.times( 1. / give('d', gp, tStep) ); fprintf( vyst, "Elem %.3d krok %.2d: t= %.0f, dt=%.0f, %ld. it, ksi= %.12f, T= %.8f, heat=%.8f\n", gp->giveElement()->giveNumber(), tStep->giveNumber(), tStep->giveTargetTime(), tStep->giveTimeIncrement(), tStep->giveSolutionStateCounter(), giveHydrationDegree(gp, tStep, VM_Total), vec.at(1), aux.at(1) * tStep->giveTimeIncrement() ); fclose(vyst); } } } }
double HeMoTKMaterial :: computeCapacityCoeff(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) { if ( mode == Capacity_ww ) { return 1.0 * rho; } else if ( mode == Capacity_wh ) { return 0.0; } else if ( mode == Capacity_hw ) { TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; double w, t; s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("undefined state vector"); } w = s.at(2); t = s.at(1); return get_b(w, t) * get_latent(w, t); } else if ( mode == Capacity_hh ) { TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; double w, t; s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("undefined state vector"); } w = s.at(2); t = s.at(1); return get_ceff(w, t); } else { OOFEM_ERROR("Unknown MatResponseMode"); } return 0.0; // to make compiler happy }
void HeMoKunzelMaterial :: giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; // s = ms->giveTempStateVector(); s = ms->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("matcond1d: undefined state vector"); } double h = s.at(2); double t = s.at(1); FloatArray ans_w, ans_t; FloatArray grad_w, grad_t; int size = grad.giveSize() / 2; for ( int i = 1; i <= size; ++i ) { grad_w.at(i) = grad.at(i); } for ( int i = size + 1; i <= size * 2; ++i ) { grad_t.at(i) = grad.at(i); } ans_w.beScaled(perm_mm(h, t), grad_w); ans_w.beScaled(perm_mh(h, t), grad_t); ans_t.beScaled(perm_hm(h, t), grad_w); ans_t.beScaled(perm_hh(h, t), grad_t); answer.resize(size * 2); answer.zero(); answer.addSubVector(ans_w, 1); answer.addSubVector(ans_t, size + 1); ms->setTempField(field); ms->setTempGradient(grad); ms->setTempFlux(answer); }
double HeMoTKMaterial :: computeCapacityCoeff(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { if ( mode == Capacity_ww ) { return 1.0 * rho; } else if ( mode == Capacity_wh ) { return 0.0; } else if ( mode == Capacity_hw ) { TransportMaterialStatus *status = ( TransportMaterialStatus * ) this->giveStatus(gp); FloatArray s; double w, t; s = status->giveTempStateVector(); if ( s.isEmpty() ) { _error("computeCapacityCoeff: undefined state vector"); } w = s.at(2); t = s.at(1); return get_b(w, t) * get_latent(w, t); } else if ( mode == Capacity_hh ) { TransportMaterialStatus *status = ( TransportMaterialStatus * ) this->giveStatus(gp); FloatArray s; double w, t; s = status->giveTempStateVector(); if ( s.isEmpty() ) { _error("computeCapacityCoeff: undefined state vector"); } w = s.at(2); t = s.at(1); return get_ceff(w, t); } else { _error("Unknown MatResponseMode"); } return 0.0; // to make compiler happy }
void HeMoTKMaterial :: matcond1d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *tStep) // function creates conductivity matrix of the // isotropic heat material for 1D problems // // d - conductivity matrix of the material // 25.9.2001 { double k = 0.0, w = 0.0, t = 0.0; TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); FloatArray s; // w = Tm->ip[ipp].av[0]; // t = Tm->ip[ipp].av[1]; s = status->giveTempField(); if ( s.isEmpty() ) { OOFEM_ERROR("undefined state vector"); } w = s.at(2); t = s.at(1); if ( mode == Conductivity_ww ) { k = perm_ww(w, t); } else if ( mode == Conductivity_wh ) { k = perm_wt(w, t); } else if ( mode == Conductivity_hw ) { k = perm_ww(w, t) * get_latent(w, t); } else if ( mode == Conductivity_hh ) { k = get_chi(w, t) + get_latent(w, t) * perm_wt(w, t); } else { OOFEM_ERROR("Unknown MatResponseMode"); } d.resize(1, 1); d.at(1, 1) = k; }
double HeMoKunzelMaterial :: giveHumidity(GaussPoint *gp, ValueModeType mode) { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); const FloatArray &tempState = ms->giveTempField(); if ( tempState.giveSize() < 2 ) { OOFEM_ERROR("Undefined moisture status"); } const FloatArray &state = ms->giveField(); if ( mode == VM_Total ) { return tempState.at(2); } else if ( mode == VM_Incremental ) { return tempState.at(2) - state.at(2); } else if ( mode == VM_Velocity ) { // VM_Previous return state.at(2); } else { OOFEM_ERROR("Undefined moisture mode"); } return 1.; }
int TransportMaterial :: giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep) // IST_Humidity must be overriden! { TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) ); if ( type == IST_Temperature || type == IST_MassConcentration_1 || type == IST_Humidity ) { FloatArray vec = ms->giveField(); answer = FloatArray{vec.at( ( type == IST_Temperature ) ? 1 : 2 ) }; return 1; } else if ( type == IST_TemperatureFlow ) { TransportElement *transpElem = static_cast< TransportElement * >( gp->giveElement() ); transpElem->computeFlow(answer, gp, tStep); return 1; } else if ( type == IST_Velocity ) { ///@todo Shouldn't be named velocity.. instead, "MassFlow" or something suitable like that. answer = ms->giveFlux(); answer.resizeWithValues(3); return 1; } else if ( type == IST_PressureGradient ) { answer = ms->giveGradient(); answer.resizeWithValues(3); return 1; } else if ( type == IST_Density ) { answer = FloatArray{ this->give('d', gp) }; return 1; } else if ( type == IST_HeatCapacity ) { answer = FloatArray{ this->give('c', gp) }; return 1; } else if ( type == IST_ThermalConductivityIsotropic ) { answer = FloatArray{ this->give('k', gp) }; return 1; } else if ( type == IST_Maturity ) { answer = FloatArray{ ms->giveMaturity() }; return 1; } return Material :: giveIPValue(answer, gp, type, tStep); }