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);
std :: unique_ptr< SparseMtrx > K;
std :: unique_ptr< SparseLinearSystemNM > solver;
solver.reset( classFactory.createSparseLinSolver(ST_Petsc, & iOldDom, engngMod) );
if (!solver) {
solver.reset( classFactory.createSparseLinSolver(ST_Direct, & iOldDom, engngMod) );
}
K.reset( classFactory.createSparseMtrx(solver->giveRecommendedMatrix(true)) );
K->buildInternalStructure( engngMod, iNewDom.giveNumber(), 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++ ) {
for ( GaussPoint *gp: *elNew->giveIntegrationRule(intRuleInd) ) {
// New N-matrix
FloatMatrix NNew;
elNew->computeNmatrixAt(gp->giveNaturalCoordinates(), NNew);
//////////////
// Global coordinates of GP
const FloatArray &localCoord = gp->giveNaturalCoordinates();
FloatArray globalCoord;
elNew->computeGlobalCoordinates(globalCoord, localCoord);
//////////////
// 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 elNode: elNew->giveDofManArray() ) {
// DofManager *dMan = iNewDom.giveNode(elNode);
DofManager *dMan = iNewDom.giveDofManager(elNode);
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;
if(dof->giveEqn() > 0) {
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 {
// TODO: Why does this case occur?
nodeDispOld.push_back(0.0);
}
} 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++;
}
}
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);
}
}
