void
CompCol_ICPreconditioner :: init(const SparseMtrx &A)
{
if ( A.giveType() == SMT_SymCompCol ) {
this->initialize( * ( ( SymCompCol * ) & A ) );
} else if ( A.giveType() == SMT_CompCol ) {
this->initialize( * ( ( CompCol * ) & A ) );
} else {
OOFEM_ERROR("unsupported sparse matrix type");
}
}
NM_Status
IMLSolver :: solve(SparseMtrx &A, FloatArray &b, FloatArray &x)
{
int result;
if ( x.giveSize() != b.giveSize() ) {
OOFEM_ERROR("size mismatch");
}
// check preconditioner
if ( M ) {
if ( ( precondInit ) || ( Lhs != &A ) || ( this->lhsVersion != A.giveVersion() ) ) {
M->init(A);
}
} else {
OOFEM_ERROR("preconditioner creation error");
}
Lhs = &A;
this->lhsVersion = A.giveVersion();
#ifdef TIME_REPORT
Timer timer;
timer.startTimer();
#endif
if ( solverType == IML_ST_CG ) {
int mi = this->maxite;
double t = this->tol;
result = CG(* Lhs, x, b, * M, mi, t);
OOFEM_LOG_INFO("CG(%s): flag=%d, nite %d, achieved tol. %g\n", M->giveClassName(), result, mi, t);
} else if ( solverType == IML_ST_GMRES ) {
int mi = this->maxite, restart = 100;
double t = this->tol;
FloatMatrix H(restart + 1, restart); // storage for upper Hesenberg
result = GMRES(* Lhs, x, b, * M, H, restart, mi, t);
OOFEM_LOG_INFO("GMRES(%s): flag=%d, nite %d, achieved tol. %g\n", M->giveClassName(), result, mi, t);
} else {
OOFEM_ERROR("unknown lsover type");
}
#ifdef TIME_REPORT
timer.stopTimer();
OOFEM_LOG_INFO( "IMLSolver info: user time consumed by solution: %.2fs\n", timer.getUtime() );
#endif
//solved = 1;
return NM_Success;
}
void
NonLinearDynamic :: assemble(SparseMtrx &answer, TimeStep *tStep, const MatrixAssembler &ma,
const UnknownNumberingScheme &s, Domain *domain)
{
#ifdef TIME_REPORT
Timer timer;
timer.startTimer();
#endif
EngngModel :: assemble(answer, tStep, ma, s, domain);
if ( ( nonlocalStiffnessFlag ) && dynamic_cast< const TangentAssembler* >(&ma) ) {
// Add nonlocal contribution.
for ( auto &elem : domain->giveElements() ) {
static_cast< NLStructuralElement * >( elem.get() )->addNonlocalStiffnessContributions(answer, s, tStep);
}
// Print storage statistics.
answer.printStatistics();
}
#ifdef TIME_REPORT
timer.stopTimer();
OOFEM_LOG_DEBUG( "NonLinearDynamic info: user time consumed by assembly: %.2fs\n", timer.getUtime() );
#endif
}
void
TrabBoneNL3D :: NonlocalMaterialStiffnessInterface_addIPContribution(SparseMtrx &dest, const UnknownNumberingScheme &s, GaussPoint *gp, TimeStep *tStep)
{
TrabBoneNL3DStatus *nlStatus = static_cast< TrabBoneNL3DStatus * >( this->giveStatus(gp) );
std :: list< localIntegrationRecord > *list = nlStatus->giveIntegrationDomainList();
TrabBoneNL3D *rmat;
double coeff;
FloatArray rcontrib, lcontrib;
IntArray loc, rloc;
FloatMatrix contrib;
if ( this->giveLocalNonlocalStiffnessContribution(gp, loc, s, lcontrib, tStep) == 0 ) {
return;
}
for ( auto &lir: *list ) {
rmat = dynamic_cast< TrabBoneNL3D * >( lir.nearGp->giveMaterial() );
if ( rmat ) {
rmat->giveRemoteNonlocalStiffnessContribution(lir.nearGp, rloc, s, rcontrib, tStep);
coeff = gp->giveElement()->computeVolumeAround(gp) * lir.weight / nlStatus->giveIntegrationScale();
contrib.clear();
contrib.plusDyadUnsym(lcontrib, rcontrib, - 1.0 * coeff);
dest.assemble(loc, rloc, contrib);
}
}
}
void SurfaceTensionBoundaryCondition :: assemble(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
if ( !this->useTangent || type != TangentStiffnessMatrix ) {
return;
}
OOFEM_ERROR("Not implemented yet.");
FloatMatrix Ke;
IntArray r_loc, c_loc, bNodes;
Set *set = this->giveDomain()->giveSet(this->set);
const IntArray &boundaries = set->giveBoundaryList();
for ( int pos = 1; pos <= boundaries.giveSize() / 2; ++pos ) {
Element *e = this->giveDomain()->giveElement( boundaries.at(pos * 2 - 1) );
int boundary = boundaries.at(pos * 2);
e->giveInterpolation()->boundaryGiveNodes(bNodes, boundary);
e->giveBoundaryLocationArray(r_loc, bNodes, this->dofs, r_s);
e->giveBoundaryLocationArray(c_loc, bNodes, this->dofs, c_s);
this->computeTangentFromElement(Ke, e, boundary, tStep);
answer.assemble(r_loc, c_loc, Ke);
}
}
void
ContactDefinition :: computeContactTangent(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
FloatMatrix Kc;
IntArray locArrayR, locArrayC;
for ( auto &master : this->masterElementList ) {
//if ( master->isInContact() ) { // tangent becomes singular with this
//printf("node in contact: computeContactTangent\n\n");
master->computeContactTangent(Kc, type, tStep);
// do this in contact element?
Kc.negated(); // should be negated!
master->giveLocationArray(locArrayR, r_s);
master->giveLocationArray(locArrayC, c_s);
answer.assemble(locArrayR, locArrayC, Kc);
//}
}
}
void PrescribedGradientBCWeak :: assemble(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
std::vector<FloatArray> gpCoordArray;
if ( type == TangentStiffnessMatrix || type == SecantStiffnessMatrix || type == ElasticStiffnessMatrix ) {
for( TracSegArray* el : mpTracElNew ) {
for ( GaussPoint *gp: *(el->mIntRule.get()) ) {
gpCoordArray.push_back( gp->giveGlobalCoordinates() );
assembleGPContrib(answer, tStep, type, r_s, c_s, *el, *gp);
}
}
if ( mpDisplacementLock != NULL ) {
int nsd = domain->giveNumberOfSpatialDimensions();
FloatMatrix KeDispLock(nsd, nsd);
KeDispLock.beUnitMatrix();
KeDispLock.times(mDispLockScaling);
int placeInArray = domain->giveDofManPlaceInArray(mLockNodeInd);
DofManager *node = domain->giveDofManager(placeInArray);
IntArray lockRows, lockCols, nodeRows, nodeCols;
mpDisplacementLock->giveLocationArray(giveDispLockDofIDs(), lockRows, r_s);
node->giveLocationArray(giveRegularDispDofIDs(), nodeRows, r_s);
mpDisplacementLock->giveLocationArray(giveDispLockDofIDs(), lockCols, c_s);
node->giveLocationArray(giveRegularDispDofIDs(), nodeCols, c_s);
answer.assemble(lockRows, nodeCols, KeDispLock);
answer.assemble(nodeRows, lockCols, KeDispLock);
FloatMatrix KZero( lockRows.giveSize(), lockCols.giveSize() );
KZero.zero();
answer.assemble(lockRows, lockCols, KZero);
}
} else {
printf("Skipping assembly in PrescribedGradientBCWeak::assemble().\n");
}
// std :: string fileName("TracGpCoord.vtk");
// XFEMDebugTools :: WritePointsToVTK(fileName, gpCoordArray);
}
void
NRSolver :: applyConstraintsToLoadIncrement(int nite, const SparseMtrx &k, FloatArray &R,
referenceLoadInputModeType rlm, TimeStep *tStep)
{
double factor = engngModel->giveDomain(1)->giveFunction(prescribedDisplacementTF)->evaluateAtTime( tStep->giveTargetTime() );
if ( ( rlm == rlm_total ) && ( !tStep->isTheFirstStep() ) ) {
//factor -= engngModel->giveDomain(1)->giveFunction(prescribedDisplacementTF)->
// at(tStep->givePreviousStep()->giveTime()) ;
factor -= engngModel->giveDomain(1)->giveFunction(prescribedDisplacementTF)->
evaluateAtTime( tStep->giveTargetTime() - tStep->giveTimeIncrement() );
}
if ( nite == 0 ) {
#if 0
#ifdef __PETSC_MODULE
if ( solverType == ST_Petsc ) {
//Natural2LocalOrdering* n2lpm = engngModel->giveParallelContext(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;
}
#endif
#else
#ifdef __PETSC_MODULE
const PetscSparseMtrx *lhs = dynamic_cast< const PetscSparseMtrx * >(&k);
if ( lhs ) {
Vec diag;
PetscScalar *ptr;
lhs->createVecGlobal(& diag);
MatGetDiagonal(* ( const_cast< PetscSparseMtrx * >(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;
}
#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 MixedGradientPressureWeakPeriodic :: assemble(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
if ( type == TangentStiffnessMatrix || type == SecantStiffnessMatrix || type == ElasticStiffnessMatrix ) {
FloatMatrix Ke_v, Ke_vT, Ke_e, Ke_eT;
IntArray v_loc_r, v_loc_c, t_loc_r, t_loc_c, e_loc_r, e_loc_c;
IntArray bNodes;
Set *set = this->giveDomain()->giveSet(this->set);
const IntArray &boundaries = set->giveBoundaryList();
// Fetch the columns/rows for the stress contributions;
this->tractionsdman->giveLocationArray(t_id, t_loc_r, r_s);
this->tractionsdman->giveLocationArray(t_id, t_loc_c, c_s);
this->voldman->giveLocationArray(v_id, e_loc_r, r_s);
this->voldman->giveLocationArray(v_id, e_loc_c, c_s);
for ( int pos = 1; pos <= boundaries.giveSize() / 2; ++pos ) {
Element *el = this->giveDomain()->giveElement( boundaries.at(pos * 2 - 1) );
int boundary = boundaries.at(pos * 2);
// Fetch the element information;
el->giveInterpolation()->boundaryGiveNodes(bNodes, boundary);
el->giveBoundaryLocationArray(v_loc_r, bNodes, this->dofs, r_s);
el->giveBoundaryLocationArray(v_loc_c, bNodes, this->dofs, c_s);
this->integrateTractionVelocityTangent(Ke_v, el, boundary);
this->integrateTractionXTangent(Ke_e, el, boundary);
Ke_v.negated();
Ke_vT.beTranspositionOf(Ke_v);
Ke_eT.beTranspositionOf(Ke_e);
answer.assemble(t_loc_r, v_loc_c, Ke_v);
answer.assemble(v_loc_r, t_loc_c, Ke_vT);
answer.assemble(t_loc_r, e_loc_c, Ke_e);
answer.assemble(e_loc_r, t_loc_c, Ke_eT);
}
}
}
void
CompCol_ILUPreconditioner :: init(const SparseMtrx &A)
{
#ifdef TIME_REPORT
Timer timer;
timer.startTimer();
#endif
if ( A.giveType() == SMT_CompCol ) {
this->initialize( * ( ( CompCol * ) & A ) );
} else if ( A.giveType() == SMT_DynCompCol ) {
this->initialize( * ( ( DynCompCol * ) & A ) );
} else {
OOFEM_ERROR("unsupported sparse matrix type");
}
#ifdef TIME_REPORT
timer.stopTimer();
OOFEM_LOG_INFO( "ILUP: user time consumed by factorization: %.2fs\n", timer.getUtime() );
#endif
}
void
CompCol_ILUPreconditioner :: init(const SparseMtrx &A)
{
#ifdef TIME_REPORT
//clock_t tstart = clock();
oofem_timeval tstart;
getUtime(tstart);
#endif
if ( A.giveType() == SMT_CompCol ) {
this->initialize( * ( ( CompCol * ) & A ) );
} else if ( A.giveType() == SMT_DynCompCol ) {
this->initialize( * ( ( DynCompCol * ) & A ) );
} else {
OOFEM_ERROR("CompCol_ILUPreconditioner::init : unsupported sparse matrix type");
}
#ifdef TIME_REPORT
oofem_timeval ut;
getRelativeUtime(ut, tstart);
OOFEM_LOG_INFO( "ILUP: user time consumed by factorization: %.2fs\n", ( double ) ( ut.tv_sec + ut.tv_usec / ( double ) OOFEM_USEC_LIM ) );
#endif
}
void PrescribedGradientBCNeumann :: assemble(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
if ( type == TangentStiffnessMatrix || type == SecantStiffnessMatrix || type == ElasticStiffnessMatrix ) {
FloatMatrix Ke, KeT;
IntArray loc_r, loc_c, sigma_loc_r, sigma_loc_c;
Set *set = this->giveDomain()->giveSet(this->set);
const IntArray &boundaries = set->giveBoundaryList();
// Fetch the columns/rows for the stress contributions;
mpSigmaHom->giveCompleteLocationArray(sigma_loc_r, r_s);
mpSigmaHom->giveCompleteLocationArray(sigma_loc_c, c_s);
for ( int pos = 1; pos <= boundaries.giveSize() / 2; ++pos ) {
Element *e = this->giveDomain()->giveElement( boundaries.at(pos * 2 - 1) );
int boundary = boundaries.at(pos * 2);
// Here, we could use only the nodes actually located on the boundary, but we don't.
// Instead, we use all nodes belonging to the element, which is allowed because the
// basis functions related to the interior nodes will be zero on the boundary.
// Obviously, this is less efficient, so why do we want to do it this way?
// Because it is easier when XFEM enrichments are present. /ES
e->giveLocationArray(loc_r, r_s);
e->giveLocationArray(loc_c, c_s);
this->integrateTangent(Ke, e, boundary);
Ke.negated();
KeT.beTranspositionOf(Ke);
answer.assemble(sigma_loc_r, loc_c, Ke); // Contribution to delta_s_i equations
answer.assemble(loc_r, sigma_loc_c, KeT); // Contributions to delta_v equations
}
} else {
printf("Skipping assembly in PrescribedGradientBCNeumann::assemble().\n");
}
}
// this method is running over all neighboring Gauss points
// and computes the contribution of the nonlocal interaction to tangent stiffness
// it uses methods
// giveLocalNonlocalStiffnessContribution
// giveRemoteNonlocalStiffnessContribution
// the first one computes m*gprime*Btransposed*sigmaeff for the present point
// the second one computes Btransposed*eta for the neighboring point
// (where eta is the derivative of cum. plastic strain wrt final strain)
// THIS METHOD CAN BE USED IN THE SAME FORM FOR ALL NONLOCAL DAMAGE-PLASTIC MODELS
void
RankineMatNl :: NonlocalMaterialStiffnessInterface_addIPContribution(SparseMtrx &dest, const UnknownNumberingScheme &s,
GaussPoint *gp, TimeStep *atTime)
{
double coeff;
RankineMatNlStatus *status = ( RankineMatNlStatus * ) this->giveStatus(gp);
dynaList< localIntegrationRecord > *list = status->giveIntegrationDomainList();
dynaList< localIntegrationRecord > :: iterator pos;
RankineMatNl *rmat;
FloatArray rcontrib, lcontrib;
IntArray loc, rloc;
FloatMatrix contrib;
if ( this->giveLocalNonlocalStiffnessContribution(gp, loc, s, lcontrib, atTime) == 0 ) {
return;
}
for ( pos = list->begin(); pos != list->end(); ++pos ) {
rmat = ( RankineMatNl * )( ( * pos ).nearGp )->giveMaterial();
if ( rmat->giveClassID() == this->giveClassID() ) {
rmat->giveRemoteNonlocalStiffnessContribution( ( * pos ).nearGp, rloc, s, rcontrib, atTime );
coeff = gp->giveElement()->computeVolumeAround(gp) * ( * pos ).weight / status->giveIntegrationScale();
int i, j, dim1 = loc.giveSize(), dim2 = rloc.giveSize();
contrib.resize(dim1, dim2);
for ( i = 1; i <= dim1; i++ ) {
for ( j = 1; j <= dim2; j++ ) {
contrib.at(i, j) = -1.0 * lcontrib.at(i) * rcontrib.at(j) * coeff;
}
}
dest.assemble(loc, rloc, contrib);
}
}
}
NM_Status
SubspaceIteration :: solve(SparseMtrx &a, SparseMtrx &b, FloatArray &_eigv, FloatMatrix &_r, double rtol, int nroot)
//
// this function solve the generalized eigenproblem using the Generalized
// jacobi iteration
//
{
if ( a.giveNumberOfColumns() != b.giveNumberOfColumns() ) {
OOFEM_ERROR("matrices size mismatch");
}
FloatArray temp, w, d, tt, f, rtolv, eigv;
FloatMatrix r;
int nn, nc1, ij = 0, is;
double rt, art, brt, eigvt;
FloatMatrix ar, br, vec;
std :: unique_ptr< SparseLinearSystemNM > solver( GiveClassFactory().createSparseLinSolver(ST_Direct, domain, engngModel) );
GJacobi mtd(domain, engngModel);
int nc = min(2 * nroot, nroot + 8);
nn = a.giveNumberOfColumns();
if ( nc > nn ) {
nc = nn;
}
ar.resize(nc, nc);
ar.zero();
br.resize(nc, nc);
br.zero();
//
// creation of initial iteration vectors
//
nc1 = nc - 1;
w.resize(nn);
w.zero();
d.resize(nc);
d.zero();
tt.resize(nn);
tt.zero();
rtolv.resize(nc);
rtolv.zero();
vec.resize(nc, nc);
vec.zero(); // eigen vectors of reduced problem
//
// create work arrays
//
r.resize(nn, nc);
r.zero();
eigv.resize(nc);
eigv.zero();
FloatArray h(nn);
for ( int i = 1; i <= nn; i++ ) {
h.at(i) = 1.0;
w.at(i) = b.at(i, i) / a.at(i, i);
}
b.times(h, tt);
r.setColumn(tt, 1);
for ( int j = 2; j <= nc; j++ ) {
rt = 0.0;
for ( int i = 1; i <= nn; i++ ) {
if ( fabs( w.at(i) ) >= rt ) {
rt = fabs( w.at(i) );
ij = i;
}
}
tt.at(j) = ij;
w.at(ij) = 0.;
for ( int i = 1; i <= nn; i++ ) {
if ( i == ij ) {
h.at(i) = 1.0;
} else {
h.at(i) = 0.0;
}
}
b.times(h, tt);
r.setColumn(tt, j);
} // (r = z)
# ifdef DETAILED_REPORT
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: Degrees of freedom invoked by initial vectors :\n");
tt.printYourself();
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: initial vectors for iteration:\n");
r.printYourself();
# endif
//ish = 0;
a.factorized();
//
// start of iteration loop
//
for ( int nite = 0; ; ++nite ) { // label 100
# ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Iteration loop no. %d\n", nite);
# endif
//
// compute projection ar and br of matrices a , b
//
for ( int j = 1; j <= nc; j++ ) {
f.beColumnOf(r, j);
solver->solve(a, f, tt);
for ( int i = j; i <= nc; i++ ) {
art = 0.;
for ( int k = 1; k <= nn; k++ ) {
art += r.at(k, i) * tt.at(k);
}
ar.at(j, i) = art;
}
r.setColumn(tt, j); // (r = xbar)
}
ar.symmetrized(); // label 110
#ifdef DETAILED_REPORT
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: Printing projection matrix ar\n");
ar.printYourself();
#endif
//
for ( int j = 1; j <= nc; j++ ) {
tt.beColumnOf(r, j);
b.times(tt, temp);
for ( int i = j; i <= nc; i++ ) {
brt = 0.;
for ( int k = 1; k <= nn; k++ ) {
brt += r.at(k, i) * temp.at(k);
}
br.at(j, i) = brt;
} // label 180
r.setColumn(temp, j); // (r=zbar)
} // label 160
br.symmetrized();
#ifdef DETAILED_REPORT
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: Printing projection matrix br\n");
br.printYourself();
#endif
//
// solution of reduced eigenvalue problem
//
mtd.solve(ar, br, eigv, vec);
// START EXPERIMENTAL
#if 0
// solve the reduced problem by Inverse iteration
{
FloatMatrix x(nc,nc), z(nc,nc), zz(nc,nc), arinv;
FloatArray w(nc), ww(nc), tt(nc), t(nc);
double c;
// initial setting
for ( int i = 1;i <= nc; i++ ) {
ww.at(i)=1.0;
}
for ( int i = 1;i <= nc; i++ )
for ( int j = 1; j <= nc;j++ )
z.at(i,j)=1.0;
arinv.beInverseOf (ar);
for ( int i = 0;i < nitem; i++ ) {
// copy zz=z
zz = z;
// solve matrix equation K.X = M.X
x.beProductOf(arinv, z);
// evaluation of Rayleigh quotients
for ( int j = 1;j <= nc; j++ ) {
w.at(j) = 0.0;
for (k = 1; k<= nc; k++) w.at(j) += zz.at(k,j) * x.at(k,j);
}
z.beProductOf (br, x);
for ( int j = 1;j <= nc; j++ ) {
c = 0;
for ( int k = 1; k<= nc; k++ ) c += z.at(k,j) * x.at(k,j);
w.at(j) /= c;
}
// check convergence
int ac = 0;
for ( int j = 1;j <= nc; j++ ) {
if (fabs((ww.at(j)-w.at(j))/w.at(j))< rtol) ac++;
ww.at(j) = w.at(j);
}
//printf ("\n iterace cislo %d %d",i,ac);
//w.printYourself();
// Gramm-Schmidt ortogonalization
for ( int j = 1;j <= nc;j++ ) {
for ( int k = 1; k<= nc; k++ ) tt.at(k) = x.at(k,j);
t.beProductOf(br,tt) ;
for ( int ii = 1;ii < j; ii++ ) {
c = 0.0;
for ( int k = 1; k<= nc; k++ ) c += x.at(k,ii) * t.at(k);
for ( int k = 1; k<= nc; k++ ) x.at(k,j) -= x.at(k,ii) * c;
}
for ( int k = 1; k<= nc; k++) tt.at(k) = x.at(k,j);
t.beProductOf(br, tt);
c = 0.0;
for ( int k = 1; k<= nc; k++) c += x.at(k,j)*t.at(k);
for ( int k = 1; k<= nc; k++) x.at(k,j) /= sqrt(c);
}
if ( ac > nroot ) {
break;
}
// compute new approximation of Z
z.beProductOf(br,x);
}
eigv = w;
vec = x;
}
#endif
//
// sorting eigenvalues according to their values
//
do {
is = 0; // label 350
for ( int i = 1; i <= nc1; i++ ) {
if ( fabs( eigv.at(i + 1) ) < fabs( eigv.at(i) ) ) {
is++;
eigvt = eigv.at(i + 1);
eigv.at(i + 1) = eigv.at(i);
eigv.at(i) = eigvt;
for ( int k = 1; k <= nc; k++ ) {
rt = vec.at(k, i + 1);
vec.at(k, i + 1) = vec.at(k, i);
vec.at(k, i) = rt;
}
}
} // label 360
} while ( is != 0 );
# ifdef DETAILED_REPORT
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: current eigen values of reduced problem \n");
eigv.printYourself();
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: current eigen vectors of reduced problem \n");
vec.printYourself();
# endif
//
// compute eigenvectors
//
for ( int i = 1; i <= nn; i++ ) { // label 375
for ( int j = 1; j <= nc; j++ ) {
tt.at(j) = r.at(i, j);
}
for ( int k = 1; k <= nc; k++ ) {
rt = 0.;
for ( int j = 1; j <= nc; j++ ) {
rt += tt.at(j) * vec.at(j, k);
}
r.at(i, k) = rt;
}
} // label 420 (r = z)
//
// convergency check
//
for ( int i = 1; i <= nc; i++ ) {
double dif = ( eigv.at(i) - d.at(i) );
rtolv.at(i) = fabs( dif / eigv.at(i) );
}
# ifdef DETAILED_REPORT
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: Reached precision of eigenvalues:\n");
rtolv.printYourself();
# endif
for ( int i = 1; i <= nroot; i++ ) {
if ( rtolv.at(i) > rtol ) {
goto label400;
}
}
OOFEM_LOG_INFO("SubspaceIteration :: solveYourselfAt: Convergence reached for RTOL=%20.15f\n", rtol);
break;
label400:
if ( nite >= nitem ) {
OOFEM_WARNING("SubspaceIteration :: solveYourselfAt: Convergence not reached in %d iteration - using current values", nitem);
break;
}
d = eigv; // label 410 and 440
continue;
}
// compute eigenvectors
for ( int j = 1; j <= nc; j++ ) {
tt.beColumnOf(r, j);
a.backSubstitutionWith(tt);
r.setColumn(tt, j); // r = xbar
}
// one cad add a normalization of eigen-vectors here
// initialize original index locations
_r.resize(nn, nroot);
_eigv.resize(nroot);
for ( int i = 1; i <= nroot; i++ ) {
_eigv.at(i) = eigv.at(i);
for ( int j = 1; j <= nn; j++ ) {
_r.at(j, i) = r.at(j, i);
}
}
return NM_Success;
}
NM_Status
SubspaceIteration :: solve(SparseMtrx &a, SparseMtrx &b, FloatArray &_eigv, FloatMatrix &_r, double rtol, int nroot)
//
// this function solve the generalized eigenproblem using the Generalized
// jacobi iteration
//
//
{
FILE *outStream;
FloatArray temp, w, d, tt, rtolv, eigv;
FloatMatrix r;
int nn, nc1, i, j, k, ij = 0, nite, is;
double rt, art, brt, eigvt, dif;
FloatMatrix ar, br, vec;
GJacobi mtd(domain, engngModel);
outStream = domain->giveEngngModel()->giveOutputStream();
nc = min(2 * nroot, nroot + 8);
//
// check matrix size
//
if ( a.giveNumberOfColumns() != b.giveNumberOfColumns() ) {
OOFEM_ERROR("matrices size mismatch");
}
// check matrix for factorization support
if ( !a.canBeFactorized() ) {
OOFEM_ERROR("a matrix not support factorization");
}
//
// check for wery small problem
//
nn = a.giveNumberOfColumns();
if ( nc > nn ) {
nc = nn;
}
ar.resize(nc, nc);
ar.zero();
br.resize(nc, nc);
br.zero();
//
// creation of initial iteration vectors
//
nc1 = nc - 1;
w.resize(nn);
w.zero();
d.resize(nc);
d.zero();
tt.resize(nn);
tt.zero();
rtolv.resize(nc);
rtolv.zero();
vec.resize(nc, nc);
vec.zero(); // eigen vectors of reduced problem
_r.resize(nn, nroot);
_eigv.resize(nroot);
//
// create work arrays
//
r.resize(nn, nc);
r.zero();
eigv.resize(nc);
eigv.zero();
FloatArray h(nn);
for ( i = 1; i <= nn; i++ ) {
h.at(i) = 1.0;
w.at(i) = b.at(i, i) / a.at(i, i);
}
b.times(h, tt);
for ( i = 1; i <= nn; i++ ) {
r.at(i, 1) = tt.at(i);
}
for ( j = 2; j <= nc; j++ ) {
rt = 0.0;
for ( i = 1; i <= nn; i++ ) {
if ( fabs( w.at(i) ) >= rt ) {
rt = fabs( w.at(i) );
ij = i;
}
}
tt.at(j) = ij;
w.at(ij) = 0.;
for ( i = 1; i <= nn; i++ ) {
if ( i == ij ) {
h.at(i) = 1.0;
} else {
h.at(i) = 0.0;
}
}
b.times(h, tt);
for ( i = 1; i <= nn; i++ ) {
r.at(i, j) = tt.at(i);
}
} // (r = z)
# ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Degrees of freedom invoked by initial vectors :\n");
tt.printYourself();
printf("SubspaceIteration :: solveYourselfAt: initial vectors for iteration:\n");
r.printYourself();
# endif
//ish = 0;
a.factorized();
//
// start of iteration loop
//
nite = 0;
do { // label 100
nite++;
# ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Iteration loop no. %d\n", nite);
# endif
//
// compute projection ar and br of matrices a , b
//
for ( j = 1; j <= nc; j++ ) {
for ( k = 1; k <= nn; k++ ) {
tt.at(k) = r.at(k, j);
}
//a. forwardReductionWith(&tt) -> diagonalScalingWith (&tt)
// -> backSubstitutionWithtt) ;
a.backSubstitutionWith(tt);
for ( i = j; i <= nc; i++ ) {
art = 0.;
for ( k = 1; k <= nn; k++ ) {
art += r.at(k, i) * tt.at(k);
}
ar.at(j, i) = art;
}
for ( k = 1; k <= nn; k++ ) {
r.at(k, j) = tt.at(k); // (r = xbar)
}
}
ar.symmetrized(); // label 110
#ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Printing projection matrix ar\n");
ar.printYourself();
#endif
//
for ( j = 1; j <= nc; j++ ) {
for ( k = 1; k <= nn; k++ ) {
tt.at(k) = r.at(k, j);
}
b.times(tt, temp);
for ( i = j; i <= nc; i++ ) {
brt = 0.;
for ( k = 1; k <= nn; k++ ) {
brt += r.at(k, i) * temp.at(k);
}
br.at(j, i) = brt;
} // label 180
for ( k = 1; k <= nn; k++ ) {
r.at(k, j) = temp.at(k); // (r=zbar)
}
} // label 160
br.symmetrized();
#ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Printing projection matrix br\n");
br.printYourself();
#endif
//
// solution of reduced eigenvalue problem
//
mtd.solve(ar, br, eigv, vec);
/// START EXPERIMENTAL
// solve the reduced problem by Inverse iteration
/*
* {
* FloatMatrix x(nc,nc), z(nc,nc), zz(nc,nc), arinv;
* FloatArray w(nc), ww(nc), tt(nc), t(nc);
* double c;
* int ii, i,j,k,ac;
*
*
* // initial setting
* for (i=1;i<=nc;i++){
* ww.at(i)=1.0;
* }
*
* for (i=1;i<=nc;i++)
* for (j=1; j<=nc;j++)
* z.at(i,j)=1.0;
*
* arinv.beInverseOf (ar);
*
* for (i=0;i<nitem;i++) {
*
* // copy zz=z
* zz = z;
*
* // solve matrix equation K.X = M.X
* x.beProductOf (arinv, z);
* // evaluation of Rayleigh quotients
* for (j=1;j<=nc;j++){
* w.at(j) = 0.0;
* for (k = 1; k<= nc; k++) w.at(j) += zz.at(k,j)*x.at(k,j);
* }
*
* z.beProductOf (br, x);
*
* for (j=1;j<=nc;j++){
* c = 0;
* for (k = 1; k<= nc; k++) c+= z.at(k,j)*x.at(k,j);
* w.at(j) /= c;
* }
*
* // check convergence
* ac=0;
* for (j=1;j<=nc;j++){
* if (fabs((ww.at(j)-w.at(j))/w.at(j))< rtol) ac++;
* ww.at(j)=w.at(j);
* }
*
* printf ("\n iterace cislo %d %d",i,ac);
* w.printYourself();
*
* // Gramm-Schmidt ortogonalization
* for (j=1;j<=nc;j++) {
* for (k = 1; k<= nc; k++) tt.at(k) = x.at(k,j) ;
* t.beProductOf(br,tt) ;
* for (ii=1;ii<j;ii++) {
* c = 0.0;
* for (k = 1; k<= nc; k++) c += x.at(k,ii)*t.at(k);
* for (k = 1; k<= nc; k++) x.at(k,j) -= x.at(k,ii)*c;
* }
* for (k = 1; k<= nc; k++) tt.at(k) = x.at(k,j) ;
* t.beProductOf (br,tt) ;
* c = 0.0;
* for (k = 1; k<= nc; k++) c += x.at(k,j)*t.at(k);
* for (k = 1; k<= nc; k++) x.at(k,j) /= sqrt(c);
* }
*
* if (ac>nroot){
* break;
* }
*
* // compute new approximation of Z
* z.beProductOf (br,x);
* }
*
* eigv = w;
* vec = x;
* }
* /// END EXPERIMANTAL
*/
//
// sorting eigenvalues according to their values
//
do {
is = 0; // label 350
for ( i = 1; i <= nc1; i++ ) {
if ( fabs( eigv.at(i + 1) ) < fabs( eigv.at(i) ) ) {
is++;
eigvt = eigv.at(i + 1);
eigv.at(i + 1) = eigv.at(i);
eigv.at(i) = eigvt;
for ( k = 1; k <= nc; k++ ) {
rt = vec.at(k, i + 1);
vec.at(k, i + 1) = vec.at(k, i);
vec.at(k, i) = rt;
}
}
} // label 360
} while ( is != 0 );
# ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: current eigen values of reduced problem \n");
eigv.printYourself();
printf("SubspaceIteration :: solveYourselfAt: current eigen vectors of reduced problem \n");
vec.printYourself();
# endif
//
// compute eigenvectors
//
for ( i = 1; i <= nn; i++ ) { // label 375
for ( j = 1; j <= nc; j++ ) {
tt.at(j) = r.at(i, j);
}
for ( k = 1; k <= nc; k++ ) {
rt = 0.;
for ( j = 1; j <= nc; j++ ) {
rt += tt.at(j) * vec.at(j, k);
}
r.at(i, k) = rt;
}
} // label 420 (r = z)
//
// convergency check
//
for ( i = 1; i <= nc; i++ ) {
dif = ( eigv.at(i) - d.at(i) );
rtolv.at(i) = fabs( dif / eigv.at(i) );
}
# ifdef DETAILED_REPORT
printf("SubspaceIteration :: solveYourselfAt: Reached precision of eigenvalues:\n");
rtolv.printYourself();
# endif
for ( i = 1; i <= nroot; i++ ) {
if ( rtolv.at(i) > rtol ) {
goto label400;
}
}
fprintf(outStream,
"SubspaceIteration :: solveYourselfAt: Convergence reached for RTOL=%20.15f",
rtol);
break;
label400:
if ( nite >= nitem ) {
fprintf(outStream, " SubspaceIteration :: solveYourselfAt: Convergence not reached in %d iteration - using current values", nitem);
break;
}
for ( i = 1; i <= nc; i++ ) {
d.at(i) = eigv.at(i); // label 410 and 440
}
continue;
} while ( 1 );
// compute eigenvectors
for ( j = 1; j <= nc; j++ ) {
for ( k = 1; k <= nn; k++ ) {
tt.at(k) = r.at(k, j);
}
a.backSubstitutionWith(tt);
for ( k = 1; k <= nn; k++ ) {
r.at(k, j) = tt.at(k); // (r = xbar)
}
}
// one cad add a normalization of eigen-vectors here
for ( i = 1; i <= nroot; i++ ) {
_eigv.at(i) = eigv.at(i);
for ( j = 1; j <= nn; j++ ) {
_r.at(j, i) = r.at(j, i);
}
}
solved = 1;
return NM_Success;
}
void
PrescribedMean :: assemble(SparseMtrx &answer, TimeStep *tStep, CharType type,
const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
if ( type != TangentStiffnessMatrix && type != StiffnessMatrix ) {
return;
}
computeDomainSize();
IntArray c_loc, r_loc;
lambdaDman->giveLocationArray(lambdaIDs, r_loc, r_s);
lambdaDman->giveLocationArray(lambdaIDs, c_loc, c_s);
for ( int i=1; i<=elements.giveSize(); i++ ) {
int elementID = elements.at(i);
Element *thisElement = this->giveDomain()->giveElement(elementID);
FEInterpolation *interpolator = thisElement->giveInterpolation(DofIDItem(dofid));
IntegrationRule *iRule = (elementEdges) ? (interpolator->giveBoundaryIntegrationRule(3, sides.at(i))) :
(interpolator->giveIntegrationRule(3));
for ( GaussPoint * gp: * iRule ) {
FloatArray lcoords = gp->giveNaturalCoordinates();
FloatArray N; //, a;
FloatMatrix temp, tempT;
double detJ = 0.0;
IntArray boundaryNodes, dofids= {(DofIDItem) this->dofid}, r_Sideloc, c_Sideloc;
if (elementEdges) {
// Compute boundary integral
interpolator->boundaryGiveNodes( boundaryNodes, sides.at(i) );
interpolator->boundaryEvalN(N, sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->boundaryGiveTransformationJacobian(sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement)) );
// Retrieve locations for dofs on boundary
thisElement->giveBoundaryLocationArray(r_Sideloc, boundaryNodes, dofids, r_s);
thisElement->giveBoundaryLocationArray(c_Sideloc, boundaryNodes, dofids, c_s);
} else {
interpolator->evalN(N, lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->giveTransformationJacobian(lcoords, FEIElementGeometryWrapper(thisElement) ) );
IntArray DofIDStemp, rloc, cloc;
thisElement->giveLocationArray(rloc, r_s, &DofIDStemp);
thisElement->giveLocationArray(cloc, c_s, &DofIDStemp);
r_Sideloc.clear();
c_Sideloc.clear();
for (int j=1; j<=DofIDStemp.giveSize(); j++) {
if (DofIDStemp.at(j)==dofids.at(1)) {
r_Sideloc.followedBy({rloc.at(j)});
c_Sideloc.followedBy({cloc.at(j)});
}
}
}
// delta p part:
temp = N*detJ*gp->giveWeight()*(1.0/domainSize);
tempT.beTranspositionOf(temp);
answer.assemble(r_Sideloc, c_loc, temp);
answer.assemble(r_loc, c_Sideloc, tempT);
}
delete iRule;
}
}
NM_Status
StaggeredSolver :: solve(SparseMtrx &k, FloatArray &R, FloatArray *R0,
FloatArray &Xtotal, FloatArray &dXtotal, FloatArray &F,
const FloatArray &internalForcesEBENorm, double &l, referenceLoadInputModeType rlm,
int &nite, TimeStep *tStep)
{
// residual, iteration increment of solution, total external force
FloatArray RHS, rhs, ddXtotal, RT;
double RRTtotal;
int neq = Xtotal.giveSize();
NM_Status status;
bool converged, errorOutOfRangeFlag;
ParallelContext *parallel_context = engngModel->giveParallelContext( this->domain->giveNumber() );
if ( engngModel->giveProblemScale() == macroScale ) {
OOFEM_LOG_INFO("StaggeredSolver: Iteration");
if ( rtolf.at(1) > 0.0 ) {
OOFEM_LOG_INFO(" ForceError");
}
if ( rtold.at(1) > 0.0 ) {
OOFEM_LOG_INFO(" DisplError");
}
OOFEM_LOG_INFO("\n----------------------------------------------------------------------------\n");
}
l = 1.0;
status = NM_None;
this->giveLinearSolver();
// compute total load R = R+R0
RT = R;
if ( R0 ) {
RT.add(* R0);
}
RRTtotal = parallel_context->localNorm(RT);
RRTtotal *= RRTtotal;
ddXtotal.resize(neq);
ddXtotal.zero();
// Fetch the matrix before evaluating internal forces.
// This is intentional, since its a simple way to drastically increase convergence for nonlinear problems.
// (This old tangent is just used)
// This improves convergence for many nonlinear problems, but not all. It may actually
// cause divergence for some nonlinear problems. Therefore a flag is used to determine if
// the stiffness should be evaluated before the residual (default yes). /ES
//-------------------------------------------------
// Compute external forces
int numDofIdGroups = this->UnknownNumberingSchemeList.size();
FloatArray RRT(numDofIdGroups);
for ( int dG = 0; dG < numDofIdGroups; dG++ ) {
this->fExtList[dG].beSubArrayOf( RT, locArrayList[dG] );
RRT(dG) = this->fExtList[dG].computeSquaredNorm();
}
int nStaggeredIter = 0;
do {
// Staggered iterations
for ( int dG = 0; dG < (int)this->UnknownNumberingSchemeList.size(); dG++ ) {
printf("\nSolving for dof group %d \n", dG+1);
engngModel->updateComponent(tStep, NonLinearLhs, domain);
this->stiffnessMatrixList[dG] = k.giveSubMatrix( locArrayList[dG], locArrayList[dG]);
if ( this->prescribedDofsFlag ) {
if ( !prescribedEqsInitFlag ) {
this->initPrescribedEqs();
}
applyConstraintsToStiffness(k);
}
nite = 0;
do {
// Compute the residual
engngModel->updateComponent(tStep, InternalRhs, domain);
RHS.beDifferenceOf(RT, F);
this->fIntList[dG].beSubArrayOf( F, locArrayList[dG] );
rhs.beDifferenceOf(this->fExtList[dG], this->fIntList[dG]);
RHS.zero();
RHS.assemble(rhs, locArrayList[dG]);
if ( this->prescribedDofsFlag ) {
this->applyConstraintsToLoadIncrement(nite, k, rhs, rlm, tStep);
}
// convergence check
IntArray &idArray = UnknownNumberingSchemeList[dG].dofIdArray;
converged = this->checkConvergenceDofIdArray(RT, F, RHS, ddXtotal, Xtotal, RRTtotal, internalForcesEBENorm, nite, errorOutOfRangeFlag, tStep, idArray);
if ( errorOutOfRangeFlag ) {
status = NM_NoSuccess;
OOFEM_WARNING("Divergence reached after %d iterations", nite);
break;
} else if ( converged && ( nite >= minIterations ) ) {
break;
} else if ( nite >= nsmax ) {
OOFEM_LOG_DEBUG("Maximum number of iterations reached\n");
break;
}
if ( nite > 0 || !mCalcStiffBeforeRes ) {
if ( ( NR_Mode == nrsolverFullNRM ) || ( ( NR_Mode == nrsolverAccelNRM ) && ( nite % MANRMSteps == 0 ) ) ) {
engngModel->updateComponent(tStep, NonLinearLhs, domain);
this->stiffnessMatrixList[dG] = k.giveSubMatrix( locArrayList[dG], locArrayList[dG]);
applyConstraintsToStiffness(*this->stiffnessMatrixList[dG]);
}
}
if ( ( nite == 0 ) && ( deltaL < 1.0 ) ) { // deltaL < 1 means no increment applied, only equilibrate current state
rhs.zero();
R.zero();
ddX[dG] = rhs;
} else {
status = linSolver->solve(*this->stiffnessMatrixList[dG], rhs, ddX[dG]);
}
//
// update solution
//
if ( this->lsFlag && ( nite > 0 ) ) { // Why not nite == 0 ?
// line search
LineSearchNM :: LS_status LSstatus;
double eta;
this->giveLineSearchSolver()->solve( X[dG], ddX[dG], fIntList[dG], fExtList[dG], R0, prescribedEqs, 1.0, eta, LSstatus, tStep);
} else if ( this->constrainedNRFlag && ( nite > this->constrainedNRminiter ) ) {
if ( this->forceErrVec.computeSquaredNorm() > this->forceErrVecOld.computeSquaredNorm() ) {
printf("Constraining increment to be %e times full increment...\n", this->constrainedNRalpha);
ddX[dG].times(this->constrainedNRalpha);
}
}
X[dG].add(ddX[dG]);
dX[dG].add(ddX[dG]);
// Update total solution (containing all dofs)
Xtotal.assemble(ddX[dG], locArrayList[dG]);
dXtotal.assemble(ddX[dG], locArrayList[dG]);
ddXtotal.zero();
ddXtotal.assemble(ddX[dG], locArrayList[dG]);
tStep->incrementStateCounter(); // update solution state counter
tStep->incrementSubStepNumber();
nite++; // iteration increment
engngModel->giveExportModuleManager()->doOutput(tStep, true);
} while ( true ); // end of iteration
}
printf("\nStaggered iteration (all dof id's) \n");
// Check convergence of total system
RHS.beDifferenceOf(RT, F);
converged = this->checkConvergence(RT, F, RHS, ddXtotal, Xtotal, RRTtotal, internalForcesEBENorm, nStaggeredIter, errorOutOfRangeFlag);
if ( converged && ( nStaggeredIter >= minIterations ) ) {
break;
}
nStaggeredIter++;
} while ( true ); // end of iteration
status |= NM_Success;
solved = 1;
// Modify Load vector to include "quasi reaction"
if ( R0 ) {
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
R.at( prescribedEqs.at(i) ) = F.at( prescribedEqs.at(i) ) - R0->at( prescribedEqs.at(i) ) - R.at( prescribedEqs.at(i) );
}
} else {
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
R.at( prescribedEqs.at(i) ) = F.at( prescribedEqs.at(i) ) - R.at( prescribedEqs.at(i) );
}
}
this->lastReactions.resize(numberOfPrescribedDofs);
#ifdef VERBOSE
if ( numberOfPrescribedDofs ) {
// print quasi reactions if direct displacement control used
OOFEM_LOG_INFO("\n");
OOFEM_LOG_INFO("StaggeredSolver: Quasi reaction table \n");
OOFEM_LOG_INFO("StaggeredSolver: Node Dof Displacement Force\n");
double reaction;
for ( int i = 1; i <= numberOfPrescribedDofs; i++ ) {
reaction = R->at( prescribedEqs.at(i) );
if ( R0 ) {
reaction += R0->at( prescribedEqs.at(i) );
}
lastReactions.at(i) = reaction;
OOFEM_LOG_INFO("StaggeredSolver: %-15d %-15d %-+15.5e %-+15.5e\n", prescribedDofs.at(2 * i - 1), prescribedDofs.at(2 * i),
X.at( prescribedEqs.at(i) ), reaction);
}
OOFEM_LOG_INFO("\n");
}
#endif
return status;
}
NM_Status
SLEPcSolver :: solve(SparseMtrx &a, SparseMtrx &b, FloatArray &_eigv, FloatMatrix &_r, double rtol, int nroot)
{
FILE *outStream;
PetscErrorCode ierr;
int size;
ST st;
outStream = domain->giveEngngModel()->giveOutputStream();
// first check whether Lhs is defined
if ( a->giveNumberOfRows() != a->giveNumberOfColumns() ||
b->giveNumberOfRows() != b->giveNumberOfRows() ||
a->giveNumberOfColumns() != b->giveNumberOfColumns() ) {
OOFEM_ERROR("matrices size mismatch");
}
A = dynamic_cast< PetscSparseMtrx * >(&a);
B = dynamic_cast< PetscSparseMtrx * >(&b);
if ( !A || !B ) {
OOFEM_ERROR("PetscSparseMtrx Expected");
}
size = engngModel->giveParallelContext( A->giveDomainIndex() )->giveNumberOfNaturalEqs(); // A->giveLeqs();
_r.resize(size, nroot);
_eigv.resize(nroot);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Create the eigensolver and set various options
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
int nconv, nite;
EPSConvergedReason reason;
#ifdef TIME_REPORT
Timer timer;
timer.startTimer();
#endif
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);
CHKERRQ(ierr);
epsInit = true;
}
/*
* Set operators. In this case, it is a generalized eigenvalue problem
*/
ierr = EPSSetOperators( eps, * A->giveMtrx(), * B->giveMtrx() );
CHKERRQ(ierr);
ierr = EPSSetProblemType(eps, EPS_GHEP);
CHKERRQ(ierr);
ierr = EPSGetST(eps, & st);
CHKERRQ(ierr);
ierr = STSetType(st, STSINVERT);
CHKERRQ(ierr);
ierr = STSetMatStructure(st, SAME_NONZERO_PATTERN);
CHKERRQ(ierr);
ierr = EPSSetTolerances(eps, ( PetscReal ) rtol, PETSC_DECIDE);
CHKERRQ(ierr);
ierr = EPSSetDimensions(eps, ( PetscInt ) nroot, PETSC_DECIDE, PETSC_DECIDE);
CHKERRQ(ierr);
ierr = EPSSetWhichEigenpairs(eps, EPS_SMALLEST_MAGNITUDE);
CHKERRQ(ierr);
/*
* Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps);
CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Solve the eigensystem
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSolve(eps);
CHKERRQ(ierr);
ierr = EPSGetConvergedReason(eps, & reason);
CHKERRQ(ierr);
ierr = EPSGetIterationNumber(eps, & nite);
CHKERRQ(ierr);
OOFEM_LOG_INFO("SLEPcSolver::solve EPSConvergedReason: %d, number of iterations: %d\n", reason, nite);
ierr = EPSGetConverged(eps, & nconv);
CHKERRQ(ierr);
if ( nconv > 0 ) {
fprintf(outStream, "SLEPcSolver :: solveYourselfAt: Convergence reached for RTOL=%20.15f", rtol);
PetscScalar kr;
Vec Vr;
ierr = MatGetVecs(* B->giveMtrx(), PETSC_NULL, & Vr);
CHKERRQ(ierr);
FloatArray Vr_loc;
for ( int i = 0; i < nconv && i < nroot; i++ ) {
ierr = EPSGetEigenpair(eps, nconv - i - 1, & kr, PETSC_NULL, Vr, PETSC_NULL);
CHKERRQ(ierr);
//Store the eigenvalue
_eigv->at(i + 1) = kr;
//Store the eigenvector
A->scatterG2L(Vr, Vr_loc);
for ( int j = 0; j < size; j++ ) {
_r->at(j + 1, i + 1) = Vr_loc.at(j + 1);
}
}
ierr = VecDestroy(Vr);
CHKERRQ(ierr);
} else {
OOFEM_ERROR("No converged eigenpairs");
}
#ifdef TIME_REPORT
timer.stopTimer();
OOFEM_LOG_INFO( "SLEPcSolver info: user time consumed by solution: %.2fs\n", timer.getUtime() );
#endif
return NM_Success;
}
NM_Status
InverseIteration :: solve(SparseMtrx &a, SparseMtrx &b, FloatArray &_eigv, FloatMatrix &_r, double rtol, int nroot)
{
FILE *outStream;
if ( a.giveNumberOfColumns() != b.giveNumberOfColumns() ) {
OOFEM_ERROR("matrices size mismatch");
}
SparseLinearSystemNM *solver = GiveClassFactory().createSparseLinSolver(ST_Direct, domain, engngModel);
int nn = a.giveNumberOfColumns();
int nc = min(2 * nroot, nroot + 8);
nc = min(nc, nn);
//// control of diagonal zeroes in mass matrix, to be avoided
//int i;
//for (i = 1; i <= nn; i++) {
// if (b.at(i, i) == 0) {
// b.at(i, i) = 1.0e-12;
// }
//}
FloatArray w(nc), ww(nc), t;
std :: vector< FloatArray > z(nc, nn), zz(nc, nn), x(nc, nn);
outStream = domain->giveEngngModel()->giveOutputStream();
/* initial setting */
#if 0
ww.add(1.0);
for ( int j = 0; j < nc; j++ ) {
z[j].add(1.0);
}
#else
{
FloatArray ad(nn), bd(nn);
for (int i = 1; i <= nn; i++) {
ad.at(i) = fabs(a.at(i, i));
bd.at(i) = fabs(b.at(i, i));
}
IntArray order;
order.enumerate(nn);
std::sort(order.begin(), order.end(), [&ad, &bd](int a, int b) { return bd.at(a) * ad.at(b) > bd.at(b) * ad.at(a); });
for (int i = 0; i < nc; i++) {
x[i].at(order[i]) = 1.0;
b.times(x[i], z[i]);
ww.at(i + 1) = z[i].dotProduct(x[i]);
}
}
#endif
int it;
for ( it = 0; it < nitem; it++ ) {
/* copy zz=z */
for ( int j = 0; j < nc; j++ ) {
zz[j] = z[j];
}
/* solve matrix equation K.X = M.X */
for ( int j = 0; j < nc; j++ ) {
solver->solve(a, z[j], x[j]);
}
/* evaluation of Rayleigh quotients */
for ( int j = 0; j < nc; j++ ) {
w.at(j + 1) = zz[j].dotProduct(x[j]);
}
for ( int j = 0; j < nc; j++ ) {
b.times(x[j], z[j]);
}
for ( int j = 0; j < nc; j++ ) {
w.at(j + 1) /= z[j].dotProduct(x[j]);
}
/* check convergence */
int ac = 0;
for ( int j = 1; j <= nc; j++ ) {
if ( fabs( ww.at(j) - w.at(j) ) <= fabs( w.at(j) * rtol ) ) {
ac++;
}
ww.at(j) = w.at(j);
}
//printf ("\n iteration %d %d",it,ac);
//w.printYourself();
/* Gramm-Schmidt ortogonalization */
for ( int j = 0; j < nc; j++ ) {
if ( j != 0 ) {
b.times(x[j], t);
}
for ( int ii = 0; ii < j; ii++ ) {
x[j].add( -x[ii].dotProduct(t), x[ii] );
}
b.times(x[j], t);
x[j].times( 1.0 / sqrt( x[j].dotProduct(t) ) );
}
if ( ac > nroot ) {
break;
}
/* compute new approximation of Z */
for ( int j = 0; j < nc; j++ ) {
b.times(x[j], z[j]);
}
}
// copy results
IntArray order;
order.enumerate(w.giveSize());
std :: sort(order.begin(), order.end(), [&w](int a, int b) { return w.at(a) < w.at(b); });
_eigv.resize(nroot);
_r.resize(nn, nroot);
for ( int i = 1; i <= nroot; i++ ) {
_eigv.at(i) = w.at(order.at(i));
_r.setColumn(x[order.at(i) - 1], i);
}
if ( it < nitem ) {
fprintf(outStream, "InverseIteration :: convergence reached in %d iterations\n", it);
} else {
fprintf(outStream, "InverseIteration :: convergence not reached after %d iterations\n", it);
}
return NM_Success;
}
void PrescribedGradientBCWeak :: assembleGPContrib(SparseMtrx &answer, TimeStep *tStep,
CharType type, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s, TracSegArray &iEl, GaussPoint &iGP)
{
SpatialLocalizer *localizer = domain->giveSpatialLocalizer();
///////////////
// Gamma_plus
FloatMatrix contrib;
assembleTangentGPContributionNew(contrib, iEl, iGP, -1.0, iGP.giveGlobalCoordinates());
// Compute vector of traction unknowns
FloatArray tracUnknowns;
iEl.mFirstNode->giveUnknownVector(tracUnknowns, giveTracDofIDs(), VM_Total, tStep);
IntArray trac_rows;
iEl.giveTractionLocationArray(trac_rows, type, r_s);
FloatArray dispElLocCoord, closestPoint;
Element *dispEl = localizer->giveElementClosestToPoint(dispElLocCoord, closestPoint, iGP.giveGlobalCoordinates() );
IntArray disp_cols;
dispEl->giveLocationArray(disp_cols, c_s);
answer.assemble(trac_rows, disp_cols, contrib);
FloatMatrix contribT;
contribT.beTranspositionOf(contrib);
answer.assemble(disp_cols, trac_rows, contribT);
///////////////
// Gamma_minus
contrib.clear();
FloatArray xMinus;
this->giveMirroredPointOnGammaMinus(xMinus, iGP.giveGlobalCoordinates() );
assembleTangentGPContributionNew(contrib, iEl, iGP, 1.0, xMinus);
// Compute vector of traction unknowns
tracUnknowns.clear();
iEl.mFirstNode->giveUnknownVector(tracUnknowns, giveTracDofIDs(), VM_Total, tStep);
trac_rows.clear();
iEl.giveTractionLocationArray(trac_rows, type, r_s);
dispElLocCoord.clear(); closestPoint.clear();
dispEl = localizer->giveElementClosestToPoint(dispElLocCoord, closestPoint, xMinus );
disp_cols.clear();
dispEl->giveLocationArray(disp_cols, c_s);
answer.assemble(trac_rows, disp_cols, contrib);
contribT.clear();
contribT.beTranspositionOf(contrib);
answer.assemble(disp_cols, trac_rows, contribT);
// Assemble zeros on diagonal (required by PETSc solver)
FloatMatrix KZero(1,1);
KZero.zero();
for( int i : trac_rows) {
answer.assemble(IntArray({i}), IntArray({i}), KZero);
}
}
