int XfemManager :: instanciateYourself(DataReader *dr)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
std :: string name;
enrichmentItemList.resize(numberOfEnrichmentItems);
for ( int i = 1; i <= numberOfEnrichmentItems; i++ ) {
InputRecord *mir = dr->giveInputRecord(DataReader :: IR_enrichItemRec, i);
result = mir->giveRecordKeywordField(name);
if ( result != IRRT_OK ) {
mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__);
}
std :: unique_ptr< EnrichmentItem > ei( classFactory.createEnrichmentItem( name.c_str(), i, this, this->giveDomain() ) );
if ( ei.get() == NULL ) {
OOFEM_ERROR( "unknown enrichment item (%s)", name.c_str() );
}
ei->initializeFrom(mir);
ei->instanciateYourself(dr);
this->enrichmentItemList[i-1] = std :: move(ei);
}
updateNodeEnrichmentItemMap();
return 1;
}
void
NonLinearStatic :: updateAttributes(MetaStep *mStep)
{
const char *__proc = "updateAttributes"; // Required by IR_GIVE_FIELD macro
IRResultType result; // Required by IR_GIVE_FIELD macro
MetaStep *mStep1 = this->giveMetaStep( mStep->giveNumber() );//this line ensures correct input file in staggered problem
InputRecord *ir = mStep1->giveAttributesRecord();
LinearStatic :: updateAttributes(mStep1);
/*
* if ((mstep->giveFirstStepNumber() == atTime->giveNumber()) && hasString(initString, "fixload")) {
* double factor;
*
* printf ("NonLinearStatic: fixed load level");
* if (initialLoadVector.isEmpty()) initialLoadVector.resize(loadVector.giveSize());
* if ((controlMode == nls_directControl) || (controlMode == nls_directControl2)) factor = 1.0;
* else factor = loadLevel;
* loadVector.times (factor);
* initialLoadVector.add(loadVector);
* loadVector.zero();
* this->loadInitFlag = 1;
* this->loadLevel = 0.0;
* }
*/
int _val = nls_indirectControl;
IR_GIVE_OPTIONAL_FIELD(ir, _val, IFT_NonLinearStatic_controlmode, "controlmode"); // Macro
IR_GIVE_OPTIONAL_FIELD(ir, _val, IFT_NonLinearStatic_controlmode, "controllmode"); // for backward compatibility
this->controlMode = ( NonLinearStatic_controlType ) _val;
_val = IG_None;
IR_GIVE_OPTIONAL_FIELD(ir, _val, IFT_EngngModel_initialGuess, "initialguess");
this->initialGuessType = ( InitialGuess ) _val;
deltaT = 1.0;
IR_GIVE_OPTIONAL_FIELD(ir, deltaT, IFT_NonLinearStatic_deltat, "deltat"); // Macro
if ( deltaT < 0. ) {
_error("updateAttributes: deltaT < 0");
}
_val = nls_tangentStiffness;
IR_GIVE_OPTIONAL_FIELD(ir, _val, IFT_NonLinearStatic_stiffmode, "stiffmode"); // Macro
this->stiffMode = ( NonLinearStatic_stiffnessMode ) _val;
_val = SparseNonLinearSystemNM :: rlm_total;
IR_GIVE_OPTIONAL_FIELD(ir, _val, IFT_NonLinearStatic_refloadmode, "refloadmode"); // Macro
this->refLoadInputMode = ( SparseNonLinearSystemNM :: referenceLoadInputModeType ) _val;
if ( ir->hasField(IFT_NonLinearStatic_keepll, "keepll") ) {
mstepCumulateLoadLevelFlag = true;
} else {
mstepCumulateLoadLevelFlag = false;
}
// called just to mart filed as recognized, used later
ir->hasField(IFT_NonLinearStatic_donotfixload, "donotfixload");
}
void
NonLinearStatic :: updateAttributes(MetaStep *mStep)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
MetaStep *mStep1 = this->giveMetaStep( mStep->giveNumber() ); //this line ensures correct input file in staggered problem
InputRecord *ir = mStep1->giveAttributesRecord();
LinearStatic :: updateAttributes(mStep1);
/*
* if ((mstep->giveFirstStepNumber() == tStep->giveNumber()) && hasString(initString, "fixload")) {
* double factor;
*
* printf ("NonLinearStatic: fixed load level");
* if (initialLoadVector.isEmpty()) initialLoadVector.resize(loadVector.giveSize());
* if ((controlMode == nls_directControl) || (controlMode == nls_directControl2)) factor = 1.0;
* else factor = loadLevel;
* loadVector.times (factor);
* initialLoadVector.add(loadVector);
* loadVector.zero();
* this->loadInitFlag = 1;
* this->loadLevel = 0.0;
* }
*/
int _val = nls_indirectControl;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_NonLinearStatic_controlmode);
IR_GIVE_OPTIONAL_FIELD(ir, _val, "controllmode"); /// @todo If there is ever a major version change, remove this (for backward compatibility)
this->controlMode = ( NonLinearStatic_controlType ) _val;
_val = IG_None;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_EngngModel_initialGuess);
this->initialGuessType = ( InitialGuess ) _val;
deltaT = 1.0;
IR_GIVE_OPTIONAL_FIELD(ir, deltaT, _IFT_NonLinearStatic_deltat);
if ( deltaT < 0. ) {
OOFEM_ERROR("deltaT < 0");
}
_val = nls_tangentStiffness;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_NonLinearStatic_stiffmode);
this->stiffMode = ( NonLinearStatic_stiffnessMode ) _val;
_val = SparseNonLinearSystemNM :: rlm_total;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_NonLinearStatic_refloadmode);
this->refLoadInputMode = ( SparseNonLinearSystemNM :: referenceLoadInputModeType ) _val;
mstepCumulateLoadLevelFlag = ir->hasField(_IFT_NonLinearStatic_keepll);
// called just to mark field as recognized, used later
ir->hasField(_IFT_NonLinearStatic_donotfixload);
}
int
ContactManager :: instanciateYourself(DataReader *dr)
{
IRResultType result = IRRT_OK; // Required by IR_GIVE_FIELD macro
std :: string name;
// Create and instantiate contact definitions
for ( int i = 1; i <= this->giveNumberOfContactDefinitions(); i++ ) {
InputRecord *ir = dr->giveInputRecord(DataReader :: IR_contactDefRec, i);
result = ir->giveRecordKeywordField(name);
this->contactDefinitionList[i-1].reset( classFactory.createContactDefinition( name.c_str(), this ) );
if ( this->contactDefinitionList[i-1] ) {
this->contactDefinitionList[i-1]->initializeFrom(ir);
this->contactDefinitionList[i-1]->instanciateYourself(dr);
} else {
OOFEM_ERROR("Failed to create contact definition (%s)", name.c_str() );
}
}
return result;
}
EngngModel *InstanciateProblem(DataReader *dr, problemMode mode, int contextFlag, EngngModel *_master, bool parallelFlag)
{
const char *__proc = "InstanciateProblem"; // Required by IR_GIVE_FIELD macro
IRResultType result; // Required by IR_GIVE_FIELD macro
EngngModel *problem;
std::string problemName, dataOutputFileName, desc;
dataOutputFileName = dr->giveOutputFileName();
desc = dr->giveDescription();
/* here we need copy of input record. The pointer returned by dr->giveInputRecord can (and will)
* be updated as reading e-model components (nodes, etc). But we need this record being available
* through the whole e-model instanciation
*/
InputRecord *emodelir = dr->giveInputRecord(DataReader :: IR_emodelRec, 1)->GiveCopy();
result = emodelir->giveRecordKeywordField(problemName); ///@todo Make this function robust, it can't be allowed to fail (the record keyword is not a normal field-id)
if ( result != IRRT_OK ) {
IR_IOERR("", __proc, "", emodelir, result);
}
problem = classFactory.createEngngModel(problemName.c_str(), 1, _master);
if (!problem) {
OOFEM_ERROR2("EngngModel::InstanciateProblem - Failed to construct engineering model if type \"%s\".\n", problemName.c_str());
}
problem->setProblemMode(mode);
problem->setParallelMode(parallelFlag);
if ( contextFlag ) {
problem->setContextOutputMode(COM_Always);
}
problem->instanciateYourself(dr, emodelir, dataOutputFileName.c_str(), desc.c_str());
delete emodelir;
return problem;
}
int Delamination :: instanciateYourself(DataReader *dr)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
std :: string name;
// Instantiate enrichment function
InputRecord *mir = dr->giveInputRecord(DataReader :: IR_enrichFuncRec, 1);
result = mir->giveRecordKeywordField(name);
if ( result != IRRT_OK ) {
mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__);
}
mpEnrichmentFunc = classFactory.createEnrichmentFunction( name.c_str(), 1, this->giveDomain() );
if ( mpEnrichmentFunc != NULL ) {
mpEnrichmentFunc->initializeFrom(mir);
} else {
OOFEM_ERROR( "failed to create enrichment function (%s)", name.c_str() );
}
// Instantiate enrichment domain
mir = dr->giveInputRecord(DataReader :: IR_geoRec, 1);
result = mir->giveRecordKeywordField(name);
if ( result != IRRT_OK ) {
mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__);
}
IntArray idList;
IR_GIVE_FIELD(mir, idList, _IFT_ListBasedEI_list);
for ( int i = 1; i <= idList.giveSize(); i++ ) {
this->dofManList.push_back( idList.at(i) );
}
std :: sort( dofManList.begin(), this->dofManList.end() );
//IR_GIVE_FIELD(ir, this->xi, _IFT_DofManList_DelaminationLevel);
// Instantiate EnrichmentFront
if ( mEnrFrontIndex == 0 ) {
mpEnrichmentFrontStart = new EnrFrontDoNothing();
mpEnrichmentFrontEnd = new EnrFrontDoNothing();
} else {
std :: string enrFrontNameStart, enrFrontNameEnd;
InputRecord *enrFrontStartIr = dr->giveInputRecord(DataReader :: IR_enrichFrontRec, mEnrFrontIndex);
result = enrFrontStartIr->giveRecordKeywordField(enrFrontNameStart);
mpEnrichmentFrontStart = classFactory.createEnrichmentFront( enrFrontNameStart.c_str() );
if ( mpEnrichmentFrontStart != NULL ) {
mpEnrichmentFrontStart->initializeFrom(enrFrontStartIr);
} else {
OOFEM_ERROR( "Failed to create enrichment front (%s)", enrFrontNameStart.c_str() );
}
InputRecord *enrFrontEndIr = dr->giveInputRecord(DataReader :: IR_enrichFrontRec, mEnrFrontIndex);
result = enrFrontEndIr->giveRecordKeywordField(enrFrontNameEnd);
mpEnrichmentFrontEnd = classFactory.createEnrichmentFront( enrFrontNameEnd.c_str() );
if ( mpEnrichmentFrontEnd != NULL ) {
mpEnrichmentFrontEnd->initializeFrom(enrFrontEndIr);
} else {
OOFEM_ERROR( "Failed to create enrichment front (%s)", enrFrontNameEnd.c_str() );
}
}
// Instantiate PropagationLaw
if ( mPropLawIndex == 0 ) {
mpPropagationLaw = new PLDoNothing();
} else {
std :: string propLawName;
InputRecord *propLawir = dr->giveInputRecord(DataReader :: IR_propagationLawRec, mPropLawIndex);
result = propLawir->giveRecordKeywordField(propLawName);
mpPropagationLaw = classFactory.createPropagationLaw( propLawName.c_str() );
if ( mpPropagationLaw != NULL ) {
mpPropagationLaw->initializeFrom(propLawir);
} else {
OOFEM_ERROR( "Failed to create propagation law (%s)", propLawName.c_str() );
}
}
// Set start of the enrichment dof pool for the given EI
int xDofPoolAllocSize = this->giveDofPoolSize();
this->startOfDofIdPool = this->giveDomain()->giveNextFreeDofID(xDofPoolAllocSize);
this->endOfDofIdPool = this->startOfDofIdPool + xDofPoolAllocSize - 1;
XfemManager *xMan = this->giveDomain()->giveXfemManager();
// mpEnrichmentDomain->CallNodeEnrMarkerUpdate(* this, * xMan);
this->updateNodeEnrMarker(* xMan);
writeVtkDebug();
return 1;
}
void StructuralFE2MaterialStatus :: copyStateVariables(const MaterialStatus &iStatus)
{
//static int num = 0;
//printf("Entering StructuralFE2MaterialStatus :: copyStateVariables.\n");
this->oldTangent = true;
// if ( !this->createRVE(this->giveNumber(), gp, mInputFile) ) {
// OOFEM_ERROR("Couldn't create RVE");
// }
StructuralMaterialStatus :: copyStateVariables(iStatus);
//////////////////////////////
MaterialStatus &tmpStat = const_cast< MaterialStatus & >(iStatus);
StructuralFE2MaterialStatus *fe2ms = dynamic_cast<StructuralFE2MaterialStatus*>(&tmpStat);
if ( !fe2ms ) {
OOFEM_ERROR("Failed to cast StructuralFE2MaterialStatus.")
}
this->mNewlyInitialized = fe2ms->mNewlyInitialized;
// The proper way to do this would be to clone the RVE from iStatus.
// However, this is a mess due to all pointers that need to be tracked.
// Therefore, we consider a simplified version: copy only the enrichment items.
Domain *ext_domain = fe2ms->giveRVE()->giveDomain(1);
if ( ext_domain->hasXfemManager() ) {
Domain *rve_domain = rve->giveDomain(1);
XfemManager *ext_xMan = ext_domain->giveXfemManager();
XfemManager *this_xMan = rve->giveDomain(1)->giveXfemManager();
DynamicDataReader dataReader("fe2");
if ( ext_xMan != NULL ) {
IRResultType result; // Required by IR_GIVE_FIELD macro
std::vector<std::unique_ptr<EnrichmentItem>> eiList;
//DynamicInputRecord *xmanRec = new DynamicInputRecord();
//ext_xMan->giveInputRecord(* xmanRec);
//dataReader.insertInputRecord(DataReader :: IR_xfemManRec, xmanRec);
// Enrichment items
int nEI = ext_xMan->giveNumberOfEnrichmentItems();
for ( int i = 1; i <= nEI; i++ ) {
EnrichmentItem *ext_ei = ext_xMan->giveEnrichmentItem(i);
ext_ei->appendInputRecords(dataReader);
InputRecord *mir = dataReader.giveInputRecord(DataReader :: IR_enrichItemRec, i);
std :: string name;
result = mir->giveRecordKeywordField(name);
if ( result != IRRT_OK ) {
mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__);
}
std :: unique_ptr< EnrichmentItem >ei( classFactory.createEnrichmentItem( name.c_str(), i, this_xMan, rve_domain ) );
if ( ei.get() == NULL ) {
OOFEM_ERROR( "unknown enrichment item (%s)", name.c_str() );
}
ei->initializeFrom(mir);
ei->instanciateYourself(dataReader);
eiList.push_back( std :: move(ei) );
}
this_xMan->clearEnrichmentItems();
this_xMan->appendEnrichmentItems(eiList);
rve_domain->postInitialize();
rve->forceEquationNumbering();
}
}
//printf("done.\n");
#if 0
Domain *newDomain = fe2ms->giveRVE()->giveDomain(1)->Clone();
newDomain->SetEngngModel(rve.get());
bool deallocateOld = true;
rve->setDomain(1, newDomain, deallocateOld);
//rve->giveDomain(1)->postInitialize();
rve->giveNumericalMethod(NULL)->setDomain(newDomain);
rve->postInitialize();
//rve->forceEquationNumbering();
rve->initMetaStepAttributes( rve->giveMetaStep(1) );
rve->giveNextStep(); // Makes sure there is a timestep (which we will modify before solving a step)
rve->init();
// std :: ostringstream name;
// name << this->rve->giveOutputBaseFileName() << "-gp" << n;
// this->rve->letOutputBaseFileNameBe( name.str() );
// n++;
double crackLength = 0.0;
XfemStructureManager *xMan = dynamic_cast<XfemStructureManager*>( rve->giveDomain(1)->giveXfemManager() );
if ( xMan ) {
crackLength = xMan->computeTotalCrackLength();
}
std :: ostringstream name;
name << this->rve->giveOutputBaseFileName() << "-gp" << num << "crackLength" << crackLength;
if ( this->domain->giveEngngModel()->isParallel() && this->domain->giveEngngModel()->giveNumberOfProcesses() > 1 ) {
name << "." << this->domain->giveEngngModel()->giveRank();
}
num++;
this->rve->letOutputBaseFileNameBe( name.str() );
// Update BC
this->bc = dynamic_cast< PrescribedGradientHomogenization * >( this->rve->giveDomain(1)->giveBc(1) );
#if 1
XfemSolverInterface *xfemSolInt = dynamic_cast<XfemSolverInterface*>(rve.get());
StaticStructural *statStruct = dynamic_cast<StaticStructural*>(rve.get());
if ( xfemSolInt && statStruct ) {
//printf("Successfully casted to XfemSolverInterface.\n");
TimeStep *tStep = rve->giveCurrentStep();
EModelDefaultEquationNumbering num;
int numDofsNew = rve->giveNumberOfDomainEquations( 1, num );
FloatArray u;
u.resize(numDofsNew);
u.zero();
xfemSolInt->xfemUpdatePrimaryField(*statStruct, tStep, u);
// Set domain pointer to various components ...
rve->giveNumericalMethod(NULL)->setDomain(newDomain);
//ioEngngModel.nMethod->setDomain(domain);
}
// TimeStep *tStep = rve->giveNextStep();
// setTimeStep(tStep);
// rve->solveYourselfAt(tStep);
int numExpModules = rve->giveExportModuleManager()->giveNumberOfModules();
for ( int i = 1; i <= numExpModules; i++ ) {
// ... by diving deep into the hierarchies ... :-/
VTKXMLExportModule *vtkxmlMod = dynamic_cast< VTKXMLExportModule * >( rve->giveExportModuleManager()->giveModule(i) );
if ( vtkxmlMod != NULL ) {
vtkxmlMod->giveSmoother()->setDomain(newDomain);
vtkxmlMod->givePrimVarSmoother()->setDomain(newDomain);
}
}
#endif
#endif
}
void Root_NTupleManager::fill(
const InputRecord& irecord,
const OutputRecord& orecord,
Real64_t weigth
) {
n_part_px.clear();
n_part_py.clear();
n_part_pz.clear();
n_part_E.clear();
n_part_pdgId.clear();
int count = 0;
const vector<Particle>& parts = irecord.particles();
for (int j=0; j<parts.size(); ++j) {
// pick only particles from hard process
if (!isHardProcess(parts, j))
continue;
Real64_t px = parts[j].pT() * cos(parts[j].getPhi());
Real64_t py = parts[j].pT() * sin(parts[j].getPhi());
Real64_t pz = parts[j].pT() * sinh(parts[j].getEta());
Real64_t E = parts[j].pT() * cosh(parts[j].getEta());
n_part_px.push_back(px);
n_part_py.push_back(py);
n_part_pz.push_back(pz);
n_part_E.push_back(E);
count++;
}
n_part_n = count;
n_pho_px.clear();
n_pho_py.clear();
n_pho_pz.clear();
n_pho_E.clear();
n_pho_pdgId.clear();
for (int j=0; j<orecord.Photons.size(); ++j) {
Real64_t px = orecord.Photons[j].pT * cos(orecord.Photons[j].phi);
Real64_t py = orecord.Photons[j].pT * sin(orecord.Photons[j].phi);
Real64_t pz = orecord.Photons[j].pT * sinh(orecord.Photons[j].eta);
Real64_t E = orecord.Photons[j].pT * cosh(orecord.Photons[j].eta);
n_pho_px.push_back(px);
n_pho_py.push_back(py);
n_pho_pz.push_back(pz);
n_pho_E.push_back(E);
}
n_pho_n = orecord.Photons.size();
n_muo_px.clear();
n_muo_py.clear();
n_muo_pz.clear();
n_muo_E.clear();
n_muo_pdgId.clear();
for (int j=0; j<orecord.Muons.size(); ++j) {
Real64_t px = orecord.Muons[j].pT * cos(orecord.Muons[j].phi);
Real64_t py = orecord.Muons[j].pT * sin(orecord.Muons[j].phi);
Real64_t pz = orecord.Muons[j].pT * sinh(orecord.Muons[j].eta);
Real64_t E = orecord.Muons[j].pT * cosh(orecord.Muons[j].eta);
n_muo_px.push_back(px);
n_muo_py.push_back(py);
n_muo_pz.push_back(pz);
n_muo_E.push_back(E);
}
n_muo_n = orecord.Muons.size();
n_ele_px.clear();
n_ele_py.clear();
n_ele_pz.clear();
n_ele_E.clear();
n_ele_pdgId.clear();
for (int j=0; j<orecord.Electrons.size(); ++j) {
Real64_t px = orecord.Electrons[j].pT * cos(orecord.Electrons[j].phi);
Real64_t py = orecord.Electrons[j].pT * sin(orecord.Electrons[j].phi);
Real64_t pz = orecord.Electrons[j].pT * sinh(orecord.Electrons[j].eta);
Real64_t E = orecord.Electrons[j].pT * cosh(orecord.Electrons[j].eta);
n_ele_px.push_back(px);
n_ele_py.push_back(py);
n_ele_pz.push_back(pz);
n_ele_E.push_back(E);
}
n_ele_n = orecord.Electrons.size();
n_jet_px.clear();
n_jet_py.clear();
n_jet_pz.clear();
n_jet_E.clear();
n_jet_pdgId.clear();
for (int j=0; j<orecord.Jets.size(); ++j) {
Real64_t px = orecord.Jets[j].pT * cos(orecord.Jets[j].phi);
Real64_t py = orecord.Jets[j].pT * sin(orecord.Jets[j].phi);
Real64_t pz = orecord.Jets[j].pT * sinh(orecord.Jets[j].eta);
Real64_t E = orecord.Jets[j].pT * cosh(orecord.Jets[j].eta);
n_jet_px.push_back(px);
n_jet_py.push_back(py);
n_jet_pz.push_back(pz);
n_jet_E.push_back(E);
}
n_jet_n = orecord.Jets.size();
ntuple->Fill();
}
void
AdaptiveNonLinearStatic :: assembleInitialLoadVector(FloatArray &loadVector, FloatArray &loadVectorOfPrescribed,
AdaptiveNonLinearStatic *sourceProblem, int domainIndx,
TimeStep *tStep)
{
IRResultType result; // Required by IR_GIVE_FIELD macro
int mStepNum = tStep->giveMetaStepNumber();
int hasfixed, mode;
InputRecord *ir;
MetaStep *iMStep;
FloatArray _incrementalLoadVector, _incrementalLoadVectorOfPrescribed;
SparseNonLinearSystemNM :: referenceLoadInputModeType rlm;
//Domain* sourceDomain = sourceProblem->giveDomain(domainIndx);
loadVector.resize( this->giveNumberOfDomainEquations( domainIndx, EModelDefaultEquationNumbering() ) );
loadVectorOfPrescribed.resize( this->giveNumberOfDomainEquations( domainIndx, EModelDefaultPrescribedEquationNumbering() ) );
loadVector.zero();
loadVectorOfPrescribed.zero();
_incrementalLoadVector.resize( this->giveNumberOfDomainEquations( domainIndx, EModelDefaultEquationNumbering() ) );
_incrementalLoadVectorOfPrescribed.resize( this->giveNumberOfDomainEquations( domainIndx, EModelDefaultPrescribedEquationNumbering() ) );
_incrementalLoadVector.zero();
_incrementalLoadVectorOfPrescribed.zero();
for ( int imstep = 1; imstep < mStepNum; imstep++ ) {
iMStep = this->giveMetaStep(imstep);
ir = iMStep->giveAttributesRecord();
//hasfixed = ir->hasField("fixload");
hasfixed = 1;
if ( hasfixed ) {
// test for control mode
// here the algorithm works only for direct load control.
// Direct displacement control requires to know the quasi-rections, and the controlled nodes
// should have corresponding node on new mesh -> not supported
// Indirect control -> the load level from prevous steps is required, currently nt supported.
// additional problem: direct load control supports the reduction of step legth if convergence fails
// if this happens, this implementation does not work correctly.
// But there is NO WAY HOW TO TEST IF THIS HAPPEN
mode = 0;
IR_GIVE_OPTIONAL_FIELD(ir, mode, _IFT_AdaptiveNonLinearStatic_controlmode);
// check if displacement control takes place
if ( ir->hasField(_IFT_AdaptiveNonLinearStatic_ddm) ) {
OOFEM_ERROR("fixload recovery not supported for direct displacement control");
}
int firststep = iMStep->giveFirstStepNumber();
int laststep = iMStep->giveLastStepNumber();
int _val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_AdaptiveNonLinearStatic_refloadmode);
rlm = ( SparseNonLinearSystemNM :: referenceLoadInputModeType ) _val;
if ( mode == ( int ) nls_directControl ) { // and only load control
for ( int istep = firststep; istep <= laststep; istep++ ) {
// bad practise here
///@todo Likely memory leak here with new TimeStep; Check.
TimeStep *old = new TimeStep(istep, this, imstep, istep - 1.0, deltaT, 0);
this->assembleIncrementalReferenceLoadVectors(_incrementalLoadVector, _incrementalLoadVectorOfPrescribed,
rlm, this->giveDomain(domainIndx), EID_MomentumBalance, old);
_incrementalLoadVector.times( sourceProblem->giveTimeStepLoadLevel(istep) );
loadVector.add(_incrementalLoadVector);
loadVectorOfPrescribed.add(_incrementalLoadVectorOfPrescribed);
}
} else if ( mode == ( int ) nls_indirectControl ) {
// bad practise here
if ( !ir->hasField(_IFT_NonLinearStatic_donotfixload) ) {
TimeStep *old = new TimeStep(firststep, this, imstep, firststep - 1.0, deltaT, 0);
this->assembleIncrementalReferenceLoadVectors(_incrementalLoadVector, _incrementalLoadVectorOfPrescribed,
rlm, this->giveDomain(domainIndx), EID_MomentumBalance, old);
_incrementalLoadVector.times( sourceProblem->giveTimeStepLoadLevel(laststep) );
loadVector.add(_incrementalLoadVector);
loadVectorOfPrescribed.add(_incrementalLoadVectorOfPrescribed);
}
} else {
OOFEM_ERROR("fixload recovery not supported");
}
}
} // end loop over meta-steps
/* if direct control; add to initial load also previous steps in same metestep */
iMStep = this->giveMetaStep(mStepNum);
ir = iMStep->giveAttributesRecord();
mode = 0;
IR_GIVE_OPTIONAL_FIELD(ir, mode, _IFT_AdaptiveNonLinearStatic_controlmode);
int firststep = iMStep->giveFirstStepNumber();
int laststep = tStep->giveNumber();
int _val = 0;
IR_GIVE_OPTIONAL_FIELD(ir, _val, _IFT_AdaptiveNonLinearStatic_refloadmode);
rlm = ( SparseNonLinearSystemNM :: referenceLoadInputModeType ) _val;
if ( mode == ( int ) nls_directControl ) { // and only load control
for ( int istep = firststep; istep <= laststep; istep++ ) {
// bad practise here
TimeStep *old = new TimeStep(istep, this, mStepNum, istep - 1.0, deltaT, 0);
this->assembleIncrementalReferenceLoadVectors(_incrementalLoadVector, _incrementalLoadVectorOfPrescribed,
rlm, this->giveDomain(domainIndx), EID_MomentumBalance, old);
_incrementalLoadVector.times( sourceProblem->giveTimeStepLoadLevel(istep) );
loadVector.add(_incrementalLoadVector);
loadVectorOfPrescribed.add(_incrementalLoadVectorOfPrescribed);
}
}
}