IRResultType
StationaryTransportProblem :: initializeFrom(InputRecord *ir)
{
const char *__proc = "initializeFrom"; // Required by IR_GIVE_FIELD macro
IRResultType result; // Required by IR_GIVE_FIELD macro
EngngModel :: initializeFrom(ir);
int val = SMT_Skyline;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_smtype);
this->sparseMtrxType = ( SparseMtrxType ) val;
///@todo Combine this option with structural problems, where it is possible to keep the secant tangent elastic tangent (or generally, the initial tangent) etc. One option should fit all common needs here.
this->keepTangent = ir->hasField(_IFT_StationaryTransportProblem_keepTangent);
// read field export flag
IntArray exportFields;
exportFields.resize(0);
IR_GIVE_OPTIONAL_FIELD(ir, exportFields, _IFT_StationaryTransportProblem_exportfields);
if ( exportFields.giveSize() ) {
IntArray mask(1);
FieldManager *fm = this->giveContext()->giveFieldManager();
for ( int i = 1; i <= exportFields.giveSize(); i++ ) {
if ( exportFields.at(i) == FT_Temperature ) {
mask.at(1) = T_f;
#ifdef FIELDMANAGER_USE_SHARED_PTR
//std::tr1::shared_ptr<Field> _temperatureField = make_shared<MaskedPrimaryField>(FT_Temperature, this->UnknownsField, mask);
std::tr1::shared_ptr<Field> _temperatureField (new MaskedPrimaryField(FT_Temperature, this->UnknownsField, mask));
fm->registerField(_temperatureField, ( FieldType ) exportFields.at(i));
#else
MaskedPrimaryField *_temperatureField = new MaskedPrimaryField(FT_Temperature, this->UnknownsField, mask);
fm->registerField(_temperatureField, ( FieldType ) exportFields.at(i), true);
#endif
} else if ( exportFields.at(i) == FT_HumidityConcentration ) {
mask.at(1) = C_1;
#ifdef FIELDMANAGER_USE_SHARED_PTR
//std::tr1::shared_ptr<Field> _temperatureField = make_shared<MaskedPrimaryField>(FT_Temperature, this->UnknownsField, mask);
std::tr1::shared_ptr<Field> _concentrationField (new MaskedPrimaryField(FT_HumidityConcentration, this->UnknownsField, mask));
fm->registerField(_concentrationField, ( FieldType ) exportFields.at(i));
#else
MaskedPrimaryField *_concentrationField = new MaskedPrimaryField(FT_HumidityConcentration, this->UnknownsField, mask);
fm->registerField(_concentrationField, ( FieldType ) exportFields.at(i), true);
#endif
}
}
}
if( UnknownsField == NULL ){ // can exist from nonstationary transport problem
UnknownsField = new PrimaryField(this, 1, FT_TransportProblemUnknowns, EID_ConservationEquation, 0);
}
return IRRT_OK;
}
IRResultType
TransientTransportProblem :: initializeFrom(InputRecord *ir)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
int val = SMT_Skyline;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_smtype);
this->sparseMtrxType = ( SparseMtrxType ) val;
IR_GIVE_FIELD(ir, this->alpha, _IFT_TransientTransportProblem_alpha);
prescribedTimes.clear();
dtFunction = 0;
if ( ir->hasField(_IFT_TransientTransportProblem_dtFunction) ) {
IR_GIVE_FIELD(ir, this->dtFunction, _IFT_TransientTransportProblem_dtFunction);
} else if ( ir->hasField(_IFT_TransientTransportProblem_prescribedTimes) ) {
IR_GIVE_FIELD(ir, this->prescribedTimes, _IFT_TransientTransportProblem_prescribedTimes);
} else {
IR_GIVE_FIELD(ir, this->deltaT, _IFT_TransientTransportProblem_deltaT);
}
this->keepTangent = ir->hasField(_IFT_TransientTransportProblem_keepTangent);
this->lumped = ir->hasField(_IFT_TransientTransportProblem_lumped);
field.reset( new DofDistributedPrimaryField(this, 1, FT_TransportProblemUnknowns, 0) );
// read field export flag
exportFields.clear();
IR_GIVE_OPTIONAL_FIELD(ir, exportFields, _IFT_TransientTransportProblem_exportFields);
if ( exportFields.giveSize() ) {
FieldManager *fm = this->giveContext()->giveFieldManager();
for ( int i = 1; i <= exportFields.giveSize(); i++ ) {
if ( exportFields.at(i) == FT_Temperature ) {
FM_FieldPtr _temperatureField( new MaskedPrimaryField ( ( FieldType ) exportFields.at(i), this->field.get(), {T_f} ) );
fm->registerField( _temperatureField, ( FieldType ) exportFields.at(i) );
} else if ( exportFields.at(i) == FT_HumidityConcentration ) {
FM_FieldPtr _concentrationField( new MaskedPrimaryField ( ( FieldType ) exportFields.at(i), this->field.get(), {C_1} ) );
fm->registerField( _concentrationField, ( FieldType ) exportFields.at(i) );
}
}
}
return EngngModel :: initializeFrom(ir);
}
IRResultType
CBS :: initializeFrom(InputRecord *ir)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
int val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_lstype);
solverType = ( LinSystSolverType ) val;
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_smtype);
sparseMtrxType = ( SparseMtrxType ) val;
IR_GIVE_FIELD(ir, deltaT, _IFT_CBS_deltat);
minDeltaT = 0.;
IR_GIVE_OPTIONAL_FIELD(ir, minDeltaT, _IFT_CBS_mindeltat);
IR_GIVE_OPTIONAL_FIELD(ir, consistentMassFlag, _IFT_CBS_cmflag);
theta1 = theta2 = 1.0;
IR_GIVE_OPTIONAL_FIELD(ir, theta1, _IFT_CBS_theta1);
IR_GIVE_OPTIONAL_FIELD(ir, theta2, _IFT_CBS_theta2);
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_CBS_scaleflag);
equationScalingFlag = val > 0;
if ( equationScalingFlag ) {
IR_GIVE_FIELD(ir, lscale, _IFT_CBS_lscale);
IR_GIVE_FIELD(ir, uscale, _IFT_CBS_uscale);
IR_GIVE_FIELD(ir, dscale, _IFT_CBS_dscale);
double vref = 1.0; // reference viscosity
Re = dscale * uscale * lscale / vref;
} else {
lscale = uscale = dscale = 1.0;
Re = 1.0;
}
//<RESTRICTED_SECTION>
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_CBS_miflag);
if ( val ) {
this->materialInterface.reset( new LEPlic( 1, this->giveDomain(1) ) );
// export velocity field
FieldManager *fm = this->giveContext()->giveFieldManager();
IntArray mask = {V_u, V_v, V_w};
//std::shared_ptr<Field> _velocityField = make_shared<MaskedPrimaryField>(FT_Velocity, &this->VelocityField, mask);
std :: shared_ptr< Field > _velocityField( new MaskedPrimaryField ( FT_Velocity, &this->VelocityField, mask ) );
fm->registerField(_velocityField, FT_Velocity);
}
//</RESTRICTED_SECTION>
return EngngModel :: initializeFrom(ir);
}
IRResultType
SUPG :: initializeFrom(InputRecord *ir)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
result = FluidModel :: initializeFrom(ir);
if ( result != IRRT_OK ) {
return result;
}
IR_GIVE_FIELD(ir, rtolv, _IFT_SUPG_rtolv);
atolv = 1.e-15;
IR_GIVE_OPTIONAL_FIELD(ir, atolv, _IFT_SUPG_atolv);
stopmaxiter = ir->hasField(_IFT_SUPG_stopmaxiter);
maxiter = 200;
IR_GIVE_OPTIONAL_FIELD(ir, maxiter, _IFT_SUPG_maxiter);
int val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_lstype);
solverType = ( LinSystSolverType ) val;
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_EngngModel_smtype);
sparseMtrxType = ( SparseMtrxType ) val;
IR_GIVE_FIELD(ir, deltaT, _IFT_SUPG_deltat);
deltaTF = 0;
IR_GIVE_OPTIONAL_FIELD(ir, deltaTF, _IFT_SUPG_deltatFunction);
IR_GIVE_OPTIONAL_FIELD(ir, consistentMassFlag, _IFT_SUPG_cmflag);
alpha = 0.5;
IR_GIVE_OPTIONAL_FIELD(ir, alpha, _IFT_SUPG_alpha);
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_SUPG_scaleflag);
equationScalingFlag = val > 0;
if ( equationScalingFlag ) {
IR_GIVE_FIELD(ir, lscale, _IFT_SUPG_lscale);
IR_GIVE_FIELD(ir, uscale, _IFT_SUPG_uscale);
IR_GIVE_FIELD(ir, dscale, _IFT_SUPG_dscale);
double vref = 1.0; // reference viscosity
Re = dscale * uscale * lscale / vref;
} else {
lscale = uscale = dscale = 1.0;
Re = 1.0;
}
if ( requiresUnknownsDictionaryUpdate() ) {
VelocityPressureField.reset( new DofDistributedPrimaryField(this, 1, FT_VelocityPressure, 1) );
} else {
VelocityPressureField.reset( new PrimaryField(this, 1, FT_VelocityPressure, 1) );
}
val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, val, _IFT_SUPG_miflag);
if ( val == 1 ) {
this->materialInterface.reset( new LEPlic( 1, this->giveDomain(1) ) );
this->materialInterface->initializeFrom(ir);
// export velocity field
FieldManager *fm = this->giveContext()->giveFieldManager();
IntArray mask;
mask = {V_u, V_v, V_w};
std :: shared_ptr< Field > _velocityField( new MaskedPrimaryField ( FT_Velocity, this->VelocityPressureField.get(), mask ) );
fm->registerField(_velocityField, FT_Velocity);
//fsflag = 0;
//IR_GIVE_OPTIONAL_FIELD (ir, fsflag, _IFT_SUPG_fsflag, "fsflag");
} else if ( val == 2 ) {
// positive coefficient scheme level set alg
this->materialInterface.reset( new LevelSetPCS( 1, this->giveDomain(1) ) );
this->materialInterface->initializeFrom(ir);
}
return IRRT_OK;
}
