void
assembleMatrix ( MatrixEpetra<Real>& globalMatrix,
MatrixElemental& localMatrix,
const CurrentFE& currentFE,
const DofType& dof,
Int iblock,
Int jblock,
Int iOffset,
Int jOffset)
{
return assembleMatrix ( globalMatrix, localMatrix, currentFE, currentFE, dof, dof,
iblock, jblock, iOffset, jOffset);
}
void
assembleMatrix ( MatrixEpetra<Real>& globalMatrix,
UInt const& elementID1,
UInt const& elementID2,
LocalMatrixType& localMatrix,
const CurrentFE& currentFE1,
const CurrentFE& currentFE2,
const DofType1& dof1,
const DofType2& dof2,
Int iOffset,
Int jOffset)
{
assembleMatrix (globalMatrix, elementID1, elementID2, localMatrix, currentFE1.nbFEDof(), currentFE2.nbFEDof(),
dof1, dof2, iOffset, jOffset);
}
void
ADRAssembler< mesh_type, matrix_type, vector_type>::
addDiffusion (matrix_ptrType matrix, const Real& coefficient, const UInt& offsetLeft, const UInt& offsetUp)
{
// Check that the fespace is set
ASSERT (M_fespace != 0, "No FE space for assembling the diffusion!");
M_diffusionAssemblyChrono.start();
// Some constants
const UInt nbElements (M_fespace->mesh()->numElements() );
const UInt fieldDim (M_fespace->fieldDim() );
const UInt nbTotalDof (M_fespace->dof().numTotalDof() );
// Loop over the elements
for (UInt iterElement (0); iterElement < nbElements; ++iterElement)
{
// Update the diffusion current FE
M_diffCFE->update ( M_fespace->mesh()->element (iterElement), UPDATE_DPHI | UPDATE_WDET );
// Clean the local matrix
M_localDiff->zero();
// local stiffness
AssemblyElemental::stiffness (*M_localDiff, *M_diffCFE, coefficient, fieldDim);
// Assembly
for (UInt iFieldDim (0); iFieldDim < fieldDim; ++iFieldDim)
{
assembleMatrix ( *matrix,
*M_localDiff,
*M_diffCFE,
*M_diffCFE,
M_fespace->dof(),
M_fespace->dof(),
iFieldDim, iFieldDim,
iFieldDim * nbTotalDof + offsetLeft, iFieldDim * nbTotalDof + offsetUp );
}
}
M_diffusionAssemblyChrono.stop();
}
void
assembleMatrix ( MatrixEpetra<Real>& globalMatrix,
MatrixElemental& localMatrix,
const CurrentFE& currentFE1,
const CurrentFE& currentFE2,
const DofType1& dof1,
const DofType2& dof2,
Int iblock,
Int jblock,
Int iOffset,
Int jOffset )
{
MatrixElemental::matrix_view localView = localMatrix.block ( iblock, jblock );
UInt elementID1 = currentFE1.currentLocalId();
UInt elementID2 = currentFE2.currentLocalId();
assembleMatrix ( globalMatrix, elementID1, elementID2, localView,
currentFE1, currentFE2, dof1, dof2, iOffset, jOffset );
return;
}
void
assembleMatrix ( MatrixEpetra<Real>& globalMatrix,
const UInt& elementID,
MatrixElemental& localMatrix,
const UInt& feNbDof,
const DofType& dof,
Int iblock,
Int jblock,
Int iOffset,
Int jOffset)
{
MatrixElemental::matrix_view localView = localMatrix.block ( iblock, jblock );
assembleMatrix ( globalMatrix,
elementID,
elementID,
localView,
feNbDof,
feNbDof,
dof,
dof, iOffset, jOffset);
}
void
ADRAssembler< mesh_type, matrix_type, vector_type>::
addAdvection (matrix_ptrType matrix, const vector_type& beta, const UInt& offsetLeft, const UInt& offsetUp)
{
// Beta has to be repeated!
if (beta.mapType() == Unique)
{
addAdvection (matrix, vector_type (beta, Repeated), offsetLeft, offsetUp);
return;
}
// Check that the fespace is set
ASSERT (M_fespace != 0, "No FE space for assembling the advection!");
ASSERT (M_betaFESpace != 0, "No FE space (beta) for assembling the advection!");
M_advectionAssemblyChrono.start();
// Some constants
const UInt nbElements (M_fespace->mesh()->numElements() );
const UInt fieldDim (M_fespace->fieldDim() );
const UInt betaFieldDim (M_betaFESpace->fieldDim() );
const UInt nbTotalDof (M_fespace->dof().numTotalDof() );
const UInt nbQuadPt (M_advCFE->nbQuadPt() );
// Temporaries
//Real localValue(0);
std::vector< std::vector< Real > > localBetaValue (nbQuadPt, std::vector<Real> ( betaFieldDim, 0.0 ) );
// Loop over the elements
for (UInt iterElement (0); iterElement < nbElements; ++iterElement)
{
// Update the advection current FEs
M_advCFE->update ( M_fespace->mesh()->element (iterElement), UPDATE_PHI | UPDATE_DPHI | UPDATE_WDET );
M_advBetaCFE->update (M_fespace->mesh()->element (iterElement), UPDATE_PHI );
// Clean the local matrix
M_localAdv->zero();
// Interpolate beta in the quadrature points
AssemblyElemental::interpolate (localBetaValue, *M_advBetaCFE, betaFieldDim, M_betaFESpace->dof(), iterElement, beta);
// Assemble the advection
AssemblyElemental::advection (*M_localAdv, *M_advCFE, 1.0, localBetaValue, fieldDim);
// Assembly
for (UInt iFieldDim (0); iFieldDim < fieldDim; ++iFieldDim)
{
assembleMatrix ( *matrix,
*M_localAdv,
*M_advCFE,
*M_advCFE,
M_fespace->dof(),
M_fespace->dof(),
iFieldDim, iFieldDim,
iFieldDim * nbTotalDof + offsetLeft, iFieldDim * nbTotalDof + offsetUp );
}
}
M_advectionAssemblyChrono.stop();
}
void NeoHookeanMaterialNonLinear<Mesh>::updateNonLinearJacobianTerms ( matrixPtr_Type& jacobian,
const vector_Type& disp,
const dataPtr_Type& dataMaterial,
const mapMarkerVolumesPtr_Type mapsMarkerVolumes,
const displayerPtr_Type& displayer )
{
displayer->leaderPrint (" Non-Linear S- updating non linear terms in the Jacobian Matrix (Neo-Hookean)");
UInt totalDof = this->M_FESpace->dof().numTotalDof();
VectorElemental dk_loc (this->M_FESpace->fe().nbFEDof(), nDimensions);
vector_Type dRep (disp, Repeated);
//! Number of displacement components
UInt nc = nDimensions;
//! Nonlinear part of jacobian
//! loop on volumes: assembling source term
mapIterator_Type it;
for ( it = (*mapsMarkerVolumes).begin(); it != (*mapsMarkerVolumes).end(); it++ )
{
//Given the marker pointed by the iterator, let's extract the material parameters
UInt marker = it->first;
Real mu = dataMaterial->mu (marker);
Real bulk = dataMaterial->bulk (marker);
for ( UInt j (0); j < it->second.size(); j++ )
{
this->M_FESpace->fe().updateFirstDerivQuadPt ( * (it->second[j]) );
UInt eleID = this->M_FESpace->fe().currentLocalId();
for ( UInt iNode = 0; iNode < ( UInt ) this->M_FESpace->fe().nbFEDof(); iNode++ )
{
UInt iloc = this->M_FESpace->fe().patternFirst ( iNode );
for ( UInt iComp = 0; iComp < nDimensions; ++iComp )
{
UInt ig = this->M_FESpace->dof().localToGlobalMap ( eleID, iloc ) + iComp * this->M_FESpace->dim() + this->M_offset;
dk_loc[iloc + iComp * this->M_FESpace->fe().nbFEDof()] = dRep[ig];
}
}
this->M_elmatK->zero();
//! Computes F, Cof(F), J = det(F), Tr(C)
computeKinematicsVariables ( dk_loc );
//! Stiffness for non-linear terms of the Neo-Hookean model
/*!
The results of the integrals are stored at each step into elmatK, until to build K matrix of the bilinear form
*/
//! VOLUMETRIC PART
//! 1. Stiffness matrix: int { 1/2 * bulk * ( 2 - 1/J + 1/J^2 ) * ( CofF : \nabla \delta ) (CofF : \nabla v) }
AssemblyElementalStructure::stiff_Jac_Pvol_1term ( 0.5 * bulk, (*M_CofFk), (*M_Jack),
*this->M_elmatK, this->M_FESpace->fe() );
//! 2. Stiffness matrix: int { 1/2 * bulk * ( 1/J- 1 - log(J)/J^2 ) * ( CofF [\nabla \delta]^t CofF ) : \nabla v }
AssemblyElementalStructure::stiff_Jac_Pvol_2term ( 0.5 * bulk, (*M_CofFk), (*M_Jack),
*this->M_elmatK, this->M_FESpace->fe() );
//! ISOCHORIC PART
//! 1. Stiffness matrix : int { -2/3 * mu * J^(-5/3) *( CofF : \nabla \delta ) ( F : \nabla \v ) }
AssemblyElementalStructure::stiff_Jac_P1iso_NH_1term ( (-2.0 / 3.0) * mu, (*M_CofFk), (*M_Fk), (*M_Jack),
*this->M_elmatK, this->M_FESpace->fe() );
//! 2. Stiffness matrix : int { 2/9 * mu * ( Ic_iso / J^2 )( CofF : \nabla \delta ) ( CofF : \nabla \v ) }
AssemblyElementalStructure::stiff_Jac_P1iso_NH_2term ( (2.0 / 9.0) * mu, (*M_CofFk), (*M_Jack), (*M_trCisok),
*this->M_elmatK, this->M_FESpace->fe() );
//! 3. Stiffness matrix : int { mu * J^(-2/3) (\nabla \delta : \nabla \v)}
AssemblyElementalStructure::stiff_Jac_P1iso_NH_3term ( mu, (*M_Jack), *this->M_elmatK, this->M_FESpace->fe() );
//! 4. Stiffness matrix : int { -2/3 * mu * J^(-5/3) ( F : \nabla \delta ) ( CofF : \nabla \v ) }
AssemblyElementalStructure::stiff_Jac_P1iso_NH_4term ( (-2.0 / 3.0) * mu, (*M_CofFk), (*M_Fk), (*M_Jack),
*this->M_elmatK, this->M_FESpace->fe() );
//! 5. Stiffness matrix : int { 1/3 * mu * J^(-2) * Ic_iso * (CofF [\nabla \delta]^t CofF ) : \nabla \v }
AssemblyElementalStructure::stiff_Jac_P1iso_NH_5term ( (1.0 / 3.0) * mu, (*M_CofFk), (*M_Jack), (*M_trCisok),
*this->M_elmatK, this->M_FESpace->fe() );
//! assembling
for ( UInt ic = 0; ic < nc; ++ic )
{
for ( UInt jc = 0; jc < nc; jc++ )
{
assembleMatrix ( *jacobian,
*this->M_elmatK,
this->M_FESpace->fe(),
this->M_FESpace->dof(),
ic, jc,
this->M_offset + ic * totalDof, this->M_offset + jc * totalDof );
}
}
}
}
}
void VenantKirchhoffMaterialLinear<Mesh>::computeLinearStiff(dataPtr_Type& dataMaterial,
const mapMarkerVolumesPtr_Type mapsMarkerVolumes)
{
// std::cout<<"compute LinearStiff Matrix start\n";
UInt totalDof = this->M_FESpace->dof().numTotalDof();
// Number of displacement components
UInt nc = nDimensions;
//Compute the linear part of the Stiffness Matrix.
//In the case of Linear Material it is the Stiffness Matrix.
//In the case of NonLinear Materials it must be added of the non linear part.
mapIterator_Type it;
for( it = (*mapsMarkerVolumes).begin(); it != (*mapsMarkerVolumes).end(); it++ )
{
//Given the marker pointed by the iterator, let's extract the material parameters
UInt marker = it->first;
Real mu = dataMaterial->mu(marker);
Real lambda = dataMaterial->lambda(marker);
//Given the parameters I loop over the volumes with that marker
for ( UInt j(0); j < it->second.size(); j++ )
{
this->M_FESpace->fe().updateFirstDerivQuadPt( *(it->second[j]) );
this->M_elmatK->zero();
//These methods are implemented in AssemblyElemental.cpp
//They have been kept in AssemblyElemental in order to avoid repetitions
stiff_strain( 2*mu, *this->M_elmatK, this->M_FESpace->fe() );// here in the previous version was 1. (instead of 2.)
stiff_div ( lambda, *this->M_elmatK, this->M_FESpace->fe() );// here in the previous version was 0.5 (instead of 1.)
//this->M_elmatK->showMe();
// assembling
for ( UInt ic = 0; ic < nc; ic++ )
{
for ( UInt jc = 0; jc < nc; jc++ )
{
assembleMatrix( *this->M_linearStiff,
*this->M_elmatK,
this->M_FESpace->fe(),
this->M_FESpace->fe(),
this->M_FESpace->dof(),
this->M_FESpace->dof(),
ic, jc,
this->M_offset +ic*totalDof, this->M_offset + jc*totalDof );
}
}
}
}
this->M_linearStiff->globalAssemble();
//Initialization of the pointer M_stiff to what is pointed by M_linearStiff
this->M_stiff = this->M_linearStiff;
// std::cout<<"compute LinearStiff Matrix end\n";
this->M_jacobian = this->M_linearStiff;
}
