void
AdaptiveNonLinearStatic :: solveYourselfAt(TimeStep *tStep)
{
proceedStep(1, tStep);
this->updateYourself(tStep);
#ifdef __OOFEG
ESIEventLoop( YES, const_cast< char * >("AdaptiveNonLinearStatic: Solution finished; Press Ctrl-p to continue") );
#endif
this->terminate( this->giveCurrentStep() );
#ifdef __PARALLEL_MODE
if ( preMappingLoadBalancingFlag ) {
this->balanceLoad( this->giveCurrentStep() );
}
#endif
// evaluate error of the reached solution
this->defaultErrEstimator->estimateError( equilibratedEM, this->giveCurrentStep() );
//this->defaultErrEstimator->estimateError( temporaryEM, this->giveCurrentStep() );
this->defaultErrEstimator->giveRemeshingCrit()->estimateMeshDensities( this->giveCurrentStep() );
RemeshingStrategy strategy = this->defaultErrEstimator->giveRemeshingCrit()->giveRemeshingStrategy( this->giveCurrentStep() );
// if ((strategy == RemeshingFromCurrentState_RS) && (this->giveDomain(1)->giveSerialNumber() == 0))
// strategy = RemeshingFromPreviousState_RS;
if ( strategy == NoRemeshing_RS ) {
//
} else if ( ( strategy == RemeshingFromCurrentState_RS ) || ( strategy == RemeshingFromPreviousState_RS ) ) {
// do remeshing
MesherInterface *mesher = classFactory.createMesherInterface( meshPackage, this->giveDomain(1) );
Domain *newDomain;
MesherInterface :: returnCode result = mesher->createMesh(this->giveCurrentStep(), 1,
this->giveDomain(1)->giveSerialNumber() + 1, & newDomain);
delete mesher;
if ( result == MesherInterface :: MI_OK ) {
this->initFlag = 1;
this->adaptiveRemap(newDomain);
} else if ( result == MesherInterface :: MI_NEEDS_EXTERNAL_ACTION ) {
if ( strategy == RemeshingFromCurrentState_RS ) {
// ensure the updating the step
this->setContextOutputMode(COM_Always);
//this->terminate (this->giveCurrentStep());
} else {
// save previous step (because update not called)
}
this->terminateAnalysis();
throw OOFEM_Terminate();
} else {
OOFEM_ERROR("createMesh failed");
}
}
}
void
LEPlic :: updatePosition(TimeStep *atTime)
{
#ifdef __OOFEG
//deleteLayerGraphics(OOFEG_DEBUG_LAYER);
EVFastRedraw(myview);
#endif
this->doLagrangianPhase(atTime);
this->doInterfaceReconstruction(atTime, true, false);
#ifdef __OOFEG
//ESIEventLoop (YES, "doInterfaceReconstruction Finished; Press Ctrl-p to continue");
deleteLayerGraphics(OOFEG_DEBUG_LAYER);
#endif
this->doInterfaceRemapping(atTime);
// here the new VOF values are determined, now we call doInterfaceReconstruction
// to reconstruct interface (normal, constant) on original grid
this->doInterfaceReconstruction(atTime, false, true);
#ifdef __OOFEG
ESIEventLoop( NO, const_cast< char * >("doInterfaceReconstruction Finished; Press Ctrl-p to continue") );
//ESIEventLoop (YES, "doInterfaceReconstruction Finished; Press Ctrl-p to continue");
#endif
}
int
AdaptiveNonLinearStatic :: adaptiveRemap(Domain *dNew)
{
int ielem, nelem, result = 1;
this->initStepIncrements();
this->ndomains = 2;
this->domainNeqs.resize(2);
this->domainPrescribedNeqs.resize(2);
this->domainNeqs.at(2) = 0;
this->domainPrescribedNeqs.at(2) = 0;
this->domainList->put(2, dNew);
#ifdef __PARALLEL_MODE
ParallelContext *pcNew = new ParallelContext(this);
this->parallelContextList->put(2, pcNew);
#endif
// init equation numbering
//this->forceEquationNumbering(2);
this->forceEquationNumbering();
// measure time consumed by mapping
Timer timer;
double mc1, mc2, mc3;
timer.startTimer();
// map primary unknowns
EIPrimaryUnknownMapper mapper;
d2_totalDisplacement.resize( this->giveNumberOfDomainEquations( 2, EModelDefaultEquationNumbering() ) );
d2_incrementOfDisplacement.resize( this->giveNumberOfDomainEquations( 2, EModelDefaultEquationNumbering() ) );
d2_totalDisplacement.zero();
d2_incrementOfDisplacement.zero();
result &= mapper.mapAndUpdate( d2_totalDisplacement, VM_Total,
this->giveDomain(1), this->giveDomain(2), this->giveCurrentStep() );
result &= mapper.mapAndUpdate( d2_incrementOfDisplacement, VM_Incremental,
this->giveDomain(1), this->giveDomain(2), this->giveCurrentStep() );
timer.stopTimer();
mc1 = timer.getUtime();
timer.startTimer();
// map internal ip state
nelem = this->giveDomain(2)->giveNumberOfElements();
for ( ielem = 1; ielem <= nelem; ielem++ ) {
/* HUHU CHEATING */
#ifdef __PARALLEL_MODE
if ( this->giveDomain(2)->giveElement(ielem)->giveParallelMode() == Element_remote ) {
continue;
}
#endif
result &= this->giveDomain(2)->giveElement(ielem)->adaptiveMap( this->giveDomain(1), this->giveCurrentStep() );
}
/* replace domains */
OOFEM_LOG_DEBUG("deleting old domain\n");
//delete domainList->at(1);
//domainList->put(1, dNew);
//dNew->setNumber(1);
//domainList->put(2, NULL);
domainList->put( 1, domainList->unlink(2) );
domainList->at(1)->setNumber(1);
#ifdef __PARALLEL_MODE
parallelContextList->put( 1, parallelContextList->unlink(2) );
parallelContextList->growTo(1);
#endif
// keep equation numbering of new domain
this->numberOfEquations = this->domainNeqs.at(1) = this->domainNeqs.at(2);
this->numberOfPrescribedEquations = this->domainPrescribedNeqs.at(1) = this->domainPrescribedNeqs.at(2);
this->equationNumberingCompleted = 1;
// update solution
totalDisplacement = d2_totalDisplacement;
incrementOfDisplacement = d2_incrementOfDisplacement;
this->ndomains = 1;
// init equation numbering
// this->forceEquationNumbering();
this->updateDomainLinks();
#ifdef __PARALLEL_MODE
if ( isParallel() ) {
// set up communication patterns
this->initializeCommMaps(true);
this->exchangeRemoteElementData(RemoteElementExchangeTag);
}
#endif
timer.stopTimer();
mc2 = timer.getUtime();
timer.startTimer();
// computes the stresses and calls updateYourself to mapped state
for ( ielem = 1; ielem <= nelem; ielem++ ) {
/* HUHU CHEATING */
#ifdef __PARALLEL_MODE
if ( this->giveDomain(1)->giveElement(ielem)->giveParallelMode() == Element_remote ) {
continue;
}
#endif
result &= this->giveDomain(1)->giveElement(ielem)->adaptiveUpdate( this->giveCurrentStep() );
}
// finish mapping process
for ( ielem = 1; ielem <= nelem; ielem++ ) {
/* HUHU CHEATING */
#ifdef __PARALLEL_MODE
if ( this->giveDomain(1)->giveElement(ielem)->giveParallelMode() == Element_remote ) {
continue;
}
#endif
result &= this->giveDomain(1)->giveElement(ielem)->adaptiveFinish( this->giveCurrentStep() );
}
nMethod->reinitialize();
// increment time step if mapped state will be considered as new solution stepL
// this->giveNextStep();
if ( equilibrateMappedConfigurationFlag ) {
// we need to assemble the load vector in same time as the restarted step,
// so new time step is generated with same intrincic time as has the
// previous step if equilibrateMappedConfigurationFlag is set.
// this allows to equlibrate the previously reached state
TimeStep *cts = this->giveCurrentStep();
// increment version of solution step
cts->incrementVersion();
//cts->setTime(cts->giveTime()-cts->giveTimeIncrement());
//cts = this->givePreviousStep();
//cts->setTime(cts->giveTime()-cts->giveTimeIncrement());
}
if ( this->giveCurrentStep()->giveNumber() == this->giveCurrentMetaStep()->giveFirstStepNumber() ) {
this->updateAttributes( this->giveCurrentMetaStep() );
}
// increment solution state counter - not needed, IPs are updated by adaptiveUpdate previously called
// and there is no change in primary vars.
// this->giveCurrentStep()->incrementStateCounter();
// assemble new initial load for new discretization
this->assembleInitialLoadVector( initialLoadVector, initialLoadVectorOfPrescribed,
this, 1, this->giveCurrentStep() );
this->assembleIncrementalReferenceLoadVectors( incrementalLoadVector, incrementalLoadVectorOfPrescribed,
refLoadInputMode, this->giveDomain(1), EID_MomentumBalance,
this->giveCurrentStep() );
// assemble new total load for new discretization
// this->assembleCurrentTotalLoadVector (totalLoadVector, totalLoadVectorOfPrescribed, this->giveCurrentStep());
// set bcloadVector to zero (no increment within same step)
timer.stopTimer();
mc3 = timer.getUtime();
// compute processor time used by the program
OOFEM_LOG_INFO("user time consumed by primary mapping: %.2fs\n", mc1);
OOFEM_LOG_INFO("user time consumed by ip mapping: %.2fs\n", mc2);
OOFEM_LOG_INFO("user time consumed by ip update: %.2fs\n", mc3);
OOFEM_LOG_INFO("user time consumed by mapping: %.2fs\n", mc1 + mc2 + mc3);
//
/********
* #if 0
* {
*
* // evaluate the force error of mapped configuration
* this->updateComponent (this->giveCurrentStep(), InternalRhs);
* FloatArray rhs;
*
* loadVector.resize (this->numberOfEquations);
* loadVector.zero();
* this->assemble (loadVector, this->giveCurrentStep(), ExternalForcesVector_Total, this->giveDomain(1)) ;
* this->assemble (loadVector, this->giveCurrentStep(), ExternalForcesVector_Total, this->giveDomain(1));
*
* rhs = loadVector;
* rhs.times(loadLevel);
* if (initialLoadVector.isNotEmpty()) rhs.add(initialLoadVector);
* rhs.subtract(internalForces);
*
* //
* // compute forceError
* //
* // err is relative error of unbalanced forces
* double RR, RR0, forceErr = dotProduct (rhs.givePointer(),rhs.givePointer(),rhs.giveSize());
* if (initialLoadVector.isNotEmpty())
* RR0 = dotProduct (initialLoadVector.givePointer(), initialLoadVector.givePointer(), initialLoadVector.giveSize());
* else
* RR0 = 0.0;
* RR = dotProduct(loadVector.givePointer(),loadVector.givePointer(),loadVector.giveSize());
* // we compute a relative error norm
* if ((RR0 + RR * loadLevel * loadLevel) < calm_SMALL_NUM) forceErr = 0.;
* else forceErr = sqrt (forceErr / (RR0+RR * loadLevel * loadLevel));
*
* printf ("Relative Force Error of Mapped Configuration is %-15e\n", forceErr);
*
* }
**#endif
*************/
#ifdef __OOFEG
ESIEventLoop( YES, const_cast< char * >("AdaptiveRemap: Press Ctrl-p to continue") );
#endif
//
// bring mapped configuration into equilibrium
//
if ( equilibrateMappedConfigurationFlag ) {
// use secant stiffness to resrore equilibrium
NonLinearStatic_stiffnessMode oldStiffMode = this->stiffMode;
stiffMode = nls_secantStiffness;
if ( initFlag ) {
if ( !stiffnessMatrix ) {
stiffnessMatrix = classFactory.createSparseMtrx(sparseMtrxType);
if ( stiffnessMatrix == NULL ) {
OOFEM_ERROR("sparse matrix creation failed");
}
}
if ( nonlocalStiffnessFlag ) {
if ( !stiffnessMatrix->isAsymmetric() ) {
OOFEM_ERROR("stiffnessMatrix does not support asymmetric storage");
}
}
stiffnessMatrix->buildInternalStructure( this, 1, EID_MomentumBalance, EModelDefaultEquationNumbering() );
stiffnessMatrix->zero(); // zero stiffness matrix
this->assemble( stiffnessMatrix, this->giveCurrentStep(), EID_MomentumBalance, SecantStiffnessMatrix,
EModelDefaultEquationNumbering(), this->giveDomain(1) );
initFlag = 0;
}
// updateYourself() not necessary - the adaptiveUpdate previously called does the job
//this->updateYourself(this->giveCurrentStep());
#ifdef VERBOSE
OOFEM_LOG_INFO( "Equilibrating mapped configuration [step number %5d.%d]\n",
this->giveCurrentStep()->giveNumber(), this->giveCurrentStep()->giveVersion() );
#endif
//double deltaL = nMethod->giveUnknownComponent (StepLength, 0);
double deltaL = nMethod->giveCurrentStepLength();
//
// call numerical model to solve arised problem
//
#ifdef VERBOSE
OOFEM_LOG_RELEVANT( "Solving [step number %5d.%d]\n",
this->giveCurrentStep()->giveNumber(), this->giveCurrentStep()->giveVersion() );
#endif
//nMethod -> solveYourselfAt(this->giveCurrentStep()) ;
nMethod->setStepLength(deltaL / 5.0);
if ( initialLoadVector.isNotEmpty() ) {
numMetStatus = nMethod->solve( stiffnessMatrix, & incrementalLoadVector, & initialLoadVector,
& totalDisplacement, & incrementOfDisplacement, & internalForces,
internalForcesEBENorm, loadLevel, refLoadInputMode, currentIterations, this->giveCurrentStep() );
} else {
numMetStatus = nMethod->solve( stiffnessMatrix, & incrementalLoadVector, NULL,
& totalDisplacement, & incrementOfDisplacement, & internalForces,
internalForcesEBENorm, loadLevel, refLoadInputMode, currentIterations, this->giveCurrentStep() );
}
loadVector.zero();
this->updateYourself( this->giveCurrentStep() );
this->terminate( this->giveCurrentStep() );
// this->updateLoadVectors (this->giveCurrentStep()); // already in terminate
// restore old step length
nMethod->setStepLength(deltaL);
stiffMode = oldStiffMode;
} else {
// comment this, if output for mapped configuration (not equilibrated) not wanted
this->printOutputAt( this->giveOutputStream(), this->giveCurrentStep() );
}
return result;
}
