void
LIBeam2dNL :: computeInitialStressMatrix(FloatMatrix &answer, TimeStep *tStep)
{
int i, j, n;
double dV;
GaussPoint *gp;
IntegrationRule *iRule;
FloatArray stress;
FloatMatrix A;
Material *mat = this->giveMaterial();
answer.resize(6, 6);
answer.zero();
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
answer.add(A);
}
}
}
}
}
void Tr1Darcy :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *atTime)
{
/*
* Return Ke = integrate(B^T K B)
*/
FloatMatrix B, BT, K, KB;
FloatArray *lcoords;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
answer.resize(3, 3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
mat->giveCharacteristicMatrix(K, FullForm, TangentStiffness, gp, atTime);
B.beTranspositionOf(BT);
KB.beProductOf(K, B);
answer.plusProductUnsym(B, KB, detJ * gp->giveWeight() ); // Symmetric part is just a single value, not worth it.
}
}
void Tr1Darcy :: computeInternalForcesVector(FloatArray &answer, TimeStep *atTime)
{
FloatArray *lcoords, w, a, gradP, I;
FloatMatrix BT;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
this->computeVectorOf(EID_ConservationEquation, VM_Total, atTime, a);
answer.resize(3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
gradP.beTProductOf(BT, a);
mat->giveFluxVector(w, gp, gradP, atTime);
I.beProductOf(BT, w);
answer.add(- gp->giveWeight() * detJ, I);
}
}
void Tr21Stokes :: giveIntegratedVelocity(FloatMatrix &answer, TimeStep *tStep )
{
/*
* Integrate velocity over element
*/
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FloatMatrix v, v_gamma, ThisAnswer, boundaryV, Nmatrix;
double detJ;
FloatArray *lcoords, N;
int i, j, k=0;
Dof *d;
GaussPoint *gp;
v.resize(12,1);
v.zero();
boundaryV.resize(2,1);
for (i=1; i<=this->giveNumberOfDofManagers(); i++) {
for (j=1; j<=this->giveDofManager(i)->giveNumberOfDofs(); j++) {
d = this->giveDofManager(i)->giveDof(j);
if ((d->giveDofID()==V_u) || (d->giveDofID()==V_v)) {
k=k+1;
v.at(k,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
/*} else if (d->giveDofID()==A_x) {
boundaryV.at(1,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else if (d->giveDofID()==A_y) {
boundaryV.at(2,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);*/
}
}
}
answer.resize(2,1);
answer.zero();
Nmatrix.resize(2,12);
for (i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(detJ*gp->giveWeight());
for (j=1; j<=6;j++) {
Nmatrix.at(1,j*2-1)=N.at(j);
Nmatrix.at(2,j*2)=N.at(j);
}
ThisAnswer.beProductOf(Nmatrix,v);
answer.add(ThisAnswer);
}
}
void Tr21Stokes :: computeBodyLoadVectorAt(FloatArray &answer, Load *load, TimeStep *tStep)
{
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatArray N, gVector, *lcoords, temparray(15);
double dA, detJ, rho;
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
if ( gVector.giveSize() ) {
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
lcoords = gp->giveCoordinates();
rho = this->giveMaterial()->giveCharacteristicValue(MRM_Density, gp, tStep);
detJ = fabs( this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)) );
dA = detJ * gp->giveWeight();
this->interpolation_quad.evalN(N, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0; j < 6; j++ ) {
temparray(2 * j) += N(j) * rho * gVector(0) * dA;
temparray(2 * j + 1) += N(j) * rho * gVector(1) * dA;
}
}
}
answer.resize(15);
answer.zero();
answer.assemble( temparray, this->ordering );
}
void InterfaceElem1d :: drawScalar(oofegGraphicContext &context)
{
int i, indx, result = 0;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
TimeStep *tStep = this->giveDomain()->giveEngngModel()->giveCurrentStep();
FloatArray gcoord(3), v1;
WCRec p [ 1 ];
IntArray map;
GraphicObj *go;
double val [ 1 ];
if ( !context.testElementGraphicActivity(this) ) {
return;
}
if ( context.getInternalVarsDefGeoFlag() ) {
double defScale = context.getDefScale();
p [ 0 ].x = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) );
p [ 0 ].y = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) );
p [ 0 ].z = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) );
} else {
p [ 0 ].x = ( FPNum )( this->giveNode(1)->giveCoordinate(1) );
p [ 0 ].y = ( FPNum )( this->giveNode(1)->giveCoordinate(2) );
p [ 0 ].z = ( FPNum )( this->giveNode(1)->giveCoordinate(3) );
}
result += giveIPValue(v1, iRule->getIntegrationPoint(0), context.giveIntVarType(), tStep);
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
result = 0;
gp = iRule->getIntegrationPoint(i);
result += giveIPValue(v1, gp, context.giveIntVarType(), tStep);
result += this->giveIntVarCompFullIndx( map, context.giveIntVarType() );
if ( result != 2 ) {
continue;
}
if ( ( indx = map.at( context.giveIntVarIndx() ) ) == 0 ) {
return;
}
val [ 0 ] = v1.at(indx);
context.updateFringeTableMinMax(val, 1);
EASValsSetLayer(OOFEG_VARPLOT_PATTERN_LAYER);
EASValsSetMType(FILLED_CIRCLE_MARKER);
go = CreateMarkerWD3D(p, val [ 0 ]);
EGWithMaskChangeAttributes(LAYER_MASK | FILL_MASK | MTYPE_MASK, go);
EMAddGraphicsToModel(ESIModel(), go);
//}
}
}
void Line2SurfaceTension :: computeLoadVector(FloatArray &answer, ValueModeType mode, TimeStep *tStep)
{
///@todo Support axisymm.
//domainType dt = this->giveDomain()->giveDomainType();
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
double t = 1, gamma_s;
///@todo Should i use this? Not used in FM module (but perhaps it should?) / Mikael.
//t = this->giveDomain()->giveCrossSection(1)->give(CS_Thickness);
gamma_s = this->giveMaterial()->give('g', NULL);
FloatMatrix xy(2, 3);
Node *node;
for ( int i = 1; i <= 3; i++ ) {
node = giveNode(i);
xy.at(1, i) = node->giveCoordinate(1);
xy.at(2, i) = node->giveCoordinate(2);
}
FloatArray A;
FloatArray dNdxi(3);
FloatArray es(2); // tangent vector to curve
FloatMatrix BJ(2, 6);
BJ.zero();
answer.resize(6);
answer.zero();
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
//interpolation.evaldNdx(dN, domain, dofManArray, * gp->giveCoordinates(), 0.0);
double xi = gp->giveCoordinate(1);
// Some simplifications can be performed, since the mapping J is a scalar.
dNdxi.at(1) = -0.5 + xi;
dNdxi.at(2) = 0.5 + xi;
dNdxi.at(3) = -2.0 * xi;
es.beProductOf(xy, dNdxi);
double J = es.computeNorm();
es.times(1 / J); //es.normalize();
// dNds = dNdxi/J
// B.at(1,1) = dNds.at(1); and so on.
BJ.at(1, 1) = BJ.at(2, 2) = dNdxi.at(1);
BJ.at(1, 3) = BJ.at(2, 4) = dNdxi.at(2);
BJ.at(1, 5) = BJ.at(2, 6) = dNdxi.at(3);
A.beTProductOf(BJ, es);
answer.add( - gamma_s * t * gp->giveWeight(), A); // Note! Negative sign!
}
}
double
QTrPlaneStrain :: DirectErrorIndicatorRCI_giveCharacteristicSize() {
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp;
double volume = 0.0;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
volume += this->computeVolumeAround(gp);
}
return sqrt( volume * 2.0 / this->giveCrossSection()->give(CS_Thickness) );
}
void Tr21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
FloatArray a_pressure, a_velocity, devStress, epsp, BTs, Nh, dNv(12);
double r_vol, pressure;
FloatMatrix dN, B(3, 12);
B.zero();
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, a_velocity);
this->computeVectorOf(EID_ConservationEquation, VM_Total, tStep, a_pressure);
FloatArray momentum(12), conservation(3);
momentum.zero();
conservation.zero();
GaussPoint *gp;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nh, * lcoords, FEIElementGeometryWrapper(this));
double dA = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dNv(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dNv(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
pressure = Nh.dotProduct(a_pressure);
epsp.beProductOf(B, a_velocity);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
BTs.beTProductOf(B, devStress);
momentum.add(dA, BTs);
momentum.add(-pressure*dA, dNv);
conservation.add(r_vol*dA, Nh);
}
FloatArray temp(15);
temp.zero();
temp.addSubVector(momentum, 1);
temp.addSubVector(conservation, 13);
answer.resize(15);
answer.zero();
answer.assemble(temp, this->ordering);
}
void
Quad1Mindlin :: computeBodyLoadVectorAt(FloatArray &answer, Load *forLoad, TimeStep *stepN, ValueModeType mode)
{
// Only gravity load
double dV, load;
GaussPoint *gp;
FloatArray force, gravity, n;
if ( ( forLoad->giveBCGeoType() != BodyLoadBGT ) || ( forLoad->giveBCValType() != ForceLoadBVT ) ) {
_error("computeBodyLoadVectorAt: unknown load type");
}
// note: force is assumed to be in global coordinate system.
forLoad->computeComponentArrayAt(gravity, stepN, mode);
force.resize(0);
if ( gravity.giveSize() ) {
IntegrationRule *ir = integrationRulesArray [ 0 ]; ///@todo Other/higher integration for lumped mass matrices perhaps?
for ( int i = 0; i < ir->getNumberOfIntegrationPoints(); ++i) {
gp = ir->getIntegrationPoint(i);
this->interp_lin.evalN(n, *gp->giveCoordinates(), FEIElementGeometryWrapper(this));
dV = this->computeVolumeAround(gp) * this->giveCrossSection()->give(CS_Thickness);
load = this->giveMaterial()->give('d', gp) * gravity.at(3) * dV;
force.add(load, n);
}
answer.resize(12);
answer.zero();
answer.at(1) = force.at(1);
answer.at(4) = force.at(2);
answer.at(7) = force.at(3);
answer.at(10) = force.at(4);
} else {
answer.resize(0);
}
}
void
Quad1Mindlin :: computeLumpedMassMatrix(FloatMatrix &answer, TimeStep *tStep)
// Returns the lumped mass matrix of the receiver.
{
GaussPoint *gp;
double dV, mass = 0.;
IntegrationRule *ir = integrationRulesArray [ 0 ]; ///@todo Other/higher integration for lumped mass matrices perhaps?
for ( int i = 0; i < ir->getNumberOfIntegrationPoints(); ++i) {
gp = ir->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
mass += dV * this->giveMaterial()->give('d', gp);
}
answer.resize(12, 12);
answer.zero();
answer.at(1, 1) = mass*0.25;
answer.at(4, 4) = mass*0.25;
answer.at(7, 7) = mass*0.25;
answer.at(10, 10) = mass*0.25;
}
// needed for CemhydMat
void
NonStationaryTransportProblem :: averageOverElements(TimeStep *tStep)
{
Domain *domain = this->giveDomain(1);
int ielem, i;
int nelem = domain->giveNumberOfElements();
double dV;
TransportElement *element;
IntegrationRule *iRule;
GaussPoint *gp;
FloatArray vecTemperature;
TransportMaterial *mat;
for ( ielem = 1; ielem <= nelem; ielem++ ) {
element = ( TransportElement * ) domain->giveElement(ielem);
mat = ( TransportMaterial * ) element->giveMaterial();
if ( mat->giveClassID() == CemhydMatClass ) {
iRule = element->giveDefaultIntegrationRulePtr();
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = element->computeVolumeAround(gp);
element->giveIPValue(vecTemperature, gp, IST_Temperature, tStep);
//mat->IP_volume += dV;
//mat->average_temp += vecState.at(1) * dV;
}
}
}
for ( i = 1; i <= domain->giveNumberOfMaterialModels(); i++ ) {
mat = ( TransportMaterial * ) domain->giveMaterial(i);
if ( mat->giveClassID() == CemhydMatClass ) {
//mat->average_temp /= mat->IP_volume;
}
}
}
void Tr21Stokes :: giveElementFMatrix(FloatMatrix &answer)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
GaussPoint *gp;
double detJ;
FloatArray N, N2, *lcoords;
IntArray col;
FloatMatrix temp;
N2.resize(6); N2.zero();
col.resize(2); col.at(1)=1; col.at(2)=2;
temp.resize(15,2);
temp.zero();
for (int i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(gp->giveWeight()*detJ);
//N.printYourself();
N2.add(N);
}
for (int i=1; i<=6; i++) {
temp.at(i*2-1, 1)=N2.at(i);
temp.at(i*2, 2)=N2.at(i);
}
answer.resize(17,2);
answer.zero();
answer.assemble(temp, this->ordering, col);
}
void
NLStructuralElement :: computeStiffnessMatrix_withIRulesAsSubcells(FloatMatrix &answer,
MatResponseMode rMode, TimeStep *tStep)
//
// Computes numerically the stiffness matrix of the receiver.
// taking into account possible effects of nonlinear geometry
//
{
int i, j, k, l, n, ir;
double dV;
FloatMatrix temp, d, A, *ut = NULL, b2;
FloatMatrix bi, bj, dbj, dij;
FloatArray u, stress;
GaussPoint *gp;
IntegrationRule *iRule;
IntArray irlocnum;
answer.resize( computeNumberOfDofs(EID_MomentumBalance), computeNumberOfDofs(EID_MomentumBalance) );
answer.zero();
if ( !this->isActivated(tStep) ) {
return;
}
Material *mat = this->giveMaterial();
if ( nlGeometry ) {
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, u);
if ( u.giveSize() ) {
ut = new FloatMatrix( &u, 1);
} else {
ut = NULL;
}
}
FloatMatrix *m = & answer;
if ( this->giveInterpolation() && this->giveInterpolation()->hasSubPatchFormulation() ) {
m = & temp;
}
// loop over individual integration rules
for ( ir = 0; ir < numberOfIntegrationRules; ir++ ) {
iRule = integrationRulesArray [ ir ];
for ( j = 0; j < iRule->getNumberOfIntegrationPoints(); j++ ) {
gp = iRule->getIntegrationPoint(j);
this->computeBmatrixAt(gp, bj);
if ( nlGeometry ) {
for ( l = 1; l <= bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( k = 1; k <= bj.giveNumberOfColumns(); k++ ) {
// add nonlinear contribution to each component
bj.at(l, k) += b2.at(1, k); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(d, bj);
m->plusProductSymmUpper(bj, dbj, dV);
}
if ( nlGeometry ) {
delete ut;
}
// localize irule contribution into element matrix
if ( this->giveIntegrationRuleLocalCodeNumbers(irlocnum, iRule, EID_MomentumBalance) ) {
answer.assemble(* m, irlocnum);
m->resize(0, 0);
}
}
if ( nlGeometry ) {
for ( ir = 0; ir < numberOfIntegrationRules; ir++ ) {
m->resize(0, 0);
iRule = integrationRulesArray [ ir ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
m->add(A);
}
}
}
}
// localize irule contribution into element matrix
if ( this->giveIntegrationRuleLocalCodeNumbers(irlocnum, iRule, EID_MomentumBalance) ) {
answer.assemble(* m, irlocnum);
m->resize(0, 0);
}
}
} // ens nlGeometry
answer.symmetrized();
}
void Tr21Stokes :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *tStep)
{
// Note: Working with the components; [K, G+Dp; G^T+Dv^T, C] . [v,p]
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatMatrix B(3, 12), EdB, K(12,12), G, Dp, DvT, C, Ed, dN;
FloatArray *lcoords, dN_V(12), Nlin, Ep, Cd, tmpA, tmpB;
double Cp;
K.zero();
G.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
// Compute Gauss point and determinant at current element
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
double dA = detJ * gp->giveWeight();
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nlin, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dN_V(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dN_V(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
// Computing the internal forces should have been done first.
mat->giveDeviatoricStiffnessMatrix(Ed, TangentStiffness, gp, tStep); // dsigma_dev/deps_dev
mat->giveDeviatoricPressureStiffness(Ep, TangentStiffness, gp, tStep); // dsigma_dev/dp
mat->giveVolumetricDeviatoricStiffness(Cd, TangentStiffness, gp, tStep); // deps_vol/deps_dev
mat->giveVolumetricPressureStiffness(Cp, TangentStiffness, gp, tStep); // deps_vol/dp
EdB.beProductOf(Ed,B);
K.plusProductSymmUpper(B, EdB, dA);
G.plusDyadUnsym(dN_V, Nlin, -dA);
C.plusDyadSymmUpper(Nlin, Nlin, Cp*dA);
tmpA.beTProductOf(B, Ep);
Dp.plusDyadUnsym(tmpA, Nlin, dA);
tmpB.beTProductOf(B, Cd);
DvT.plusDyadUnsym(Nlin, tmpB, dA);
}
K.symmetrized();
C.symmetrized();
FloatMatrix GTDvT, GDp;
GTDvT.beTranspositionOf(G);
GTDvT.add(DvT);
GDp = G;
GDp.add(Dp);
FloatMatrix temp(15, 15);
temp.setSubMatrix(K, 1, 1);
temp.setSubMatrix(GTDvT, 13, 1);
temp.setSubMatrix(GDp, 1, 13);
temp.setSubMatrix(C, 13, 13);
answer.resize(15, 15);
answer.zero();
answer.assemble(temp, this->ordering);
}
void
MMALeastSquareProjection :: __init(Domain *dold, IntArray &type, FloatArray &coords, int region, TimeStep *tStep)
//(Domain* dold, IntArray& varTypes, GaussPoint* gp, TimeStep* tStep)
{
GaussPoint *sourceIp;
Element *sourceElement;
SpatialLocalizer *sl = dold->giveSpatialLocalizer();
IntegrationRule *iRule;
int j, nip;
IntArray patchList;
this->patchDomain = dold;
// find the closest IP on old mesh
sourceElement = sl->giveElementContainingPoint(coords);
// determine the type of patch
Element_Geometry_Type egt = sourceElement->giveGeometryType();
if ( egt == EGT_line_1 ) {
this->patchType = MMALSPPatchType_1dq;
} else if ( ( egt == EGT_triangle_1 ) || ( egt == EGT_quad_1 ) ) {
this->patchType = MMALSPPatchType_2dq;
} else {
OOFEM_ERROR("MMALeastSquareProjection::__init: unsupported material mode");
}
if ( !sourceElement ) {
OOFEM_ERROR("MMALeastSquareProjection::__init: no suitable source element found");
}
/* Determine the state of closest point.
* Only IP in the neighbourhood with same state can be used
* to interpolate the values.
*/
FloatArray dam;
int state = 0;
if ( this->stateFilter ) {
iRule = sourceElement->giveDefaultIntegrationRulePtr();
nip = iRule->getNumberOfIntegrationPoints();
for ( j = 0; j < nip; j++ ) {
sourceElement->giveIPValue(dam, iRule->getIntegrationPoint(j), IST_PrincipalDamageTensor, tStep);
if ( dam.computeNorm() > 1.e-3 ) {
state = 1; // damaged
}
}
}
// from source neighbours the patch will be constructed
Element *element;
IntArray neighborList;
patchList.resize(1);
patchList.at(1) = sourceElement->giveNumber();
int minNumberOfPoints = this->giveNumberOfUnknownPolynomialCoefficients(this->patchType);
int actualNumberOfPoints = sourceElement->giveDefaultIntegrationRulePtr()->getNumberOfIntegrationPoints();
int i, nite = 0;
int elemFlag;
// check if number of IP in patchList is sufficient
// some recursion control would be appropriate
while ( ( actualNumberOfPoints < minNumberOfPoints ) && ( nite <= 2 ) ) {
//if not, construct the neighborhood
dold->giveConnectivityTable()->giveElementNeighbourList(neighborList, patchList);
// count number of available points
patchList.resize(0);
actualNumberOfPoints = 0;
for ( i = 1; i <= neighborList.giveSize(); i++ ) {
if ( this->stateFilter ) {
element = patchDomain->giveElement( neighborList.at(i) );
// exclude elements in different regions
if ( this->regionFilter && ( element->giveRegionNumber() != region ) ) {
continue;
}
iRule = element->giveDefaultIntegrationRulePtr();
nip = iRule->getNumberOfIntegrationPoints();
elemFlag = 0;
for ( j = 0; j < nip; j++ ) {
element->giveIPValue(dam, iRule->getIntegrationPoint(j), IST_PrincipalDamageTensor, tStep);
if ( state && ( dam.computeNorm() > 1.e-3 ) ) {
actualNumberOfPoints++;
elemFlag = 1;
} else if ( ( state == 0 ) && ( dam.computeNorm() < 1.e-3 ) ) {
actualNumberOfPoints++;
elemFlag = 1;
}
}
if ( elemFlag ) {
// include this element with corresponding state in neighbor search.
patchList.followedBy(neighborList.at(i), 10);
}
} else { // if (! yhis->stateFilter)
element = patchDomain->giveElement( neighborList.at(i) );
// exclude elements in different regions
if ( this->regionFilter && ( element->giveRegionNumber() != region ) ) {
continue;
}
actualNumberOfPoints += element->giveDefaultIntegrationRulePtr()->getNumberOfIntegrationPoints();
patchList.followedBy(neighborList.at(i), 10);
}
} // end loop over neighbor list
nite++;
}
if ( nite > 2 ) {
// not enough points -> take closest point projection
patchGPList.clear();
sourceIp = sl->giveClosestIP(coords, region);
patchGPList.push_front(sourceIp);
//fprintf(stderr, "MMALeastSquareProjection: too many neighbor search iterations\n");
//exit (1);
return;
}
#ifdef MMALSP_ONLY_CLOSEST_POINTS
// select only the nval closest IP points
GaussPoint **gpList = ( GaussPoint ** ) malloc(sizeof( GaussPoint * ) * actualNumberOfPoints);
FloatArray dist(actualNumberOfPoints), srcgpcoords;
GaussPoint *srcgp;
int npoints = 0;
// check allocation of gpList
if ( gpList == NULL ) {
OOFEM_ERROR("MMALeastSquareProjection::__init: memory allocation error");
}
for ( int ielem = 1; ielem <= patchList.giveSize(); ielem++ ) {
element = patchDomain->giveElement( patchList.at(ielem) );
iRule = element->giveDefaultIntegrationRulePtr();
nip = iRule->getNumberOfIntegrationPoints();
for ( i = 0; i < nip; i++ ) {
srcgp = iRule->getIntegrationPoint(i);
if ( element->computeGlobalCoordinates( srcgpcoords, * ( srcgp->giveCoordinates() ) ) ) {
element->giveIPValue(dam, srcgp, IST_PrincipalDamageTensor, tStep);
if ( this->stateFilter ) {
// consider only points with same state
if ( ( ( state == 1 ) && ( norm(dam) > 1.e-3 ) ) || ( ( ( state == 0 ) && norm(dam) < 1.e-3 ) ) ) {
npoints++;
dist.at(npoints) = coords.distance(srcgpcoords);
gpList [ npoints - 1 ] = srcgp;
}
} else {
// take all points into account
npoints++;
dist.at(npoints) = coords.distance(srcgpcoords);
gpList [ npoints - 1 ] = srcgp;
}
} else {
_error("init: computeGlobalCoordinates failed");
}
}
}
if ( npoints != actualNumberOfPoints ) {
OOFEM_ERROR(stderr, "MMALeastSquareProjection::__init: internal error");
}
//minNumberOfPoints = min (actualNumberOfPoints, minNumberOfPoints+2);
patchGPList.clear();
// now find the minNumberOfPoints with smallest distance
// from point of interest
double swap, minDist;
int minDistIndx = 0;
// loop over all points
for ( i = 1; i <= minNumberOfPoints; i++ ) {
minDist = dist.at(i);
minDistIndx = i;
// search for point with i-th smallest distance
for ( j = i + 1; j <= actualNumberOfPoints; j++ ) {
if ( dist.at(j) < minDist ) {
minDist = dist.at(j);
minDistIndx = j;
}
}
// remember this ip
patchGPList.push_front(gpList [ minDistIndx - 1 ]);
swap = dist.at(i);
dist.at(i) = dist.at(minDistIndx);
dist.at(minDistIndx) = swap;
srcgp = gpList [ i - 1 ];
gpList [ i - 1 ] = gpList [ minDistIndx - 1 ];
gpList [ minDistIndx - 1 ] = srcgp;
}
if ( patchGPList.size() != minNumberOfPoints ) {
OOFEM_ERROR("MMALeastSquareProjection: internal error 2\n");
exit(1);
}
free(gpList);
#else
// take all neighbors
patchGPList.clear();
for ( int ielem = 1; ielem <= patchList.giveSize(); ielem++ ) {
element = patchDomain->giveElement( patchList.at(ielem) );
iRule = element->giveDefaultIntegrationRulePtr();
nip = iRule->getNumberOfIntegrationPoints();
for ( i = 0; i < nip; i++ ) {
patchGPList.push_front( iRule->getIntegrationPoint(i) );
}
}
#endif
}
void
NLStructuralElement :: giveInternalForcesVector_withIRulesAsSubcells(FloatArray &answer,
TimeStep *tStep, int useUpdatedGpRecord)
//
// returns nodal representation of real internal forces - necessary only for
// non-linear analysis.
// if useGpRecord == 1 then data stored in gp->giveStressVector() are used
// instead computing stressVector through this->ComputeStressVector();
// this must be done after you want internal forces after element->updateYourself()
// has been called for the same time step.
//
{
GaussPoint *gp;
Material *mat = this->giveMaterial();
IntegrationRule *iRule;
FloatMatrix b, A, *ut = NULL, b2;
FloatArray temp, bs, TotalStressVector, u;
IntArray irlocnum;
int ir, i, j, k;
double dV;
// do not resize answer to computeNumberOfDofs(EID_MomentumBalance)
// as this is valid only if receiver has no nodes with slaves
// zero answer will resize accordingly when adding first contribution
answer.resize(0);
if ( nlGeometry ) {
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, u);
if ( u.giveSize() ) {
ut = new FloatMatrix( &u, 1);
} else {
ut = NULL;
}
}
FloatArray *m = & answer;
if ( this->giveInterpolation() && this->giveInterpolation()->hasSubPatchFormulation() ) {
m = & temp;
}
// loop over individual integration rules
for ( ir = 0; ir < numberOfIntegrationRules; ir++ ) {
iRule = integrationRulesArray [ ir ];
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
this->computeBmatrixAt(gp, b);
if ( nlGeometry ) {
for ( j = 1; j <= b.giveNumberOfRows(); j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(*ut,A);
for ( k = 1; k <= b.giveNumberOfColumns(); k++ ) {
// add nonlinear contribution to each component
b.at(j, k) += b2.at(1, k); //mj
}
}
}
} // end nlGeometry
// TotalStressVector = gp->giveStressVector() ;
if ( useUpdatedGpRecord == 1 ) {
TotalStressVector = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )
->giveStressVector();
} else {
this->computeStressVector(TotalStressVector, gp, tStep);
}
//
// updates gp stress and strain record acording to current
// increment of displacement
//
if ( TotalStressVector.giveSize() == 0 ) {
break;
}
//
// now every gauss point has real stress vector
//
// compute nodal representation of internal forces using f = B^T*Sigma dV
//
dV = this->computeVolumeAround(gp);
bs.beTProductOf(b, TotalStressVector);
m->add(dV, bs);
// localize irule contribution into element matrix
if ( this->giveIntegrationRuleLocalCodeNumbers(irlocnum, iRule, EID_MomentumBalance) ) {
answer.assemble(* m, irlocnum);
m->resize(0, 0);
}
}
} // end loop over irules
if ( nlGeometry ) {
delete ut;
}
// if inactive update fields; but do not contribute to structure
if ( !this->isActivated(tStep) ) {
answer.zero();
return;
}
}
void
NLStructuralElement :: computeStiffnessMatrix(FloatMatrix &answer,
MatResponseMode rMode, TimeStep *tStep)
//
// Computes numerically the stiffness matrix of the receiver.
// taking into account possible effects of nonlinear geometry
//
{
int i, j, k, l, m, n, iStartIndx, iEndIndx, jStartIndx, jEndIndx;
double dV;
FloatMatrix d, A, *ut = NULL, b2;
FloatMatrix bi, bj, dbj, dij;
FloatArray u, stress;
GaussPoint *gp;
IntegrationRule *iRule;
bool matStiffSymmFlag = this->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode, this->material);
answer.resize( computeNumberOfDofs(EID_MomentumBalance), computeNumberOfDofs(EID_MomentumBalance) );
answer.zero();
if ( !this->isActivated(tStep) ) {
return;
}
Material *mat = this->giveMaterial();
if ( nlGeometry ) {
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, u);
if ( u.giveSize() ) {
ut = new FloatMatrix( &u, 1);
} else {
ut = NULL;
}
}
if ( numberOfIntegrationRules > 1 ) {
for ( i = 0; i < numberOfIntegrationRules; i++ ) {
iStartIndx = integrationRulesArray [ i ]->getStartIndexOfLocalStrainWhereApply();
iEndIndx = integrationRulesArray [ i ]->getEndIndexOfLocalStrainWhereApply();
for ( j = 0; j < numberOfIntegrationRules; j++ ) {
jStartIndx = integrationRulesArray [ j ]->getStartIndexOfLocalStrainWhereApply();
jEndIndx = integrationRulesArray [ j ]->getEndIndexOfLocalStrainWhereApply();
if ( i == j ) {
iRule = integrationRulesArray [ i ];
} else if ( integrationRulesArray [ i ]->getNumberOfIntegrationPoints() < integrationRulesArray [ j ]->getNumberOfIntegrationPoints() ) {
iRule = integrationRulesArray [ i ];
} else {
iRule = integrationRulesArray [ j ];
}
for ( k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
this->computeBmatrixAt(gp, bi, iStartIndx, iEndIndx);
if ( i != j ) {
this->computeBmatrixAt(gp, bj, jStartIndx, jEndIndx);
} else {
bj = bi;
}
if ( nlGeometry ) {
for ( l = 0; l < bi.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l + iStartIndx);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( m = 1; m <= bi.giveNumberOfColumns(); m++ ) {
// add nonlinear contribution to each component
bi.at(l + 1, m) += b2.at(1, m); //mj
}
}
}
}
if ( nlGeometry && ( i != j ) ) {
for ( l = 0; l < bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l + jStartIndx);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( m = 1; m <= bj.giveNumberOfColumns(); m++ ) {
// add nonlinear contribution to each component
bj.at(l + 1, m) += b2.at(1, m); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dij.beSubMatrixOf(d, iStartIndx, iEndIndx, jStartIndx, jEndIndx);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(dij, bj);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(bi, dbj, dV);
} else {
answer.plusProductUnsym(bi, dbj, dV);
}
}
}
}
} else { // numberOfIntegrationRules == 1
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
for ( j = 0; j < iRule->getNumberOfIntegrationPoints(); j++ ) {
gp = iRule->getIntegrationPoint(j);
this->computeBmatrixAt(gp, bj);
if ( nlGeometry ) {
for ( l = 1; l <= bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( k = 1; k <= bj.giveNumberOfColumns(); k++ ) {
// add nonlinear contribution to each component
bj.at(l, k) += b2.at(1, k); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(d, bj);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(bj, dbj, dV);
} else {
answer.plusProductUnsym(bj, dbj, dV);
}
}
}
if ( nlGeometry ) {
delete ut;
}
if ( nlGeometry ) {
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveTempStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
answer.add(A);
}
}
}
}
} // end nlGeometry
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
//keyword "cellvars" in OOFEM input file
void
VTKXMLExportModule :: exportCellVarAs(InternalStateType type, int region,
#ifdef __VTK_MODULE
vtkSmartPointer<vtkUnstructuredGrid> &stream,
#else
FILE *stream,
#endif
TimeStep *tStep)
{
Domain *d = emodel->giveDomain(1);
int ielem, nelem = d->giveNumberOfElements();
int pos;
Element *elem;
FloatMatrix mtrx(3, 3);
IntegrationRule *iRule;
GaussPoint *gp;
FloatArray answer, temp;
double gptot;
int ncomponents = 1;
#ifdef __VTK_MODULE
vtkSmartPointer<vtkDoubleArray> cellVarsArray = vtkSmartPointer<vtkDoubleArray>::New();
cellVarsArray->SetName(__InternalStateTypeToString(type));
#endif
switch ( type ) {
case IST_MaterialNumber:
case IST_ElementNumber:
case IST_Pressure:
// if it wasn't for IST_Pressure,
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(1);
cellVarsArray->SetNumberOfTuples(nelem);
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" format=\"ascii\">\n", __InternalStateTypeToString(type) );
#endif
for ( ielem = 1; ielem <= nelem; ielem++ ) {
elem = d->giveElement(ielem);
if ( (( region > 0 ) && ( this->smoother->giveElementVirtualRegionNumber(ielem) != region ))
|| this->isElementComposite(elem) || !elem-> isActivated(tStep) ) { // composite cells exported individually
continue;
}
#ifdef __PARALLEL_MODE
if ( elem->giveParallelMode() != Element_local ) {
continue;
}
#endif
if ( type == IST_MaterialNumber ) {
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, elem->giveMaterial()->giveNumber() ); // Should be integer..
#else
fprintf( stream, "%d ", elem->giveMaterial()->giveNumber() );
#endif
} else if ( type == IST_ElementNumber ) {
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, elem->giveNumber() ); // Should be integer..
#else
fprintf( stream, "%d ", elem->giveNumber() );
#endif
} else if (type == IST_Pressure) { ///@todo Why this special treatment for pressure? / Mikael
if (elem->giveNumberOfInternalDofManagers() == 1) {
IntArray pmask(1); pmask.at(1) = P_f;
elem->giveInternalDofManager(1)->giveUnknownVector (answer, pmask,EID_ConservationEquation, VM_Total, tStep);
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, answer.at(1) ); // Should be integer..
#else
fprintf( stream, "%f ", answer.at(1) );
#endif
}
}
}
#ifdef __VTK_MODULE
stream->GetCellData()->SetActiveScalars(__InternalStateTypeToString(type));
stream->GetCellData()->SetScalars(cellVarsArray);
#endif
break;
case IST_MaterialOrientation_x:
case IST_MaterialOrientation_y:
case IST_MaterialOrientation_z:
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(3);
cellVarsArray->SetNumberOfTuples(nelem);
ncomponents = 3;
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" NumberOfComponents=\"3\" format=\"ascii\">\n", __InternalStateTypeToString(type) );
#endif
if ( type == IST_MaterialOrientation_x ) {
pos = 1;
}
if ( type == IST_MaterialOrientation_y ) {
pos = 2;
}
if ( type == IST_MaterialOrientation_z ) {
pos = 3;
}
for ( ielem = 1; ielem <= nelem; ielem++ ) {
///@todo Should no elements be skipped here? / Mikael
if ( !d->giveElement(ielem)->giveLocalCoordinateSystem(mtrx) ) {
mtrx.resize(3, 3);
mtrx.zero();
}
#ifdef __VTK_MODULE
cellVarsArray->SetTuple3(ielem-1, mtrx.at(1, pos), mtrx.at(2,pos), mtrx.at(3,pos) );
#else
fprintf( stream, "%f %f %f ", mtrx.at(1, pos), mtrx.at(2, pos), mtrx.at(3, pos) );
#endif
}
#ifdef __VTK_MODULE
stream->GetCellData()->SetActiveVectors(__InternalStateTypeToString(type));
stream->GetCellData()->SetVectors(cellVarsArray);
#endif
break;
default:
bool reshape = false;
InternalStateValueType vt = giveInternalStateValueType(type);
if ( vt == ISVT_SCALAR ) {
ncomponents = 1;
} else if ( vt == ISVT_VECTOR ) {
ncomponents = 3;
} else {
ncomponents = 9;
reshape = true;
}
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(ncomponents);
cellVarsArray->SetNumberOfTuples(nelem);
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" NumberOfComponents=\"%d\" format=\"ascii\">\n", __InternalStateTypeToString(type), ncomponents );
#endif
IntArray redIndx;
for ( ielem = 1; ielem <= nelem; ielem++ ) {
elem = d->giveElement(ielem);
if ( (( region > 0 ) && ( this->smoother->giveElementVirtualRegionNumber(ielem) != region ))
|| this->isElementComposite(elem) || !elem-> isActivated(tStep) ) { // composite cells exported individually
continue;
}
#ifdef __PARALLEL_MODE
if ( elem->giveParallelMode() != Element_local ) {
continue;
}
#endif
gptot = 0;
answer.resize(0);
iRule = elem->giveDefaultIntegrationRulePtr();
if (iRule) {
MaterialMode mmode = _Unknown;
for (int i = 0; i < iRule->getNumberOfIntegrationPoints(); ++i) {
gp = iRule->getIntegrationPoint(i);
mmode = gp->giveMaterialMode();
elem->giveIPValue(temp, gp, type, tStep);
gptot += gp->giveWeight();
answer.add(gp->giveWeight(), temp);
}
answer.times(1./gptot);
elem->giveMaterial()->giveIntVarCompFullIndx(redIndx, type, mmode);
}
// Reshape the Voigt vectors to include all components (duplicated if necessary, VTK insists on 9 components for tensors.)
if ( reshape && answer.giveSize() != 9) { // If it has 9 components, then it is assumed to be proper already.
FloatArray tmp = answer;
this->makeFullForm(answer, tmp, vt, redIndx);
} else if ( vt == ISVT_VECTOR && answer.giveSize() < 3) {
answer.setValues(3,
answer.giveSize() > 1 ? answer.at(1) : 0.0,
answer.giveSize() > 2 ? answer.at(2) : 0.0,
0.0);
} else if ( ncomponents != answer.giveSize() ) { // Trying to gracefully handle bad cases, just output zeros.
answer.resize(ncomponents);
answer.zero();
}
for (int i = 1; i <= ncomponents; ++i) {
#ifdef __VTK_MODULE
cellVarsArray->SetComponent(ielem-1, i-1, answer.at(i));
#else
fprintf( stream, "%e ", answer.at(i) );
#endif
}
#ifndef __VTK_MODULE
fprintf( stream, "\n" );
#endif
}
#ifdef __VTK_MODULE
if (ncomponents == 1) {
stream->GetCellData()->SetActiveScalars(__InternalStateTypeToString(type));
stream->GetCellData()->SetScalars(cellVarsArray);
} else if (ncomponents == 3) {
stream->GetCellData()->SetActiveVectors(__InternalStateTypeToString(type));
stream->GetCellData()->SetVectors(cellVarsArray);
} else {
stream->GetCellData()->SetActiveTensors(__InternalStateTypeToString(type));
stream->GetCellData()->SetTensors(cellVarsArray);
}
#endif
}
#ifndef __VTK_MODULE
fprintf(stream, "</DataArray>\n");
#endif
}
void Line2SurfaceTension :: computeTangent(FloatMatrix &answer, TimeStep *tStep)
{
#if 1
answer.resize(6, 6);
answer.zero();
#else
///@todo Support axisymm.
domainType dt = this->giveDomain()->giveDomainType();
if (dt == _3dAxisymmMode) {
OOFEM_ERROR("Line2SurfaceTension :: computeTangent - Axisymm not implemented");
}
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
double t = 1, gamma_s;
///@todo Should i use this? Not that meaningful for flow problems.
//t = this->giveDomain()->giveCrossSection(1)->give(CS_Thickness);
gamma_s = this->giveMaterial()->give('g', NULL);
FloatMatrix xy(2,3);
Node *node;
for (int i = 1; i <= 3; i++) {
node = giveNode(i);
xy.at(1,i) = node->giveCoordinate(1);
xy.at(2,i) = node->giveCoordinate(2);
}
FloatArray A;
FloatArray dNdxi(3);
FloatArray es(2); // tangent vector to curve
FloatMatrix BJ(2,6);
BJ.zero();
FloatMatrix temp1,temp2;
answer.resize(6,6);
answer.zero();
for (int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
double xi = gp->giveCoordinate(1);
dNdxi.at(1) = -0.5+xi;
dNdxi.at(2) = 0.5+xi;
dNdxi.at(3) = -2.0*xi;
es.beProductOf(xy,dNdxi);
double J = es.computeNorm();
es.times(1/J); //es.normalize();
BJ.at(1,1) = BJ.at(2,2) = dNdxi.at(1);
BJ.at(1,3) = BJ.at(2,4) = dNdxi.at(2);
BJ.at(1,5) = BJ.at(2,6) = dNdxi.at(3);
A.beTProductOf(BJ,es);
temp1.beTProductOf(BJ,BJ);
temp2.beDyadicProductOf(A,A);
temp1.subtract(temp2);
temp1.times(t*gp->giveWeight()/J*(tStep->giveTimeIncrement()));
answer.add(temp1);
}
answer.times(gamma_s);
#endif
}
