NM_Status PetscSolver :: solve(SparseMtrx *A, FloatArray *b, FloatArray *x)
{
int neqs;
// first check whether Lhs is defined
if ( !A ) {
_error("solve: unknown Lhs");
}
// and whether Rhs
if ( !b ) {
_error("solve: unknown Rhs");
}
// and whether previous Solution exist
if ( !x ) {
_error("solve: unknown solution array");
}
if ( x->giveSize() != ( neqs = b->giveSize() ) ) {
_error("solve: size mismatch");
}
if ( A->giveType() != SMT_PetscMtrx ) {
_error("solve: PetscSparseMtrx Expected");
}
PetscSparseMtrx *Lhs = ( PetscSparseMtrx * ) A;
Vec globRhsVec;
Vec globSolVec;
// "Parallel" context automatically uses sequential alternative if the engineering problem is sequential.
PetscContext *context = engngModel->givePetscContext( Lhs->giveDomainIndex(), Lhs->giveEquationID() );
/*
* scatter and gather rhs to global representation
*/
context->createVecGlobal(& globRhsVec);
context->scatter2G(b, globRhsVec, ADD_VALUES);
VecDuplicate(globRhsVec, & globSolVec);
//VecView(globRhsVec,PETSC_VIEWER_STDOUT_WORLD);
NM_Status s = this->petsc_solve(Lhs, globRhsVec, globSolVec);
//VecView(globSolVec,PETSC_VIEWER_STDOUT_WORLD);
context->scatterG2N(globSolVec, x, INSERT_VALUES);
VecDestroy(&globSolVec);
VecDestroy(&globRhsVec);
return s;
}
void
NRSolver :: applyConstraintsToStiffness(SparseMtrx &k)
{
if ( this->smConstraintVersion == k.giveVersion() ) {
return;
}
#ifdef __PETSC_MODULE
PetscSparseMtrx *lhs = dynamic_cast< PetscSparseMtrx * >(&k);
if ( lhs ) {
Vec diag;
PetscScalar *ptr;
int eq;
lhs->createVecGlobal(& diag);
MatGetDiagonal(* lhs->giveMtrx(), diag);
VecGetArray(diag, & ptr);
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
eq = prescribedEqs.at(i) - 1;
MatSetValue(* ( lhs->giveMtrx() ), eq, eq, ptr [ eq ] * 1.e6, INSERT_VALUES);
}
MatAssemblyBegin(* lhs->giveMtrx(), MAT_FINAL_ASSEMBLY);
MatAssemblyEnd(* lhs->giveMtrx(), MAT_FINAL_ASSEMBLY);
VecRestoreArray(diag, & ptr);
VecDestroy(& diag);
if ( numberOfPrescribedDofs ) {
this->smConstraintVersion = k.giveVersion();
}
return;
}
#endif // __PETSC_MODULE
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
k.at( prescribedEqs.at(i), prescribedEqs.at(i) ) *= 1.e6;
}
if ( numberOfPrescribedDofs ) {
this->smConstraintVersion = k.giveVersion();
}
}
void TrustRegionSolver3::calcSmallestEigVal(double &oEigVal, FloatArray &oEigVec, PetscSparseMtrx &K) {
PetscErrorCode ierr;
ST st;
double eig_rtol = 1.0e-3;
int max_iter = 10000;
int nroot = 1;
if ( !epsInit ) {
/*
* Create eigensolver context
*/
#ifdef __PARALLEL_MODE
MPI_Comm comm = engngModel->giveParallelComm();
#else
MPI_Comm comm = PETSC_COMM_SELF;
#endif
ierr = EPSCreate(comm, & eps);
checkPetscError(ierr);
epsInit = true;
}
ierr = EPSSetOperators( eps, * K.giveMtrx(), NULL );
checkPetscError(ierr);
ierr = EPSSetProblemType(eps, EPS_NHEP);
checkPetscError(ierr);
ierr = EPSGetST(eps, & st);
checkPetscError(ierr);
// ierr = STSetType(st, STCAYLEY);
// ierr = STSetType(st, STSINVERT);
ierr = STSetType(st, STSHIFT);
checkPetscError(ierr);
ierr = STSetMatStructure(st, SAME_NONZERO_PATTERN);
checkPetscError(ierr);
ierr = EPSSetTolerances(eps, ( PetscReal ) eig_rtol, max_iter);
checkPetscError(ierr);
ierr = EPSSetDimensions(eps, ( PetscInt ) nroot, PETSC_DECIDE, PETSC_DECIDE);
checkPetscError(ierr);
ierr = EPSSetWhichEigenpairs(eps, EPS_SMALLEST_REAL);
checkPetscError(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Solve the eigensystem
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
EPSConvergedReason eig_reason;
int eig_nconv, eig_nite;
ierr = EPSSolve(eps);
checkPetscError(ierr);
ierr = EPSGetConvergedReason(eps, & eig_reason);
checkPetscError(ierr);
ierr = EPSGetIterationNumber(eps, & eig_nite);
checkPetscError(ierr);
// printf("SLEPcSolver::solve EPSConvergedReason: %d, number of iterations: %d\n", eig_reason, eig_nite);
ierr = EPSGetConverged(eps, & eig_nconv);
checkPetscError(ierr);
double smallest_eig_val = 1.0e20;
if ( eig_nconv > 0 ) {
// printf("SLEPcSolver :: solveYourselfAt: Convergence reached for RTOL=%20.15f\n", eig_rtol);
FloatArray eig_vals(nroot);
PetscScalar kr;
Vec Vr;
K.createVecGlobal(& Vr);
FloatArray Vr_loc;
for ( int i = 0; i < eig_nconv && i < nroot; i++ ) {
// PetscErrorCode EPSGetEigenpair(EPS eps,PetscInt i,PetscScalar *eigr,PetscScalar *eigi,Vec Vr,Vec Vi)
ierr = EPSGetEigenpair(eps, i, & kr, PETSC_NULL, Vr, PETSC_NULL);
checkPetscError(ierr);
//Store the eigenvalue
eig_vals(i) = kr;
if(kr < smallest_eig_val) {
smallest_eig_val = kr;
K.scatterG2L(Vr, Vr_loc);
oEigVec = Vr_loc;
}
}
ierr = VecDestroy(& Vr);
checkPetscError(ierr);
} else {
// OOFEM_ERROR("No converged eigenpairs.\n");
printf("Warning: No converged eigenpairs.\n");
smallest_eig_val = 1.0;
}
oEigVal = smallest_eig_val;
}
void LSPrimaryVariableMapper :: mapPrimaryVariables(FloatArray &oU, Domain &iOldDom, Domain &iNewDom, ValueModeType iMode, TimeStep &iTStep)
{
EngngModel *engngMod = iNewDom.giveEngngModel();
EModelDefaultEquationNumbering num;
const int dim = iNewDom.giveNumberOfSpatialDimensions();
int numElNew = iNewDom.giveNumberOfElements();
// Count dofs
int numDofsNew = engngMod->giveNumberOfDomainEquations( 1, num );
oU.resize(numDofsNew);
oU.zero();
FloatArray du(numDofsNew);
du.zero();
FloatArray res(numDofsNew);
#ifdef __PETSC_MODULE
PetscSparseMtrx *K = dynamic_cast<PetscSparseMtrx*>( classFactory.createSparseMtrx(SMT_PetscMtrx) );
SparseLinearSystemNM *solver = classFactory.createSparseLinSolver(ST_Petsc, & iOldDom, engngMod);
#else
SparseMtrx *K = classFactory.createSparseMtrx(SMT_Skyline);
SparseLinearSystemNM *solver = classFactory.createSparseLinSolver(ST_Direct, & iOldDom, engngMod);
#endif
K->buildInternalStructure( engngMod, 1, num );
int maxIter = 1;
for ( int iter = 0; iter < maxIter; iter++ ) {
K->zero();
res.zero();
// Contribution from elements
for ( int elIndex = 1; elIndex <= numElNew; elIndex++ ) {
StructuralElement *elNew = dynamic_cast< StructuralElement * >( iNewDom.giveElement(elIndex) );
if ( elNew == NULL ) {
OOFEM_ERROR("Failed to cast Element new to StructuralElement.");
}
///////////////////////////////////
// Compute residual
// Count element dofs
int numElNodes = elNew->giveNumberOfDofManagers();
int numElDofs = 0;
for ( int i = 1; i <= numElNodes; i++ ) {
numElDofs += elNew->giveDofManager(i)->giveNumberOfDofs();
}
FloatArray elRes(numElDofs);
elRes.zero();
IntArray elDofsGlob;
elNew->giveLocationArray( elDofsGlob, num );
// Loop over Gauss points
for ( int intRuleInd = 0; intRuleInd < elNew->giveNumberOfIntegrationRules(); intRuleInd++ ) {
IntegrationRule *iRule = elNew->giveIntegrationRule(intRuleInd);
for ( GaussPoint *gp: *iRule ) {
// New N-matrix
FloatMatrix NNew;
elNew->computeNmatrixAt(* ( gp->giveNaturalCoordinates() ), NNew);
//////////////
// Global coordinates of GP
const int nDofMan = elNew->giveNumberOfDofManagers();
FloatArray Nc;
FEInterpolation *interp = elNew->giveInterpolation();
const FloatArray &localCoord = * ( gp->giveNaturalCoordinates() );
interp->evalN( Nc, localCoord, FEIElementGeometryWrapper(elNew) );
const IntArray &elNodes = elNew->giveDofManArray();
FloatArray globalCoord(dim);
globalCoord.zero();
for ( int i = 1; i <= nDofMan; i++ ) {
DofManager *dMan = elNew->giveDofManager(i);
for ( int j = 1; j <= dim; j++ ) {
globalCoord.at(j) += Nc.at(i) * dMan->giveCoordinate(j);
}
}
//////////////
// Localize element and point in the old domain
FloatArray localCoordOld(dim), pointCoordOld(dim);
StructuralElement *elOld = dynamic_cast< StructuralElement * >( iOldDom.giveSpatialLocalizer()->giveElementClosestToPoint(localCoordOld, pointCoordOld, globalCoord, 0) );
if ( elOld == NULL ) {
OOFEM_ERROR("Failed to cast Element old to StructuralElement.");
}
// Compute N-Matrix for the old element
FloatMatrix NOld;
elOld->computeNmatrixAt(localCoordOld, NOld);
// Fetch nodal displacements for the new element
FloatArray nodeDispNew( elDofsGlob.giveSize() );
int dofsPassed = 1;
for ( int i = 1; i <= elNodes.giveSize(); i++ ) {
DofManager *dMan = elNew->giveDofManager(i);
for ( Dof *dof: *dMan ) {
if ( elDofsGlob.at(dofsPassed) != 0 ) {
nodeDispNew.at(dofsPassed) = oU.at( elDofsGlob.at(dofsPassed) );
} else {
if ( dof->hasBc(& iTStep) ) {
nodeDispNew.at(dofsPassed) = dof->giveBcValue(iMode, & iTStep);
}
}
dofsPassed++;
}
}
FloatArray newDisp;
newDisp.beProductOf(NNew, nodeDispNew);
// Fetch nodal displacements for the old element
FloatArray nodeDispOld;
dofsPassed = 1;
IntArray elDofsGlobOld;
elOld->giveLocationArray( elDofsGlobOld, num );
// elOld->computeVectorOf(iMode, &(iTStep), nodeDisp);
int numElNodesOld = elOld->giveNumberOfDofManagers();
for(int nodeIndOld = 1; nodeIndOld <= numElNodesOld; nodeIndOld++) {
DofManager *dManOld = elOld->giveDofManager(nodeIndOld);
for ( Dof *dof: *dManOld ) {
if ( elDofsGlobOld.at(dofsPassed) != 0 ) {
FloatArray dofUnknowns;
dof->giveUnknowns(dofUnknowns, iMode, &iTStep);
#ifdef DEBUG
if(!dofUnknowns.isFinite()) {
OOFEM_ERROR("!dofUnknowns.isFinite()")
}
if(dofUnknowns.giveSize() < 1) {
OOFEM_ERROR("dofUnknowns.giveSize() < 1")
}
#endif
nodeDispOld.push_back(dofUnknowns.at(1));
} else {
if ( dof->hasBc(& iTStep) ) {
// printf("hasBC.\n");
#ifdef DEBUG
if(!std::isfinite(dof->giveBcValue(iMode, & iTStep))) {
OOFEM_ERROR("!std::isfinite(dof->giveBcValue(iMode, & iTStep))")
}
#endif
nodeDispOld.push_back( dof->giveBcValue(iMode, & iTStep) );
}
else {
// printf("Unhandled case in LSPrimaryVariableMapper :: mapPrimaryVariables().\n");
nodeDispOld.push_back( 0.0 );
}
}
dofsPassed++;
}
}
FloatArray oldDisp;
oldDisp.beProductOf(NOld, nodeDispOld);
FloatArray temp, du;
#ifdef DEBUG
if(!oldDisp.isFinite()) {
OOFEM_ERROR("!oldDisp.isFinite()")
}
if(!newDisp.isFinite()) {
OOFEM_ERROR("!newDisp.isFinite()")
}
#endif
du.beDifferenceOf(oldDisp, newDisp);
temp.beTProductOf(NNew, du);
double dV = elNew->computeVolumeAround(gp);
elRes.add(dV, temp);
}
}
void
NRSolver :: applyConstraintsToLoadIncrement(int nite, const SparseMtrx *k, FloatArray &R,
referenceLoadInputModeType rlm, TimeStep *atTime)
{
double factor = engngModel->giveDomain(1)->giveLoadTimeFunction(prescribedDisplacementLTF)->__at( atTime->giveTargetTime() );
if ( ( rlm == rlm_total ) && ( !atTime->isTheFirstStep() ) ) {
//factor -= engngModel->giveDomain(1)->giveLoadTimeFunction(prescribedDisplacementLTF)->
// at(atTime->givePreviousStep()->giveTime()) ;
factor -= engngModel->giveDomain(1)->giveLoadTimeFunction(prescribedDisplacementLTF)->
__at( atTime->giveTargetTime() - atTime->giveTimeIncrement() );
}
if ( nite == 0 ) {
#if 0
#ifdef __PETSC_MODULE
if ( solverType == ST_Petsc ) {
#ifdef __PARALLEL_MODE
//Natural2LocalOrdering* n2lpm = engngModel->givePetscContext(1)->giveN2Lmap();
//IntArray* map = n2lpm->giveN2Lmap();
for ( i = 1; i <= prescribedEqs.giveSize(); i++ ) {
eq = prescribedEqs.at(i);
R.at(eq) = prescribedDofsValues.at(i) * factor; // local eq
}
return;
#else // PETSC_SERIAL
for ( i = 1; i <= numberOfPrescribedDofs; i++ ) {
eq = prescribedEqs.at(i);
R.at(eq) = prescribedDofsValues.at(i) * factor;
}
return;
#endif
}
#endif
#else
#ifdef __PETSC_MODULE
if ( solverType == ST_Petsc ) {
if ( k->giveType() != SMT_PetscMtrx ) {
OOFEM_ERROR("NRSolver :: applyConstraintsToStiffness: PetscSparseMtrx Expected");
}
PetscSparseMtrx *lhs = ( PetscSparseMtrx * ) k;
Vec diag;
PetscScalar *ptr;
engngModel->givePetscContext(this->domain->giveNumber())->createVecGlobal(& diag);
MatGetDiagonal(* lhs->giveMtrx(), diag);
VecGetArray(diag, & ptr);
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
int eq = prescribedEqs.at(i) - 1;
R.at(eq + 1) = ptr [ eq ] * prescribedDofsValues.at(i) * factor;
}
VecRestoreArray(diag, & ptr);
VecDestroy(&diag);
return;
}
#endif
#endif
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
int eq = prescribedEqs.at(i);
R.at(eq) = k->at(eq, eq) * prescribedDofsValues.at(i) * factor;
}
} else {
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
R.at( prescribedEqs.at(i) ) = 0.0;
}
}
}
void
NRSolver :: applyConstraintsToStiffness(SparseMtrx *k)
{
if ( this->smConstraintVersion == k->giveVersion() ) {
return;
}
#if 0
#ifdef __PETSC_MODULE
if ( solverType == ST_Petsc ) {
PetscScalar diagVal = 1.0;
if ( k->giveType() != SMT_PetscMtrx ) {
OOFEM_ERROR("NRSolver :: applyConstraintsToStiffness: PetscSparseMtrx Expected");
}
PetscSparseMtrx *lhs = ( PetscSparseMtrx * ) k;
if ( !prescribedEgsIS_defined ) {
IntArray eqs;
#ifdef __PARALLEL_MODE
Natural2GlobalOrdering *n2lpm = engngModel->givePetscContext(1)->giveN2Gmap();
int s = prescribedEqs.giveSize();
eqs.resize(s);
for ( int i = 1; i <= s; i++ ) {
eqs.at(i) = n2lpm->giveNewEq( prescribedEqs.at(i) );
}
ISCreateGeneral(PETSC_COMM_WORLD, s, eqs.givePointer(), & prescribedEgsIS);
//ISView(prescribedEgsIS,PETSC_VIEWER_STDOUT_WORLD);
#else
eqs.resize(numberOfPrescribedDofs);
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
eqs.at(i) = prescribedEqs.at(i) - 1;
}
ISCreateGeneral(PETSC_COMM_SELF, numberOfPrescribedDofs, eqs.givePointer(), & prescribedEgsIS);
//ISView(prescribedEgsIS,PETSC_VIEWER_STDOUT_SELF);
#endif
prescribedEgsIS_defined = true;
}
//MatView(*(lhs->giveMtrx()),PETSC_VIEWER_STDOUT_WORLD);
MatZeroRows(* ( lhs->giveMtrx() ), prescribedEgsIS, & diagVal);
//MatView(*(lhs->giveMtrx()),PETSC_VIEWER_STDOUT_WORLD);
if ( numberOfPrescribedDofs ) {
this->smConstraintVersion = k->giveVersion();
}
return;
}
#endif // __PETSC_MODULE
#else
#ifdef __PETSC_MODULE
if ( solverType == ST_Petsc ) {
if ( k->giveType() != SMT_PetscMtrx ) {
OOFEM_ERROR("NRSolver :: applyConstraintsToStiffness: PetscSparseMtrx Expected");
}
PetscSparseMtrx *lhs = ( PetscSparseMtrx * ) k;
Vec diag;
PetscScalar *ptr;
int eq;
PetscContext *parallel_context = engngModel->givePetscContext(this->domain->giveNumber());
parallel_context->createVecGlobal(& diag);
MatGetDiagonal(* lhs->giveMtrx(), diag);
VecGetArray(diag, & ptr);
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
eq = prescribedEqs.at(i) - 1;
MatSetValue(* ( lhs->giveMtrx() ), eq, eq, ptr [ eq ] * 1.e6, INSERT_VALUES);
}
MatAssemblyBegin(* lhs->giveMtrx(), MAT_FINAL_ASSEMBLY);
MatAssemblyEnd(* lhs->giveMtrx(), MAT_FINAL_ASSEMBLY);
VecRestoreArray(diag, & ptr);
VecDestroy(&diag);
if ( numberOfPrescribedDofs ) {
this->smConstraintVersion = k->giveVersion();
}
return;
}
#endif // __PETSC_MODULE
#endif
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
k->at( prescribedEqs.at(i), prescribedEqs.at(i) ) *= 1.e6;
}
if ( numberOfPrescribedDofs ) {
this->smConstraintVersion = k->giveVersion();
}
}