Merge
--HG-- branch : bgschaid/minorAdditionsBranch
This commit is contained in:
commit
72c243a96f
1416 changed files with 18017 additions and 18012 deletions
|
@ -17,13 +17,13 @@ if(divDSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divDSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradDU =
|
||||
((I - n*n)&fvc::interpolate(gradDU));
|
||||
surfaceTensorField shearGradDU = ((I - n*n)&fvc::interpolate(gradDU));
|
||||
|
||||
divDSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(DU)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradDU&(I - n*n))*n
|
||||
+ muf*(shearGradDU&n)
|
||||
|
|
|
@ -33,9 +33,13 @@ if(Pstream::parRun())
|
|||
label slaveID = contacts[contactI].slavePatch().index();
|
||||
|
||||
primitivePatchInterpolation masterInterpolator
|
||||
(mesh.boundaryMesh()[masterID]);
|
||||
(
|
||||
mesh.boundaryMesh()[masterID]
|
||||
);
|
||||
primitivePatchInterpolation slaveInterpolator
|
||||
(mesh.boundaryMesh()[slaveID]);
|
||||
(
|
||||
mesh.boundaryMesh()[slaveID]
|
||||
);
|
||||
|
||||
//- U must be interpolated to the vertices, this ignores the faceZone
|
||||
//- points with no U (unlike volPointInterpolation)
|
||||
|
@ -65,23 +69,17 @@ if(Pstream::parRun())
|
|||
{
|
||||
label pointGlobalLabel = masterPointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldMasterPoints[pointI]
|
||||
+
|
||||
correctMasterPointU[pointI];
|
||||
oldMasterPoints[pointI] + correctMasterPointU[pointI];
|
||||
}
|
||||
forAll(slavePointLabels, pointI)
|
||||
{
|
||||
label pointGlobalLabel = slavePointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldSlavePoints[pointI]
|
||||
+
|
||||
correctSlavePointU[pointI];
|
||||
oldSlavePoints[pointI] + correctSlavePointU[pointI];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//***** NOW FIX AND SYNCHRONISE ALL THE FACEZONE POINTS *****//
|
||||
|
||||
forAll(mesh.faceZones(), faceZoneI)
|
||||
|
@ -117,8 +115,7 @@ if(Pstream::parRun())
|
|||
{
|
||||
label procPoint =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints()[localPoint];
|
||||
globalFZnewPoints[globalPointI] =
|
||||
newPoints[procPoint];
|
||||
globalFZnewPoints[globalPointI] = newPoints[procPoint];
|
||||
pointNumProcs[globalPointI] = 1;
|
||||
}
|
||||
}
|
||||
|
@ -141,20 +138,16 @@ if(Pstream::parRun())
|
|||
forAll(globalFZnewPoints, globalPointI)
|
||||
{
|
||||
label localPoint = procToGlobalFZmap[faceZoneI][globalPointI];
|
||||
|
||||
procFZnewPoints[localPoint] =
|
||||
globalFZnewPoints[globalPointI];
|
||||
procFZnewPoints[localPoint] = globalFZnewPoints[globalPointI];
|
||||
}
|
||||
|
||||
//- now fix the newPoints points on the globalFaceZones
|
||||
labelList procFZmeshPoints =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
labelList procFZmeshPoints = mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
|
||||
forAll(procFZmeshPoints, pointI)
|
||||
{
|
||||
label procPoint = procFZmeshPoints[pointI];
|
||||
newPoints[procPoint] =
|
||||
procFZnewPoints[pointI];
|
||||
newPoints[procPoint] = procFZnewPoints[pointI];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -70,7 +70,9 @@ if(Pstream::parRun())
|
|||
|
||||
//- set all slave points to zero because only the master order is used
|
||||
if(!Pstream::master())
|
||||
{
|
||||
globalFZpoints *= 0.0;
|
||||
}
|
||||
|
||||
//- pass points to all procs
|
||||
reduce(globalFZpoints, sumOp<vectorField>());
|
||||
|
@ -93,6 +95,7 @@ if(Pstream::parRun())
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
//- procToGlobalFZmap now contains the local FZpoint label for each
|
||||
//- global FZ point label - for each faceZone
|
||||
|
||||
|
|
|
@ -15,7 +15,7 @@ solidInterface* solidInterfacePtr(NULL);
|
|||
solidInterfacePtr->modifyProperties(muf, lambdaf);
|
||||
gradDU = solidInterfacePtr->grad(DU);
|
||||
|
||||
//- solidInterface needs muf and lambdaf to be used for divSigmaExp
|
||||
//- solidInterface needs muf and lambdaf to be used for divDSigmaExp
|
||||
if(divDSigmaExpMethod != "surface" && divDSigmaExpMethod != "decompose")
|
||||
{
|
||||
FatalError << "divDSigmaExp must be decompose or surface when solidInterface is on"
|
||||
|
|
|
@ -101,7 +101,9 @@ int main(int argc, char *argv[])
|
|||
//- reset DU to zero at the start of the time-step if
|
||||
//- a predictor is not required
|
||||
if(!predictor)
|
||||
{
|
||||
DU = dimensionedVector("zero", dimLength, vector::zero);
|
||||
}
|
||||
|
||||
do //- start of momentum loop
|
||||
{
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -1,7 +1,13 @@
|
|||
//- how explicit component of sigma is to be calculated
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << divDSigmaExpMethod << " method chosen for calculation of sigmaExp" << endl;
|
||||
if(divDSigmaExpMethod != "standard" && divDSigmaExpMethod != "surface" && divDSigmaExpMethod != "decompose" && divDSigmaExpMethod != "laplacian")
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -44,6 +44,7 @@ if (runTime.outputTime())
|
|||
),
|
||||
tr(sigma)/3.0
|
||||
);
|
||||
|
||||
//- boundary surface pressure
|
||||
forAll(pressure.boundaryField(), patchi)
|
||||
{
|
||||
|
|
|
@ -69,5 +69,4 @@ FieldField<Field, vector> extraVecs(ptc.size());
|
|||
|
||||
curExtraVectors.setSize(nFacesAroundPoint);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -91,7 +91,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
|
||||
// Update coupled boundaries
|
||||
// Work-around for cyclic parallels.
|
||||
/*if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
/*
|
||||
if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
{
|
||||
forAll (volPointSumWeights.boundaryField(), patchI)
|
||||
{
|
||||
|
@ -111,7 +112,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
// Re-scale the weights for the current point
|
||||
forAll (ptc, pointI)
|
||||
|
|
|
@ -33,9 +33,13 @@ if(Pstream::parRun())
|
|||
label slaveID = contacts[contactI].slavePatch().index();
|
||||
|
||||
primitivePatchInterpolation masterInterpolator
|
||||
(mesh.boundaryMesh()[masterID]);
|
||||
(
|
||||
mesh.boundaryMesh()[masterID]
|
||||
);
|
||||
primitivePatchInterpolation slaveInterpolator
|
||||
(mesh.boundaryMesh()[slaveID]);
|
||||
(
|
||||
mesh.boundaryMesh()[slaveID]
|
||||
);
|
||||
|
||||
//- DU must be interpolated to the vertices, this ignores the faceZone
|
||||
//- points with no DU (unlike volPointInterpolation)
|
||||
|
@ -65,23 +69,17 @@ if(Pstream::parRun())
|
|||
{
|
||||
label pointGlobalLabel = masterPointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldMasterPoints[pointI]
|
||||
+
|
||||
correctMasterPointDU[pointI];
|
||||
oldMasterPoints[pointI] + correctMasterPointDU[pointI];
|
||||
}
|
||||
forAll(slavePointLabels, pointI)
|
||||
{
|
||||
label pointGlobalLabel = slavePointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldSlavePoints[pointI]
|
||||
+
|
||||
correctSlavePointDU[pointI];
|
||||
oldSlavePoints[pointI] + correctSlavePointDU[pointI];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//***** NOW FIX AND SYNCHRONISE ALL THE FACEZONE POINTS *****//
|
||||
|
||||
forAll(mesh.faceZones(), faceZoneI)
|
||||
|
@ -117,8 +115,7 @@ if(Pstream::parRun())
|
|||
{
|
||||
label procPoint =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints()[localPoint];
|
||||
globalFZnewPoints[globalPointI] =
|
||||
newPoints[procPoint];
|
||||
globalFZnewPoints[globalPointI] = newPoints[procPoint];
|
||||
pointNumProcs[globalPointI] = 1;
|
||||
}
|
||||
}
|
||||
|
@ -141,20 +138,16 @@ if(Pstream::parRun())
|
|||
forAll(globalFZnewPoints, globalPointI)
|
||||
{
|
||||
label localPoint = procToGlobalFZmap[faceZoneI][globalPointI];
|
||||
|
||||
procFZnewPoints[localPoint] =
|
||||
globalFZnewPoints[globalPointI];
|
||||
procFZnewPoints[localPoint] = globalFZnewPoints[globalPointI];
|
||||
}
|
||||
|
||||
//- now fix the newPoints points on the globalFaceZones
|
||||
labelList procFZmeshPoints =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
labelList procFZmeshPoints = mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
|
||||
forAll(procFZmeshPoints, pointI)
|
||||
{
|
||||
label procPoint = procFZmeshPoints[pointI];
|
||||
newPoints[procPoint] =
|
||||
procFZnewPoints[pointI];
|
||||
newPoints[procPoint] = procFZnewPoints[pointI];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -70,7 +70,9 @@ if(Pstream::parRun())
|
|||
|
||||
//- set all slave points to zero because only the master order is used
|
||||
if(!Pstream::master())
|
||||
{
|
||||
globalFZpoints *= 0.0;
|
||||
}
|
||||
|
||||
//- pass points to all procs
|
||||
reduce(globalFZpoints, sumOp<vectorField>());
|
||||
|
@ -93,8 +95,6 @@ if(Pstream::parRun())
|
|||
}
|
||||
}
|
||||
}
|
||||
//- procToGlobalFZmap now contains the local FZpoint label for each
|
||||
//- global FZ point label - for each faceZone
|
||||
|
||||
//- check what points are on the current proc patch
|
||||
pointOnLocalProcPatch[faceZoneI].setSize(globalFZpoints.size(), 0);
|
||||
|
|
|
@ -135,7 +135,6 @@ int main(int argc, char *argv[])
|
|||
fvm::laplacian(2*mu + lambda, DU, "laplacian(DDU,DU)")
|
||||
+ divDSigmaExp
|
||||
+ divDSigmaLargeStrainExp
|
||||
|
||||
);
|
||||
|
||||
solverPerf = DUEqn.solve();
|
||||
|
|
|
@ -41,8 +41,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
//pointDU.write();
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
// Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -7,7 +7,8 @@ pointVectorField& pf = pointDU;
|
|||
|
||||
// Do the correction
|
||||
//GeometricField<Type, pointPatchField, pointMesh> pfCorr
|
||||
/*pointVectorField pfCorr
|
||||
/*
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
|
@ -23,7 +24,8 @@ pointVectorField& pf = pointDU;
|
|||
//dimensioned<Type>("zero", pf.dimensions(), pTraits<Type>::zero),
|
||||
dimensionedVector("zero", pf.dimensions(), vector::zero),
|
||||
pf.boundaryField().types()
|
||||
);*/
|
||||
);
|
||||
*/
|
||||
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
|
@ -96,21 +98,25 @@ forAll (ptc, pointI)
|
|||
}
|
||||
|
||||
// Update coupled boundaries
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].initAddField();
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].addField(pfCorr.internalField());
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
//Info << "pfCorr: " << pfCorr << endl;
|
||||
|
|
|
@ -1,7 +1,13 @@
|
|||
//- how explicit component of sigma is to be calculated
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << divDSigmaExpMethod << " method chosen for calculation of DSigmaExp" << endl;
|
||||
if(divDSigmaExpMethod != "standard" && divDSigmaExpMethod != "surface" && divDSigmaExpMethod != "decompose" && divDSigmaExpMethod != "laplacian")
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -17,8 +17,7 @@ if(divSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradU =
|
||||
((I - n*n)&fvc::interpolate(gradU));
|
||||
surfaceTensorField shearGradU = ((I - n*n)&fvc::interpolate(gradU));
|
||||
|
||||
divSigmaExp = fvc::div
|
||||
(
|
||||
|
|
|
@ -33,9 +33,13 @@ if(Pstream::parRun())
|
|||
label slaveID = contacts[contactI].slavePatch().index();
|
||||
|
||||
primitivePatchInterpolation masterInterpolator
|
||||
(mesh.boundaryMesh()[masterID]);
|
||||
(
|
||||
mesh.boundaryMesh()[masterID]
|
||||
);
|
||||
primitivePatchInterpolation slaveInterpolator
|
||||
(mesh.boundaryMesh()[slaveID]);
|
||||
(
|
||||
mesh.boundaryMesh()[slaveID]
|
||||
);
|
||||
|
||||
//- U must be interpolated to the vertices, this ignores the faceZone
|
||||
//- points with no U (unlike volPointInterpolation)
|
||||
|
@ -65,23 +69,17 @@ if(Pstream::parRun())
|
|||
{
|
||||
label pointGlobalLabel = masterPointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldMasterPoints[pointI]
|
||||
+
|
||||
correctMasterPointU[pointI];
|
||||
oldMasterPoints[pointI] + correctMasterPointU[pointI];
|
||||
}
|
||||
forAll(slavePointLabels, pointI)
|
||||
{
|
||||
label pointGlobalLabel = slavePointLabels[pointI];
|
||||
newPoints[pointGlobalLabel] =
|
||||
oldSlavePoints[pointI]
|
||||
+
|
||||
correctSlavePointU[pointI];
|
||||
oldSlavePoints[pointI] + correctSlavePointU[pointI];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//***** NOW FIX AND SYNCHRONISE ALL THE FACEZONE POINTS *****//
|
||||
|
||||
forAll(mesh.faceZones(), faceZoneI)
|
||||
|
@ -117,8 +115,7 @@ if(Pstream::parRun())
|
|||
{
|
||||
label procPoint =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints()[localPoint];
|
||||
globalFZnewPoints[globalPointI] =
|
||||
newPoints[procPoint];
|
||||
globalFZnewPoints[globalPointI] = newPoints[procPoint];
|
||||
pointNumProcs[globalPointI] = 1;
|
||||
}
|
||||
}
|
||||
|
@ -141,20 +138,16 @@ if(Pstream::parRun())
|
|||
forAll(globalFZnewPoints, globalPointI)
|
||||
{
|
||||
label localPoint = procToGlobalFZmap[faceZoneI][globalPointI];
|
||||
|
||||
procFZnewPoints[localPoint] =
|
||||
globalFZnewPoints[globalPointI];
|
||||
procFZnewPoints[localPoint] = globalFZnewPoints[globalPointI];
|
||||
}
|
||||
|
||||
//- now fix the newPoints points on the globalFaceZones
|
||||
labelList procFZmeshPoints =
|
||||
mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
labelList procFZmeshPoints = mesh.faceZones()[faceZoneI]().meshPoints();
|
||||
|
||||
forAll(procFZmeshPoints, pointI)
|
||||
{
|
||||
label procPoint = procFZmeshPoints[pointI];
|
||||
newPoints[procPoint] =
|
||||
procFZnewPoints[pointI];
|
||||
newPoints[procPoint] = procFZnewPoints[pointI];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -70,7 +70,9 @@ if(Pstream::parRun())
|
|||
|
||||
//- set all slave points to zero because only the master order is used
|
||||
if(!Pstream::master())
|
||||
{
|
||||
globalFZpoints *= 0.0;
|
||||
}
|
||||
|
||||
//- pass points to all procs
|
||||
reduce(globalFZpoints, sumOp<vectorField>());
|
||||
|
@ -93,8 +95,6 @@ if(Pstream::parRun())
|
|||
}
|
||||
}
|
||||
}
|
||||
//- procToGlobalFZmap now contains the local FZpoint label for each
|
||||
//- global FZ point label - for each faceZone
|
||||
|
||||
//- check what points are on the current proc patch
|
||||
pointOnLocalProcPatch[faceZoneI].setSize(globalFZpoints.size(), 0);
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -17,8 +17,7 @@ if(divSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradU =
|
||||
((I - n*n)&fvc::interpolate(gradU));
|
||||
surfaceTensorField shearGradU = ((I - n*n)&fvc::interpolate(gradU));
|
||||
|
||||
divSigmaExp = fvc::div
|
||||
(
|
||||
|
|
|
@ -1,7 +1,13 @@
|
|||
//- how explicit component of sigma is to be calculated
|
||||
word divSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divSigmaExp"));
|
||||
Info << "Selecting divSigmaExp calculation method " << divSigmaExpMethod << endl;
|
||||
if(divSigmaExpMethod != "standard" && divSigmaExpMethod != "surface" && divSigmaExpMethod != "decompose" && divSigmaExpMethod != "laplacian")
|
||||
if
|
||||
(
|
||||
divSigmaExpMethod != "standard"
|
||||
&& divSigmaExpMethod != "surface"
|
||||
&& divSigmaExpMethod != "decompose"
|
||||
&& divSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divSigmaExp method " << divSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -17,13 +17,13 @@ if(divDSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divDSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradDU =
|
||||
((I - n*n)&fvc::interpolate(gradDU));
|
||||
surfaceTensorField shearGradDU = ((I - n*n)&fvc::interpolate(gradDU));
|
||||
|
||||
divDSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(DU)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradDU&(I - n*n))*n
|
||||
+ muf*(shearGradDU&n)
|
||||
|
|
|
@ -1,7 +1,13 @@
|
|||
//- how explicit component of sigma is to be calculated
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << "Selecting divDSigmaExp calculation method " << divDSigmaExpMethod << endl;
|
||||
if(divDSigmaExpMethod != "standard" && divDSigmaExpMethod != "surface" && divDSigmaExpMethod != "decompose" && divDSigmaExpMethod != "laplacian")
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -7,9 +7,10 @@ if(leftPatchID == -1)
|
|||
}
|
||||
|
||||
//- calculate force in x direction on leftClamp patch
|
||||
scalar leftForce = gSum(
|
||||
vector(1, 0, 0) &
|
||||
(mesh.boundary()[leftPatchID].Sf() & sigma.boundaryField()[leftPatchID])
|
||||
scalar leftForce = gSum
|
||||
(
|
||||
vector(1, 0, 0)
|
||||
& (mesh.boundary()[leftPatchID].Sf() & sigma.boundaryField()[leftPatchID])
|
||||
);
|
||||
|
||||
//- patchIntegrate utility integrates it this way but this is worng because the sigma tensor should
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
{
|
||||
forAll(mesh.boundary(), patchID)
|
||||
{
|
||||
if(U.boundaryField()[patchID].type()
|
||||
if
|
||||
(
|
||||
U.boundaryField()[patchID].type()
|
||||
== solidDirectionMixedFvPatchVectorField::typeName
|
||||
)
|
||||
{
|
||||
|
|
|
@ -83,7 +83,8 @@ int main(int argc, char *argv[])
|
|||
fvm::d2dt2(rho, U)
|
||||
==
|
||||
fvm::laplacian(2*mu + lambda, U, "laplacian(DU,U)")
|
||||
+ fvc::div(
|
||||
+ fvc::div
|
||||
(
|
||||
- ( (mu + lambda) * gradU )
|
||||
+ ( mu * gradU.T() )
|
||||
+ ( mu * (gradU & gradU.T()) )
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(U, pointU);
|
||||
|
||||
const vectorField& pointUI =
|
||||
pointU.internalField();
|
||||
const vectorField& pointUI = pointU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -17,13 +17,13 @@ if(divDSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divDSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradDU =
|
||||
((I - n*n)&fvc::interpolate(gradDU));
|
||||
surfaceTensorField shearGradDU = ((I - n*n)&fvc::interpolate(gradDU));
|
||||
|
||||
divDSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(DU)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradDU&(I - n*n))*n
|
||||
+ muf*(shearGradDU&n)
|
||||
|
|
|
@ -69,5 +69,4 @@ FieldField<Field, vector> extraVecs(ptc.size());
|
|||
|
||||
curExtraVectors.setSize(nFacesAroundPoint);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -91,7 +91,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
|
||||
// Update coupled boundaries
|
||||
// Work-around for cyclic parallels.
|
||||
/*if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
/*
|
||||
if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
{
|
||||
forAll (volPointSumWeights.boundaryField(), patchI)
|
||||
{
|
||||
|
@ -111,7 +112,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
// Re-scale the weights for the current point
|
||||
forAll (ptc, pointI)
|
||||
|
|
|
@ -38,8 +38,7 @@ if(min(J.internalField()) > 0)
|
|||
//- that class no longer works
|
||||
# include "performEdgeCorrectedVolPointInterpolation.H"
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- see the effect of correctBCs
|
||||
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -7,7 +7,8 @@ pointVectorField& pf = pointDU;
|
|||
|
||||
// Do the correction
|
||||
//GeometricField<Type, pointPatchField, pointMesh> pfCorr
|
||||
/*pointVectorField pfCorr
|
||||
/*
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
|
@ -23,7 +24,8 @@ pointVectorField& pf = pointDU;
|
|||
//dimensioned<Type>("zero", pf.dimensions(), pTraits<Type>::zero),
|
||||
dimensionedVector("zero", pf.dimensions(), vector::zero),
|
||||
pf.boundaryField().types()
|
||||
);*/
|
||||
);
|
||||
*/
|
||||
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
|
@ -96,21 +98,25 @@ forAll (ptc, pointI)
|
|||
}
|
||||
|
||||
// Update coupled boundaries
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].initAddField();
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].addField(pfCorr.internalField());
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
//Info << "pfCorr: " << pfCorr << endl;
|
||||
|
|
|
@ -1,10 +1,13 @@
|
|||
//- the method used to calculate the explicit component of sigma
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << "Calculation of divDSigmaExp method: " << divDSigmaExpMethod << endl;
|
||||
if(divDSigmaExpMethod != "standard"
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian")
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -17,13 +17,13 @@ if(divDSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divDSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradDU =
|
||||
((I - n*n)&fvc::interpolate(gradDU));
|
||||
surfaceTensorField shearGradDU = ((I - n*n)&fvc::interpolate(gradDU));
|
||||
|
||||
divDSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(DU)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradDU&(I - n*n))*n
|
||||
+ muf*(shearGradDU&n)
|
||||
|
|
|
@ -69,5 +69,4 @@ FieldField<Field, vector> extraVecs(ptc.size());
|
|||
|
||||
curExtraVectors.setSize(nFacesAroundPoint);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -91,7 +91,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
|
||||
// Update coupled boundaries
|
||||
// Work-around for cyclic parallels.
|
||||
/*if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
/*
|
||||
if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
|
||||
{
|
||||
forAll (volPointSumWeights.boundaryField(), patchI)
|
||||
{
|
||||
|
@ -111,7 +112,8 @@ FieldField<Field, scalar> w(ptc.size());
|
|||
);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
// Re-scale the weights for the current point
|
||||
forAll (ptc, pointI)
|
||||
|
|
|
@ -41,8 +41,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
//pointDU.write();
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
// Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = mesh.allPoints();
|
||||
|
|
|
@ -7,7 +7,8 @@ pointVectorField& pf = pointDU;
|
|||
|
||||
// Do the correction
|
||||
//GeometricField<Type, pointPatchField, pointMesh> pfCorr
|
||||
/*pointVectorField pfCorr
|
||||
/*
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
|
@ -23,7 +24,8 @@ pointVectorField& pf = pointDU;
|
|||
//dimensioned<Type>("zero", pf.dimensions(), pTraits<Type>::zero),
|
||||
dimensionedVector("zero", pf.dimensions(), vector::zero),
|
||||
pf.boundaryField().types()
|
||||
);*/
|
||||
);
|
||||
*/
|
||||
|
||||
pointVectorField pfCorr
|
||||
(
|
||||
|
@ -96,21 +98,25 @@ forAll (ptc, pointI)
|
|||
}
|
||||
|
||||
// Update coupled boundaries
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].initAddField();
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
/*forAll (pfCorr.boundaryField(), patchI)
|
||||
/*
|
||||
forAll (pfCorr.boundaryField(), patchI)
|
||||
{
|
||||
if (pfCorr.boundaryField()[patchI].coupled())
|
||||
{
|
||||
pfCorr.boundaryField()[patchI].addField(pfCorr.internalField());
|
||||
}
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
//Info << "pfCorr: " << pfCorr << endl;
|
||||
|
|
|
@ -1,10 +1,13 @@
|
|||
//- the method used to calculate the explicit component of sigma
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << "Calculation of divDSigmaExp method: " << divDSigmaExpMethod << endl;
|
||||
if(divDSigmaExpMethod != "standard"
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian")
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -17,13 +17,13 @@ if(divDSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divDSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradU =
|
||||
((I - n*n)&fvc::interpolate(gradDU));
|
||||
surfaceTensorField shearGradU = ((I - n*n)&fvc::interpolate(gradDU));
|
||||
|
||||
divDSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(U)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradU&(I - n*n))*n
|
||||
+ muf*(shearGradU&n)
|
||||
|
|
|
@ -1,7 +1,13 @@
|
|||
//- how explicit component of sigma is to be calculated
|
||||
word divDSigmaExpMethod(mesh.solutionDict().subDict("stressedFoam").lookup("divDSigmaExp"));
|
||||
Info << "Selecting divDSigmaExp calculation method " << divDSigmaExpMethod << endl;
|
||||
if(divDSigmaExpMethod != "standard" && divDSigmaExpMethod != "surface" && divDSigmaExpMethod != "decompose" && divDSigmaExpMethod != "laplacian")
|
||||
if
|
||||
(
|
||||
divDSigmaExpMethod != "standard"
|
||||
&& divDSigmaExpMethod != "surface"
|
||||
&& divDSigmaExpMethod != "decompose"
|
||||
&& divDSigmaExpMethod != "laplacian"
|
||||
)
|
||||
{
|
||||
FatalError << "divDSigmaExp method " << divDSigmaExpMethod << " not found!" << nl
|
||||
<< "valid methods are:\nstandard\nsurface\ndecompose\nlaplacian"
|
||||
|
|
|
@ -17,13 +17,13 @@ if(divSigmaExpMethod == "standard")
|
|||
}
|
||||
else if(divSigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradU =
|
||||
((I - n*n)&fvc::interpolate(gradU));
|
||||
surfaceTensorField shearGradU = ((I - n*n)&fvc::interpolate(gradU));
|
||||
|
||||
divSigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(U)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradU&(I - n*n))*n
|
||||
+ muf*(shearGradU&n)
|
||||
|
|
|
@ -17,13 +17,13 @@ if(sigmaExpMethod == "standard")
|
|||
}
|
||||
else if(sigmaExpMethod == "decompose")
|
||||
{
|
||||
surfaceTensorField shearGradU =
|
||||
((I - n*n)&fvc::interpolate(gradU));
|
||||
surfaceTensorField shearGradU = ((I - n*n)&fvc::interpolate(gradU));
|
||||
|
||||
sigmaExp = fvc::div
|
||||
(
|
||||
mesh.magSf()
|
||||
*(
|
||||
*
|
||||
(
|
||||
- (muf + lambdaf)*(fvc::snGrad(U)&(I - n*n))
|
||||
+ lambdaf*tr(shearGradU&(I - n*n))*n
|
||||
+ muf*(shearGradU&n)
|
||||
|
|
|
@ -13,7 +13,8 @@
|
|||
}
|
||||
|
||||
//- update patch
|
||||
if(
|
||||
if
|
||||
(
|
||||
U.boundaryField()[patchID].type()
|
||||
== fixedValueFvPatchVectorField::typeName
|
||||
)
|
||||
|
@ -27,7 +28,6 @@
|
|||
<< " to " << disp
|
||||
<< endl;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
SeriousError << "Loading Patch " << patchName << " is type "
|
||||
|
|
|
@ -103,7 +103,7 @@
|
|||
|
||||
word solidDdtScheme
|
||||
(
|
||||
stressMesh.ddtScheme("ddt(" + DU.name() +')')
|
||||
stressMesh.schemesDict().ddtScheme("ddt(" + DU.name() +')')
|
||||
);
|
||||
|
||||
// if
|
||||
|
|
|
@ -31,8 +31,7 @@ if(min(J.internalField()) > 0)
|
|||
|
||||
pointInterpolation.interpolate(DU, pointDU);
|
||||
|
||||
const vectorField& pointDUI =
|
||||
pointDU.internalField();
|
||||
const vectorField& pointDUI = pointDU.internalField();
|
||||
|
||||
//- Move mesh
|
||||
vectorField newPoints = stressMesh.allPoints();
|
||||
|
|
|
@ -68,23 +68,28 @@ Foam::contactPatchPair::contactPatchPair
|
|||
// ),
|
||||
// vectorField(cp_.mesh().boundaryMesh()[slavePatch_.index()].pointNormals().size(), vector::zero)
|
||||
// ),
|
||||
slavePointPenetration_(
|
||||
slavePointPenetration_
|
||||
(
|
||||
cp_.mesh().boundaryMesh()[slavePatch_.index()].pointNormals().size(),
|
||||
0.0
|
||||
),
|
||||
masterPointPenetration_(
|
||||
masterPointPenetration_
|
||||
(
|
||||
cp_.mesh().boundaryMesh()[masterPatch_.index()].pointNormals().size(),
|
||||
0.0
|
||||
),
|
||||
globalSlavePointPenetration_(
|
||||
globalSlavePointPenetration_
|
||||
(
|
||||
cp_.mesh().pointZones()[cp_.mesh().faceZones().findZoneID(slaveFaceZoneName_)].size(),
|
||||
0.0
|
||||
),
|
||||
globalMasterPointPenetration_(
|
||||
globalMasterPointPenetration_
|
||||
(
|
||||
cp_.mesh().pointZones()[cp_.mesh().faceZones().findZoneID(masterFaceZoneName_)].size(),
|
||||
0.0
|
||||
),
|
||||
oldTotalSlavePointForce_(
|
||||
oldTotalSlavePointForce_
|
||||
(
|
||||
cp_.mesh().boundaryMesh()[slavePatch_.index()].pointNormals().size(),
|
||||
vector::zero
|
||||
),
|
||||
|
@ -92,7 +97,8 @@ Foam::contactPatchPair::contactPatchPair
|
|||
penetrationLimit_(readScalar(dict.lookup("penetrationLimit"))),
|
||||
rigidMaster_(dict.lookup("rigidMaster")),
|
||||
interpolationMethod_(dict.lookup("interpolationMethod")),
|
||||
faceZoneMasterToSlaveInterpolator_(
|
||||
faceZoneMasterToSlaveInterpolator_
|
||||
(
|
||||
cp_.mesh().faceZones()[cp_.mesh().faceZones().findZoneID(masterFaceZoneName_)](), // from
|
||||
cp_.mesh().faceZones()[cp_.mesh().faceZones().findZoneID(slaveFaceZoneName_)](), // to zone
|
||||
alg_,
|
||||
|
|
|
@ -34,7 +34,6 @@ Description
|
|||
|
||||
void Foam::contactPatchPair::correct()
|
||||
{
|
||||
|
||||
//---------------------PRELIMINARIES---------------------------------//
|
||||
const fvMesh& mesh = cp_.mesh();
|
||||
const label& masterIndex = masterPatch_.index();
|
||||
|
@ -42,28 +41,24 @@ void Foam::contactPatchPair::correct()
|
|||
scalar maxMagSlaveTraction = 0.0;
|
||||
contactIterNum_++;
|
||||
|
||||
|
||||
//--------CALCULATE MASTER AND SLAVE PENETRATIONS----------------------//
|
||||
scalarField& globalSlavePointPenetration = globalSlavePointPenetration_;
|
||||
//scalarField& globalMasterPointPenetration = globalMasterPointPenetration_;
|
||||
|
||||
|
||||
//- tell zoneToZone that mesh has moved, so the intersection will be recalculated
|
||||
faceZoneMasterToSlaveInterpolator_.movePoints();
|
||||
//- calculate intersection distances
|
||||
//- this is the slowest part of the contact correction especially when the slavePatch
|
||||
//- has many points. parallelisation of this step should be considered.
|
||||
globalSlavePointPenetration
|
||||
= faceZoneMasterToSlaveInterpolator_.pointDistanceToIntersection();
|
||||
|
||||
//globalMasterPointPenetration
|
||||
//= faceZoneSlaveToMasterInterpolator.pointDistanceToIntersection();
|
||||
globalSlavePointPenetration =
|
||||
faceZoneMasterToSlaveInterpolator_.pointDistanceToIntersection();
|
||||
|
||||
//globalMasterPointPenetration =
|
||||
// faceZoneSlaveToMasterInterpolator.pointDistanceToIntersection();
|
||||
|
||||
scalarField& slavePointPenetration = slavePointPenetration_;
|
||||
//scalarField& masterPointPenetration = masterPointPenetration_;
|
||||
|
||||
|
||||
forAll(slavePointPenetration, pointI)
|
||||
{
|
||||
//label pointGlobalLabel = slavePointLabels[pointI];
|
||||
|
@ -95,8 +90,6 @@ void Foam::contactPatchPair::correct()
|
|||
// }
|
||||
|
||||
|
||||
|
||||
|
||||
//------CALCULATE SLAVE VERTEX FORCES BASED ON PENETRATION-------------//
|
||||
//- approximation of penaltyFactor
|
||||
//- this should be automatic, these numbers don't really matter, the scaleFactor
|
||||
|
@ -111,9 +104,9 @@ void Foam::contactPatchPair::correct()
|
|||
const vectorField& slavePointNormals = mesh.boundaryMesh()[slaveIndex].pointNormals();
|
||||
vectorField& totalSlavePointForce = totalSlavePointForce_;
|
||||
|
||||
int numSlaveContactPoints = 0;
|
||||
int numSlaveContactPointsReducing = 0;
|
||||
int numSlavesUpdated = 0;
|
||||
label numSlaveContactPoints = 0;
|
||||
label numSlaveContactPointsReducing = 0;
|
||||
label numSlavesUpdated = 0;
|
||||
|
||||
//- so the procs know the global min
|
||||
//scalar minSlavePointPenetration = gMin(slavePointPenetration);
|
||||
|
@ -134,7 +127,9 @@ void Foam::contactPatchPair::correct()
|
|||
numSlavesUpdated++;
|
||||
//- force is linearly dependent on penetration
|
||||
totalSlavePointForce[pointI] +=
|
||||
( slavePointNormals[pointI] * penaltyFactor * slavePointPenetration[pointI] );
|
||||
(
|
||||
slavePointNormals[pointI]*penaltyFactor*slavePointPenetration[pointI]
|
||||
);
|
||||
}
|
||||
//- else if point is within contact tolerance then don't add any more force
|
||||
else if(slavePointPenetration[pointI] < 0.0)
|
||||
|
@ -151,7 +146,9 @@ void Foam::contactPatchPair::correct()
|
|||
// point forces must be reduced slowly
|
||||
|
||||
totalSlavePointForce[pointI] +=
|
||||
( slavePointNormals[pointI] * returnPenaltyFactor * slavePointPenetration[pointI] );
|
||||
(
|
||||
slavePointNormals[pointI]*returnPenaltyFactor*slavePointPenetration[pointI]
|
||||
);
|
||||
|
||||
// if a tensile force develops
|
||||
if((totalSlavePointForce[pointI] & slavePointNormals[pointI]) > 0.0)
|
||||
|
@ -185,10 +182,10 @@ void Foam::contactPatchPair::correct()
|
|||
//- for a deformable master
|
||||
if(!rigidMaster_)
|
||||
{
|
||||
const label slaveFaceZoneID
|
||||
= mesh.faceZones().findZoneID(slaveFaceZoneName_);
|
||||
const label slavePatchStart
|
||||
= mesh.boundaryMesh()[slaveIndex].start();
|
||||
const label slaveFaceZoneID =
|
||||
mesh.faceZones().findZoneID(slaveFaceZoneName_);
|
||||
const label slavePatchStart =
|
||||
mesh.boundaryMesh()[slaveIndex].start();
|
||||
|
||||
scalarField globalSlavePressure
|
||||
(
|
||||
|
@ -231,14 +228,13 @@ void Foam::contactPatchPair::correct()
|
|||
);
|
||||
}
|
||||
|
||||
|
||||
//- exchange parallel data
|
||||
reduce(globalMasterPressure, maxOp<scalarField>());
|
||||
|
||||
//Pout << "The max global master trac is " << max(globalMasterPressure) << endl;
|
||||
|
||||
const label masterPatchStart
|
||||
= mesh.boundaryMesh()[masterIndex].start();
|
||||
const label masterPatchStart =
|
||||
mesh.boundaryMesh()[masterIndex].start();
|
||||
|
||||
scalarField masterPressure(mesh.boundaryMesh()[masterIndex].size(), 0.0);
|
||||
|
||||
|
|
|
@ -147,8 +147,6 @@ void contactProblem::correct()
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//**********************CONTACT AREA FUNCTION***********************************//
|
||||
tmp<volScalarField> contactProblem::contactArea() const
|
||||
{
|
||||
|
@ -189,19 +187,19 @@ tmp<volScalarField> contactProblem::contactArea() const
|
|||
label slaveIndex = contacts[contactI].slavePatch().index();
|
||||
scalarField masterFrac = contacts[contactI].masterTouchFraction();
|
||||
scalarField slaveFrac = contacts[contactI].slaveTouchFraction();
|
||||
scalar contactAreaMaster =
|
||||
gSum
|
||||
scalar contactAreaMaster = gSum
|
||||
(
|
||||
masterFrac *
|
||||
mag(
|
||||
mag
|
||||
(
|
||||
mesh().Sf().boundaryField()[masterIndex]
|
||||
)
|
||||
);
|
||||
scalar contactAreaSlave =
|
||||
gSum
|
||||
scalar contactAreaSlave = gSum
|
||||
(
|
||||
slaveFrac *
|
||||
mag(
|
||||
mag
|
||||
(
|
||||
mesh().Sf().boundaryField()[slaveIndex]
|
||||
)
|
||||
);
|
||||
|
@ -275,8 +273,6 @@ void contactProblem::contactPointForce(pointVectorField& cPointForce)
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
tmp<volScalarField> contactProblem::contactPressure() const
|
||||
{
|
||||
tmp<volScalarField> tcPress
|
||||
|
|
|
@ -312,7 +312,6 @@ void plasticityModel::correct()
|
|||
{
|
||||
betaPatch[faceI] = 0;
|
||||
curDEpsEPred = DEpsilonPatch[faceI];
|
||||
|
||||
if
|
||||
(
|
||||
(DEpsilonEqPatch[faceI] >= 0)
|
||||
|
@ -448,7 +447,6 @@ void plasticityModel::updateYieldStress()
|
|||
|
||||
bool plasticityModel::read()
|
||||
{
|
||||
|
||||
if (regIOobject::read())
|
||||
{
|
||||
return true;
|
||||
|
|
|
@ -37,13 +37,15 @@ solvers
|
|||
}
|
||||
|
||||
|
||||
/* U
|
||||
/*
|
||||
U
|
||||
{
|
||||
solver PCG;
|
||||
preconditioner DIC;
|
||||
tolerance 1e-09;
|
||||
relTol 0.99;
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
stressedFoam
|
||||
|
|
|
@ -31,7 +31,6 @@ boundaryField
|
|||
|
||||
cohesive
|
||||
{
|
||||
|
||||
type cohesiveZone;
|
||||
cohesiveLaw Dugdale;
|
||||
relaxationFactor 0.9;
|
||||
|
|
|
@ -273,6 +273,7 @@ int main(int argc, char *argv[])
|
|||
mesh,
|
||||
dimensionedScalar("zero", dimless, 0.0)
|
||||
);
|
||||
|
||||
forAll(theta.internalField(), celli)
|
||||
{
|
||||
const scalar& x = mesh.C().internalField()[celli][vector::X];
|
||||
|
@ -311,9 +312,12 @@ int main(int argc, char *argv[])
|
|||
{
|
||||
const scalar& t = theta.internalField()[celli];
|
||||
|
||||
rotMat.internalField()[celli] = tensor(::cos(t), ::sin(t), 0,
|
||||
rotMat.internalField()[celli] = tensor
|
||||
(
|
||||
::cos(t), ::sin(t), 0,
|
||||
-::sin(t), ::cos(t), 0,
|
||||
0, 0, 1);
|
||||
0, 0, 1
|
||||
);
|
||||
}
|
||||
|
||||
forAll(rotMat.boundaryField(), patchi)
|
||||
|
@ -322,9 +326,12 @@ int main(int argc, char *argv[])
|
|||
{
|
||||
const scalar& t = theta.boundaryField()[patchi][facei];
|
||||
|
||||
rotMat.boundaryField()[patchi][facei] = tensor(::cos(t), ::sin(t), 0,
|
||||
rotMat.boundaryField()[patchi][facei] = tensor
|
||||
(
|
||||
::cos(t), ::sin(t), 0,
|
||||
-::sin(t), ::cos(t), 0,
|
||||
0, 0, 1);
|
||||
0, 0, 1
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -350,9 +357,7 @@ int main(int argc, char *argv[])
|
|||
|
||||
const tensor& rot = rotMat.internalField()[celli];
|
||||
|
||||
symmTensor sigmaCart(r, 0, 0,
|
||||
t, 0,
|
||||
z);
|
||||
symmTensor sigmaCart(r, 0, 0, t, 0, z);
|
||||
|
||||
sigma.internalField()[celli] =
|
||||
symm(rot.T() & sigmaCart & rot);
|
||||
|
@ -374,16 +379,12 @@ int main(int argc, char *argv[])
|
|||
|
||||
const tensor& rot = rotMat.boundaryField()[patchi][facei];
|
||||
|
||||
symmTensor sigmaCart(r, 0, 0,
|
||||
t, 0,
|
||||
z);
|
||||
symmTensor sigmaCart(r, 0, 0, t, 0, z);
|
||||
sigma.boundaryField()[patchi][facei] =
|
||||
symm(rot.T() & sigmaCart & rot);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Info << "\nWriting analytical sigma tensor" << endl;
|
||||
sigma.write();
|
||||
|
||||
|
|
|
@ -110,14 +110,10 @@ int main(int argc, char *argv[])
|
|||
label refFace = cells[celli][0];
|
||||
|
||||
//- insert first four abaqusCellPoints
|
||||
abaqusCellPoints[celli][0]
|
||||
= (faces[refFace][3] + 1);
|
||||
abaqusCellPoints[celli][1]
|
||||
= (faces[refFace][2] + 1);
|
||||
abaqusCellPoints[celli][2]
|
||||
= (faces[refFace][1] + 1);
|
||||
abaqusCellPoints[celli][3]
|
||||
= (faces[refFace][0] + 1);
|
||||
abaqusCellPoints[celli][0] = (faces[refFace][3] + 1);
|
||||
abaqusCellPoints[celli][1] = (faces[refFace][2] + 1);
|
||||
abaqusCellPoints[celli][2] = (faces[refFace][1] + 1);
|
||||
abaqusCellPoints[celli][3] = (faces[refFace][0] + 1);
|
||||
|
||||
//- now find the opposite face in the cell
|
||||
//Info << "Finding oppFace" << endl << endl;
|
||||
|
@ -181,29 +177,25 @@ int main(int argc, char *argv[])
|
|||
label globalPpi = oppFacePPs[oppFacePointi];
|
||||
if(globalPpi == faces[refFace][0])
|
||||
{
|
||||
abaqusCellPoints[celli][7]
|
||||
= globalPointi + 1;
|
||||
abaqusCellPoints[celli][7] = globalPointi + 1;
|
||||
ppFound = true;
|
||||
break;
|
||||
}
|
||||
else if(globalPpi == faces[refFace][1])
|
||||
{
|
||||
abaqusCellPoints[celli][6]
|
||||
= globalPointi + 1;
|
||||
abaqusCellPoints[celli][6] = globalPointi + 1;
|
||||
ppFound = true;
|
||||
break;
|
||||
}
|
||||
else if(globalPpi == faces[refFace][2])
|
||||
{
|
||||
abaqusCellPoints[celli][5]
|
||||
= globalPointi + 1;
|
||||
abaqusCellPoints[celli][5] = globalPointi + 1;
|
||||
ppFound = true;
|
||||
break;
|
||||
}
|
||||
else if(globalPpi == faces[refFace][3])
|
||||
{
|
||||
abaqusCellPoints[celli][4]
|
||||
= globalPointi + 1;
|
||||
abaqusCellPoints[celli][4] = globalPointi + 1;
|
||||
ppFound = true;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -78,4 +78,3 @@
|
|||
|
||||
DSigmaCorr -= sigma;
|
||||
}
|
||||
|
||||
|
|
|
@ -110,7 +110,6 @@ int main(int argc, char *argv[])
|
|||
gradDU = fvc::grad(DU);
|
||||
|
||||
# include "calculateDEpsilonDSigma.H"
|
||||
|
||||
}
|
||||
while
|
||||
(
|
||||
|
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
@ -112,12 +112,6 @@ Foam::axisCoordinateRotation::axisCoordinateRotation
|
|||
scalar theta = readScalar(dict.lookup("theta"));
|
||||
scalar psi = readScalar(dict.lookup("psi"));
|
||||
|
||||
bool inDegrees = true;
|
||||
if (dict.found("degrees"))
|
||||
{
|
||||
inDegrees = Switch(dict.lookup("degrees"));
|
||||
}
|
||||
|
||||
calcTransform
|
||||
(
|
||||
phi,
|
||||
|
|
|
@ -55,7 +55,7 @@ modified by someone else and passed on, the recipients should know
|
|||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
|
@ -111,7 +111,7 @@ modification follow. Pay close attention to the difference between a
|
|||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
|
@ -158,7 +158,7 @@ Library.
|
|||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
|
@ -216,7 +216,7 @@ instead of to this License. (If a newer version than version 2 of the
|
|||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
@ -267,7 +267,7 @@ Library will still fall under Section 6.)
|
|||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
|
@ -329,7 +329,7 @@ restrictions of other proprietary libraries that do not normally
|
|||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
|
@ -370,7 +370,7 @@ subject to these terms and conditions. You may not impose any further
|
|||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
|
@ -422,7 +422,7 @@ conditions either of that version or of any later version published by
|
|||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
|
@ -456,7 +456,7 @@ SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
|
|
|
@ -27,6 +27,7 @@ License
|
|||
#include "dimensionedScalar.H"
|
||||
#include "equationReader.H"
|
||||
#include "equationOperation.H"
|
||||
#include "error.H"
|
||||
//#include "equationOperationList.H"
|
||||
|
||||
class dimensionedScalar;
|
||||
|
@ -396,6 +397,16 @@ Foam::word Foam::equationOperation::opName
|
|||
return "min";
|
||||
case otstabilise:
|
||||
return "stabilise";
|
||||
default:
|
||||
FatalErrorIn
|
||||
(
|
||||
"Foam::word Foam::equationOperation::opName"
|
||||
"(const Foam::equationOperation::operationType& op)"
|
||||
)
|
||||
<< "invalid operation"
|
||||
<< exit(FatalError);
|
||||
|
||||
return "invalid";
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -423,6 +434,16 @@ Foam::word Foam::equationOperation::sourceName
|
|||
return "equation";
|
||||
case slstorage:
|
||||
return "memory";
|
||||
default:
|
||||
FatalErrorIn
|
||||
(
|
||||
"Foam::word Foam::equationOperation::opName"
|
||||
"(const Foam::equationOperation::operationType& op)"
|
||||
)
|
||||
<< "invalid source"
|
||||
<< exit(FatalError);
|
||||
|
||||
return "invalid";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -81,7 +81,6 @@ Foam::tmp<Foam::scalarField> Foam::mixingPlaneGAMGInterface::agglomerateCoeffs
|
|||
// AMG agglomeration missing
|
||||
notImplemented("mixingPlaneGAMGInterface::agglomerateCoeffs");
|
||||
tmp<scalarField> tcoarseCoeffs(new scalarField(size(), 0.0));
|
||||
scalarField& coarseCoeffs = tcoarseCoeffs();
|
||||
|
||||
return tcoarseCoeffs;
|
||||
}
|
||||
|
|
|
@ -102,7 +102,6 @@ void Foam::polyMesh::initMesh()
|
|||
nCells++;
|
||||
|
||||
label nUsedFaces = 0;
|
||||
label nIntFaces = 0;
|
||||
|
||||
// Use patch info if provided, use all faces otherwise
|
||||
if (boundary_.size())
|
||||
|
@ -110,13 +109,11 @@ void Foam::polyMesh::initMesh()
|
|||
nUsedFaces =
|
||||
boundary_[boundary_.size() - 1].start()
|
||||
+ boundary_[boundary_.size() - 1].size();
|
||||
nIntFaces = boundary_[0].start();
|
||||
}
|
||||
else
|
||||
{
|
||||
// No patch info. Assume all faces are used.
|
||||
nUsedFaces = owner_.size();
|
||||
nIntFaces = neighbour_.size();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -57,7 +57,8 @@ bool dynamicTopoFvMesh::meshQuality
|
|||
label nCells = 0, minCell = -1;
|
||||
scalar maxQuality = -GREAT;
|
||||
scalar minQuality = GREAT;
|
||||
scalar cQuality, meanQuality = 0.0;
|
||||
scalar cQuality = 0.0;
|
||||
scalar meanQuality = 0.0;
|
||||
|
||||
// Track slivers
|
||||
bool sliversAbsent = true;
|
||||
|
@ -1682,7 +1683,8 @@ bool dynamicTopoFvMesh::checkCollapse
|
|||
) const
|
||||
{
|
||||
label faceIndex = -1;
|
||||
scalar cQuality = 0.0, oldVolume = 0.0;
|
||||
scalar cQuality = 0.0;
|
||||
scalar oldVolume = 0.0;
|
||||
const cell& cellToCheck = cells_[cellIndex];
|
||||
|
||||
// Look for a face that doesn't contain 'pointIndex'
|
||||
|
|
|
@ -180,7 +180,8 @@ void eMesh::calcEdgePoints() const
|
|||
// NOTE: Will work only on tetrahedral meshes!
|
||||
|
||||
bool found;
|
||||
label faceIndex = -1, cellIndex = -1;
|
||||
label faceIndex = -1
|
||||
label cellIndex = -1;
|
||||
const labelList& owner = mesh_.faceOwner();
|
||||
const labelList& neighbour = mesh_.faceNeighbour();
|
||||
const cellList& cells = mesh_.cells();
|
||||
|
|
|
@ -126,16 +126,14 @@ Foam::tmp<Foam::scalarField> Foam::cellQuality::skewness() const
|
|||
|
||||
forAll (nei, faceI)
|
||||
{
|
||||
scalar dOwn =
|
||||
mag
|
||||
scalar dOwn = mag
|
||||
(
|
||||
(faceCtrs[faceI] - cellCtrs[own[faceI]])
|
||||
&areas[faceI]
|
||||
)
|
||||
/mag(areas[faceI]);
|
||||
|
||||
scalar dNei =
|
||||
mag
|
||||
scalar dNei = mag
|
||||
(
|
||||
(cellCtrs[nei[faceI]] - faceCtrs[faceI])
|
||||
&areas[faceI]
|
||||
|
@ -176,8 +174,8 @@ Foam::tmp<Foam::scalarField> Foam::cellQuality::skewness() const
|
|||
+ ((faceCentres[faceI] - cellCtrs[faceCells[faceI]])&n)*n;
|
||||
|
||||
scalar skewness =
|
||||
mag(faceCentres[faceI] - faceIntersection)/
|
||||
(
|
||||
mag(faceCentres[faceI] - faceIntersection)
|
||||
/(
|
||||
mag(faceCentres[faceI] - cellCtrs[faceCells[faceI]])
|
||||
+ VSMALL
|
||||
);
|
||||
|
@ -273,16 +271,14 @@ Foam::tmp<Foam::scalarField> Foam::cellQuality::faceSkewness() const
|
|||
|
||||
forAll (nei, faceI)
|
||||
{
|
||||
scalar dOwn =
|
||||
mag
|
||||
scalar dOwn = mag
|
||||
(
|
||||
(faceCtrs[faceI] - cellCtrs[own[faceI]])
|
||||
&areas[faceI]
|
||||
)
|
||||
/mag(areas[faceI]);
|
||||
|
||||
scalar dNei =
|
||||
mag
|
||||
scalar dNei = mag
|
||||
(
|
||||
(cellCtrs[nei[faceI]] - faceCtrs[faceI])
|
||||
&areas[faceI]
|
||||
|
@ -322,8 +318,8 @@ Foam::tmp<Foam::scalarField> Foam::cellQuality::faceSkewness() const
|
|||
+ ((faceCentres[faceI] - cellCtrs[faceCells[faceI]])&n)*n;
|
||||
|
||||
result[globalFaceI++] =
|
||||
mag(faceCentres[faceI] - faceIntersection)/
|
||||
(
|
||||
mag(faceCentres[faceI] - faceIntersection)
|
||||
/(
|
||||
mag(faceCentres[faceI] - cellCtrs[faceCells[faceI]])
|
||||
+ VSMALL
|
||||
);
|
||||
|
|
|
@ -14,13 +14,10 @@
|
|||
|
||||
if(valves_[valveI].curLift() >= valves_[valveI].deformationLift())
|
||||
{
|
||||
bool isMoving(false);
|
||||
|
||||
if(mag(valves_[valveI].curVelocity()) > 0)
|
||||
{
|
||||
Info<< "Valve n. " << valveI << " is moving with velocity = "
|
||||
<< valves_[valveI].curVelocity() << endl;
|
||||
isMoving = true;
|
||||
}
|
||||
|
||||
Info<< "Valve displacement for valve " << valveI << " = "
|
||||
|
|
|
@ -94,7 +94,6 @@ void Foam::layerAR::addZonesAndModifiers()
|
|||
|
||||
bool foundAtLeastOne = false;
|
||||
scalar zHigher = GREAT;
|
||||
scalar zLower = GREAT;
|
||||
scalar dh = GREAT;
|
||||
scalar dl = GREAT;
|
||||
|
||||
|
@ -108,7 +107,6 @@ void Foam::layerAR::addZonesAndModifiers()
|
|||
{
|
||||
if (zPistV - zc > 0 && zPistV - zc < dl)
|
||||
{
|
||||
zLower = zc;
|
||||
dl = zPistV - zc;
|
||||
}
|
||||
|
||||
|
|
|
@ -95,7 +95,6 @@ void Foam::layerARGambit::addZonesAndModifiers()
|
|||
|
||||
bool foundAtLeastOne = false;
|
||||
scalar zHigher = GREAT;
|
||||
scalar zLower = GREAT;
|
||||
scalar dh = GREAT;
|
||||
scalar dl = GREAT;
|
||||
|
||||
|
@ -109,7 +108,6 @@ void Foam::layerARGambit::addZonesAndModifiers()
|
|||
{
|
||||
if (zPistV - zc > 0 && zPistV - zc < dl)
|
||||
{
|
||||
zLower = zc;
|
||||
dl = zPistV - zc;
|
||||
}
|
||||
|
||||
|
|
|
@ -105,7 +105,6 @@ void Foam::simpleTwoStroke::addZonesAndModifiers()
|
|||
|
||||
bool foundAtLeastOne = false;
|
||||
scalar zHigher = GREAT;
|
||||
scalar zLower = GREAT;
|
||||
scalar dh = GREAT;
|
||||
scalar dl = GREAT;
|
||||
|
||||
|
@ -127,7 +126,6 @@ void Foam::simpleTwoStroke::addZonesAndModifiers()
|
|||
{
|
||||
if (zPistV - zc > 0 && zPistV - zc < dl)
|
||||
{
|
||||
zLower = zc;
|
||||
dl = zPistV - zc;
|
||||
}
|
||||
|
||||
|
|
|
@ -21,7 +21,6 @@
|
|||
|
||||
bool foundAtLeastOne = false;
|
||||
scalar zHigher = GREAT;
|
||||
scalar zLower = GREAT;
|
||||
scalar dh = GREAT;
|
||||
scalar dl = GREAT;
|
||||
|
||||
|
@ -35,7 +34,6 @@
|
|||
{
|
||||
if (zPistV - zc > 0 && zPistV - zc < dl)
|
||||
{
|
||||
zLower = zc;
|
||||
dl = zPistV - zc;
|
||||
}
|
||||
|
||||
|
|
|
@ -14,7 +14,6 @@
|
|||
label nMovingCells = 0;
|
||||
|
||||
label valvePatchID = valves_[i-1].poppetPatchID().index();
|
||||
const polyPatch& valveTopPatch = boundaryMesh()[valvePatchID];
|
||||
scalar minPopZ = min(boundary()[valvePatchID].patch().localPoints()).z();
|
||||
|
||||
forAll(cellCentres(),cellI)
|
||||
|
@ -60,7 +59,6 @@
|
|||
label nMovingCells = 0;
|
||||
|
||||
label valvePatchID = valves_[i-1].bottomPatchID().index();
|
||||
const polyPatch& valveBottomPatch = boundaryMesh()[valvePatchID];
|
||||
scalar maxPopZ = max(boundary()[valvePatchID].patch().localPoints()).z();
|
||||
|
||||
|
||||
|
|
|
@ -57,7 +57,6 @@ void ignitionSite::findIgnitionCells(const fvMesh& mesh)
|
|||
cellVolumes_[0] = vols[ignCell];
|
||||
|
||||
scalar minDist = GREAT;
|
||||
label nearestCell = 0;
|
||||
label nIgnCells = 1;
|
||||
|
||||
forAll(centres, celli)
|
||||
|
@ -66,7 +65,6 @@ void ignitionSite::findIgnitionCells(const fvMesh& mesh)
|
|||
|
||||
if (dist < minDist)
|
||||
{
|
||||
nearestCell = celli;
|
||||
minDist = dist;
|
||||
}
|
||||
|
||||
|
|
|
@ -38,8 +38,8 @@ namespace Foam
|
|||
{
|
||||
|
||||
// Temporary hack: useful for tracking balance of phi across interface
|
||||
void
|
||||
traceMixingPlaneFlux(
|
||||
void traceMixingPlaneFlux
|
||||
(
|
||||
volVectorField& U,
|
||||
surfaceScalarField& phi,
|
||||
scalar& masterPatchScaleFactor,
|
||||
|
@ -93,12 +93,9 @@ traceMixingPlaneFlux(
|
|||
<< mag(phiFromU - shadowPhiFromU)/(phiFromU + SMALL)*100
|
||||
<< " %"
|
||||
<< endl;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -467,7 +467,6 @@ void Foam::parcel::updateParcelProperties
|
|||
scalar oldhv = fuels.hl(pg, T(), X());
|
||||
scalar Np = N(oldDensity);
|
||||
|
||||
scalar newDensity = oldDensity;
|
||||
scalar newMass = oldMass;
|
||||
scalar newhg = oldhg;
|
||||
scalar newhv = oldhv;
|
||||
|
@ -496,7 +495,6 @@ void Foam::parcel::updateParcelProperties
|
|||
// the first time
|
||||
if (n > 1)
|
||||
{
|
||||
newDensity = fuels.rho(pg, Tnew, X());
|
||||
newMass = m();
|
||||
newhg = 0.0;
|
||||
scalarField Ynew(fuels.Y(X()));
|
||||
|
|
|
@ -119,11 +119,6 @@ void LISA::atomizeParcel
|
|||
scalar rhoFuel = fuels.rho(1.0e+5, p.T(), p.X());
|
||||
scalar nuFuel = muFuel/rhoFuel;
|
||||
|
||||
vector uDir = p.U()/mag(p.U());
|
||||
|
||||
scalar uGas = mag(vel & uDir);
|
||||
vector Ug = uGas*uDir;
|
||||
|
||||
/*
|
||||
TL
|
||||
It might be the relative velocity between Liquid and Gas, but I use the
|
||||
|
|
|
@ -124,9 +124,6 @@ void SHF::breakupParcel
|
|||
scalar reLiquid = p.Re(rhoLiquid, vel, muLiquid);
|
||||
scalar ohnesorge = sqrt(weLiquid)/(reLiquid + VSMALL);
|
||||
|
||||
vector acceleration = p.Urel(vel)/p.tMom();
|
||||
vector trajectory = p.U()/mag(p.U());
|
||||
|
||||
vector vRel = p.Urel(vel);
|
||||
|
||||
scalar weGasCorr = weGas/(1.0 + weCorrCoeff_ * ohnesorge);
|
||||
|
|
|
@ -256,9 +256,6 @@ void blobsSwirlInjector::calculateHX
|
|||
)
|
||||
);
|
||||
|
||||
scalar hOLD = -100.0;
|
||||
scalar xOLD = -100.0;
|
||||
|
||||
label i;
|
||||
|
||||
for(i=0; i<20; i++)
|
||||
|
@ -287,9 +284,6 @@ void blobsSwirlInjector::calculateHX
|
|||
|
||||
x_ = sqr(1.0 - 2.0 * h_/injectorDiameter);
|
||||
|
||||
hOLD = h_;
|
||||
xOLD = x_;
|
||||
|
||||
}
|
||||
|
||||
x_ = sqr(1.0 - 2.0 * h_/injectorDiameter);
|
||||
|
|
|
@ -2955,7 +2955,6 @@ char *timestring ( void )
|
|||
# define TIME_SIZE 29
|
||||
|
||||
const struct tm *tm;
|
||||
size_t len;
|
||||
time_t now;
|
||||
char *s;
|
||||
|
||||
|
@ -2964,7 +2963,7 @@ char *timestring ( void )
|
|||
|
||||
s = new char[TIME_SIZE];
|
||||
|
||||
len = strftime ( s, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );
|
||||
strftime ( s, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );
|
||||
|
||||
return s;
|
||||
# undef TIME_SIZE
|
||||
|
|
|
@ -179,10 +179,12 @@ void Foam::multiSolver::synchronizeParallel() const
|
|||
}
|
||||
else
|
||||
{
|
||||
// Recieve go signal
|
||||
// Receive go signal
|
||||
{
|
||||
IPstream fromMaster(Pstream::blocking, Pstream::masterNo());
|
||||
bool okayToGo(readBool(fromMaster));
|
||||
// Quenching compiler warning
|
||||
// HR, 18/Jul/2013
|
||||
readBool(fromMaster);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,6 +1,8 @@
|
|||
// Common elements in the constructor initialization list for multiSolver
|
||||
|
||||
multiDicts_(NULL),
|
||||
// Quenching compiler warning
|
||||
// HR, 18/Jul/2013
|
||||
multiDicts_(0),
|
||||
|
||||
multiSolverControl_(multiControlDict_.subDict("multiSolverControl")),
|
||||
solverDomains_(multiControlDict_.subDict("solverDomains")),
|
||||
|
|
|
@ -94,9 +94,12 @@ Foam::sixDoFRigidBodyMotionRestraints::linearAxialAngularSpring::restrain
|
|||
|
||||
refDir = rotationTensor(vector(1, 0 ,0), axis_) & vector(0, 0, 1);
|
||||
|
||||
vector oldDir = refQ_ & refDir;
|
||||
// Must update existing variables - not create new ones
|
||||
// HR 18/Jul/2013
|
||||
|
||||
vector newDir = motion.orientation() & refDir;
|
||||
oldDir = refQ_ & refDir;
|
||||
|
||||
newDir = motion.orientation() & refDir;
|
||||
}
|
||||
|
||||
// Removing any axis component from oldDir and newDir and normalising
|
||||
|
|
|
@ -96,9 +96,11 @@ Foam::sixDoFRigidBodyMotionRestraints::tabulatedAxialAngularSpring::restrain
|
|||
|
||||
refDir = rotationTensor(vector(1, 0 ,0), axis_) & vector(0, 0, 1);
|
||||
|
||||
vector oldDir = refQ_ & refDir;
|
||||
// Must update existing variables - not create new ones
|
||||
// HR 18/Jul/2013
|
||||
oldDir = refQ_ & refDir;
|
||||
|
||||
vector newDir = motion.orientation() & refDir;
|
||||
newDir = motion.orientation() & refDir;
|
||||
}
|
||||
|
||||
// Removing any axis component from oldDir and newDir and normalising
|
||||
|
|
|
@ -1 +0,0 @@
|
|||
../linux64Gcc/mplibSYSTEMOPENMPI
|
1
wmake/rules/linuxPPC64Gcc/mplibSYSTEMOPENMPI
Normal file
1
wmake/rules/linuxPPC64Gcc/mplibSYSTEMOPENMPI
Normal file
|
@ -0,0 +1 @@
|
|||
PFLAGS = -DOMPI_SKIP_MPICXX
|
Reference in a new issue