Foam::labelList Foam::metisDecomp::decompose
(
const labelListList& globalCellCells,
const pointField& cellCentres,
const scalarField& cellWeights
)
{
if (cellCentres.size() != globalCellCells.size())
{
FatalErrorIn
(
"metisDecomp::decompose"
"(const pointField&, const labelListList&, const scalarField&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cellCentres.size()
<< ")." << exit(FatalError);
}
// Make Metis CSR (Compressed Storage Format) storage
// adjncy : contains neighbours (= edges in graph)
// xadj(celli) : start of information in adjncy for celli
CompactListList<label> cellCells(globalCellCells);
// Decompose using default weights
labelList decomp;
decompose(cellCells.m(), cellCells.offsets(), cellWeights, decomp);
return decomp;
}
Foam::labelList Foam::ptscotchDecomp::decompose
(
const labelListList& globalCellCells,
const pointField& cellCentres,
const scalarField& cWeights
)
{
if (cellCentres.size() != globalCellCells.size())
{
FatalErrorIn
(
"ptscotchDecomp::decompose(const pointField&, const labelListList&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cellCentres.size()
<< ")." << exit(FatalError);
}
// // For running sequential ...
// if (Pstream::nProcs() <= 1)
// {
// return scotchDecomp(decompositionDict_, mesh)
// .decompose(globalCellCells, cellCentres, cWeights);
// }
// Make Metis CSR (Compressed Storage Format) storage
// adjncy : contains neighbours (= edges in graph)
// xadj(celli) : start of information in adjncy for celli
CompactListList<label> cellCells(globalCellCells);
// Decompose using weights
List<int> finalDecomp;
decomposeZeroDomains
(
"ptscotch",
cellCells.m(),
cellCells.offsets(),
cWeights,
finalDecomp
);
// Copy back to labelList
labelList decomp(finalDecomp.size());
forAll(decomp, i)
{
decomp[i] = finalDecomp[i];
}
return decomp;
}
void referredCell::locallyMapFaceList
(
const labelList& points,
const labelListList& sourceCellFaces
)
{
faces_.setSize(sourceCellFaces.size());
forAll(sourceCellFaces, sCF)
{
const labelList& sourceCellFace(sourceCellFaces[sCF]);
labelList& localFace(faces_[sCF]);
localFace.setSize(sourceCellFace.size());
forAll(sourceCellFace, p)
{
localFace[p] = findIndex(points, sourceCellFace[p]);
if (localFace[p] == -1)
{
FatalErrorIn("Foam::referredCell::locallyMapEdgeList")
<< "edgeList and points labelList for "
<< "referred cell do not match: "
<< nl << "points: " << points
<< nl << "faces: " << sourceCellFaces
<< abort(FatalError);
}
}
}
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
:
List<Type>(mapAddressing.size())
{
map(mapF, mapAddressing, mapWeights);
}
Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
:
List<Type>(mapAddressing.size())
{
map(tmapF, mapAddressing, mapWeights);
}
Foam::labelList Foam::scotchDecomp::decompose
(
const labelListList& globalCellCells,
const pointField& cc,
const scalarField& cWeights
)
{
if (cc.size() != globalCellCells.size())
{
FatalErrorIn
(
"scotchDecomp::decompose"
"(const labelListList&, const pointField&, const scalarField&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cc.size()
<< ")." << exit(FatalError);
}
// Make Metis CSR (Compressed Storage Format) storage
// adjncy : contains neighbours (= edges in graph)
// xadj(celli) : start of information in adjncy for celli
List<int> adjncy;
List<int> xadj;
calcCSR(globalCellCells, adjncy, xadj);
// Decompose using weights
List<int> finalDecomp;
decompose(adjncy, xadj, cWeights, finalDecomp);
// Copy back to labelList
labelList decomp(finalDecomp.size());
forAll(decomp, i)
{
decomp[i] = finalDecomp[i];
}
return decomp;
}
// Constructor from components
Foam::labelList Foam::bandCompression(const labelListList& cellCellAddressing)
{
labelList newOrder(cellCellAddressing.size());
// the business bit of the renumbering
SLList<label> nextCell;
labelList visited(cellCellAddressing.size());
label currentCell;
label cellInOrder = 0;
// reset the visited cells list
forAll (visited, cellI)
{
visited[cellI] = 0;
}
// loop over the cells
forAll (visited, cellI)
{
// find the first cell that has not been visited yet
if (visited[cellI] == 0)
{
currentCell = cellI;
// use this cell as a start
nextCell.append(currentCell);
// loop through the nextCell list. Add the first cell into the
// cell order if it has not already been visited and ask for its
// neighbours. If the neighbour in question has not been visited,
// add it to the end of the nextCell list
while (nextCell.size())
{
currentCell = nextCell.removeHead();
if (visited[currentCell] == 0)
{
visited[currentCell] = 1;
// add into cellOrder
newOrder[cellInOrder] = currentCell;
cellInOrder++;
// find if the neighbours have been visited
const labelList& neighbours =
cellCellAddressing[currentCell];
forAll (neighbours, nI)
{
if (visited[neighbours[nI]] == 0)
{
// not visited, add to the list
nextCell.append(neighbours[nI]);
}
}
}
}
}
// Given a subset of cells determine the new global indices. The problem
// is in the cells from neighbouring processors which need to be renumbered.
void Foam::multiLevelDecomp::subsetGlobalCellCells
(
const label nDomains,
const label domainI,
const labelList& dist,
const labelListList& cellCells,
const labelList& set,
labelListList& subCellCells,
labelList& cutConnections
) const
{
// Determine new index for cells by inverting subset
labelList oldToNew(invert(cellCells.size(), set));
globalIndex globalCells(cellCells.size());
// Subset locally the elements for which I have data
subCellCells = UIndirectList<labelList>(cellCells, set);
// Get new indices for neighbouring processors
List<Map<label>> compactMap;
mapDistribute map(globalCells, subCellCells, compactMap);
map.distribute(oldToNew);
labelList allDist(dist);
map.distribute(allDist);
// Now we have:
// oldToNew : the locally-compact numbering of all our cellCells. -1 if
// cellCell is not in set.
// allDist : destination domain for all our cellCells
// subCellCells : indexes into oldToNew and allDist
// Globally compact numbering for cells in set.
globalIndex globalSubCells(set.size());
// Now subCellCells contains indices into oldToNew which are the
// new locations of the neighbouring cells.
cutConnections.setSize(nDomains);
cutConnections = 0;
forAll(subCellCells, subCelli)
{
labelList& cCells = subCellCells[subCelli];
// Keep the connections to valid mapped cells
label newI = 0;
forAll(cCells, i)
{
// Get locally-compact cell index of neighbouring cell
label nbrCelli = oldToNew[cCells[i]];
if (nbrCelli == -1)
{
cutConnections[allDist[cCells[i]]]++;
}
else
{
// Reconvert local cell index into global one
// Get original neighbour
label celli = set[subCelli];
label oldNbrCelli = cellCells[celli][i];
// Get processor from original neighbour
label proci = globalCells.whichProcID(oldNbrCelli);
// Convert into global compact numbering
cCells[newI++] = globalSubCells.toGlobal(proci, nbrCelli);
}
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
//----------------------------------------------------------------------//
//- open abaqus input file
//----------------------------------------------------------------------//
Info << "Opening Abaqus input file" << endl << endl;
OFstream abaqusInp("abaqusMesh.inp");
//- input header
Info << "Writing input file header" << endl << endl;
abaqusInp << "*Heading\n"
<< "** Job name: OpenFoamMesh Model name: OpenFoamMesh\n"
<< "** Generated by: Abaqus/CAE 6.9-2\n"
<< "*Preprint, echo=NO, model=NO, history=NO, contact=NO\n"
<< "**\n"
<< "** PARTS\n"
<< "**\n"
<< "*Part, name=OpenFoamMeshPart"
<< endl;
//----------------------------------------------------------------------//
//- write nodes
//----------------------------------------------------------------------//
Info << "Writing Nodes" << endl << endl;
abaqusInp << "*Node" << endl;
const pointField& points = mesh.points();
forAll(points, pointi)
{
abaqusInp << "\t" << (pointi+1)
<< ",\t" << (points[pointi]).x()
<< ",\t" << (points[pointi]).y()
<< ",\t" << (points[pointi]).z()
<< endl;
}
//----------------------------------------------------------------------//
//- determine abaqusCellPoints
//----------------------------------------------------------------------//
//- for hex 1st order elements, abaqus orders the points
//- where nodes 1 2 3 4 are clockwise from the outside of the cell
//- and then 5 6 7 8 are apposite 1 2 3 4 respectively
Info << "Determining Abaqus element node ordering" << endl << endl;
const cellList& cells = mesh.cells();
const faceList& faces = mesh.faces();
const labelListList pointPoints = mesh.pointPoints();
const labelListList cellPoints = mesh.cellPoints();
const labelList faceOwner = mesh.faceOwner();
const vectorField faceNormals = mesh.Sf()/mesh.magSf();
labelListList abaqusCellPoints(cellPoints.size(), List<label>(8, 1));
forAll(cells, celli)
{
//- face0 will be our reference face
//- face0 seems to be always owned by the cell
//- so the face normal points out of the cell
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);
//- now find the opposite face in the cell
//Info << "Finding oppFace" << endl << endl;
labelList refFacePoints = faces[refFace];
//- compare each faces points to the refFace, the opposite
//- face will share points with the refFace
label oppFace = -1;
//- for all the cell faces
forAll(cells[celli], facei)
{
bool faceHasNoCommonPoints = true;
label globalFaceLabel = cells[celli][facei];
//- for all the face points
forAll(faces[globalFaceLabel], pointi)
{
label globalPointLabel = faces[globalFaceLabel][pointi];
//- compare each point with all the refFace points
forAll(faces[refFace], refFacePointi)
{
label refFaceGlobalPointLabel = faces[refFace][refFacePointi];
if(globalPointLabel == refFaceGlobalPointLabel)
{
faceHasNoCommonPoints = false;
}
}
void CalculateDragForce
(
cfdemCloud& sm,
const volScalarField& alpf_,
const volVectorField& Uf_,
const volScalarField& rho_,
const bool& verbose_,
vectorField& DragForce_,
const labelListList& particleList_
)
{
// get viscosity field
#ifdef comp
const volScalarField nufField = sm.turbulence().mu()/rho_;
#else
const volScalarField& nufField = sm.turbulence().nu();
#endif
// Local variables
label cellI(-1);
vector drag(0,0,0);
vector Ufluid(0,0,0);
vector position(0,0,0);
scalar voidfraction(1);
vector Up(0,0,0);
vector Ur(0,0,0);
scalar ds(0);
scalar nuf(0);
scalar rhof(0);
vector WenYuDrag(0,0,0);
interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_);
interpolationCellPoint<vector> UInterpolator_(Uf_);
//
//_AO_Parallel
DragForce_.resize(particleList_.size());
for(int ii =0; ii < particleList_.size(); ii++)
{
int index = particleList_[ii][0];
cellI = sm.cellIDs()[index][0];
drag = vector(0,0,0);
Ufluid = vector(0,0,0);
WenYuDrag = vector(0,0,0);
DragForce_[ii] = vector(0,0,0);
if (cellI > -1) // particle Found
{
position = sm.position(index);
if ( alpf_[cellI] > 1. ) Pout << " voidfraction > 1 " << alpf_[cellI] << endl;
voidfraction = voidfractionInterpolator_.interpolate(position,cellI);
Ufluid = UInterpolator_.interpolate(position,cellI);
if ( voidfraction > 1. )
{
Pout << " Int. voidfraction > 1 " << " value= " << voidfraction;
voidfraction = alpf_[cellI];
Pout << " mod. value = " << voidfraction << endl;
}
Up = sm.velocity(index);
Ur = Ufluid-Up;
ds = 2*sm.radius(index);
rhof = rho_[cellI];
nuf = nufField[cellI];
// Drag force
WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag);
if(verbose_ && index <= 1)
{
Info << "" << endl;
Pout << " index = " << index << endl;
Pout << " position = " << position << endl;
Pout << " Up = " << Up << endl;
Pout << " Ur = " << Ur << endl;
Pout << " dp = " << ds << endl;
Pout << " rho = " << rhof << endl;
Pout << " nuf = " << nuf << endl;
Pout << " voidfraction = " << voidfraction << endl;
Pout << " drag = " << WenYuDrag << endl;
Info << " " << endl;
}
}
for(int j=0;j<3;j++) DragForce_[ii][j] = WenYuDrag[j];
}
}
void EulerianParticleVelocityForce
(
cfdemCloud& sm,
const fvMesh& mesh,
volVectorField& Uf_,
volVectorField& Up_,
volScalarField& rho_,
volScalarField& alpf_,
volScalarField& Pg_,
volVectorField& MappedDragForce_,
const labelListList& particleList_,
const bool& weighting_
)
{
// Neighbouring cells
CPCCellToCellStencil neighbourCells(mesh);
// get viscosity field
#ifdef comp
const volScalarField nufField = sm.turbulence().mu()/rho_;
#else
const volScalarField& nufField = sm.turbulence().nu();
#endif
// Gas pressure gradient
volVectorField gradPg_ = fvc::grad(Pg_);
interpolationCellPoint<vector> gradPgInterpolator_(gradPg_);
// Local variables
label cellID(-1);
vector drag(0,0,0);
vector Ufluid(0,0,0);
vector position(0,0,0);
scalar voidfraction(1);
vector Up(0,0,0);
vector Ur(0,0,0);
scalar ds(0);
scalar nuf(0);
scalar rhof(0);
vector WenYuDrag(0,0,0);
interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_);
interpolationCellPoint<vector> UInterpolator_(Uf_);
scalar dist_s(0);
scalar sumWeights(0);
scalarField weightScalar(27,scalar(0.0));
Field <Field <scalar> > particleWeights(particleList_.size(),weightScalar);
//Info << " particle size " << particleList_.size() << endl;
// Number of particle in a cell
scalarField np(mesh.cells().size(),scalar(0));
// Particle volume
scalar Volp(0);
vector gradPg_int(0,0,0);
for(int ii = 0; ii < particleList_.size(); ii++)
{
int index = particleList_[ii][0];
cellID = sm.cellIDs()[index][0];
position = sm.position(index);
Ufluid = UInterpolator_.interpolate(position,cellID);
Up = sm.velocity(index);
Ur = Ufluid-Up;
ds = 2*sm.radius(index);
// Calculate WenYu Drag
voidfraction = voidfractionInterpolator_.interpolate(position,cellID);
nuf = nufField[cellID];
rhof = rho_[cellID];
WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag);
Volp = ds*ds*ds*M_PI/6;
gradPg_int = gradPgInterpolator_.interpolate(position,cellID);
//if (cellID > -1) // particle centre is in domain
//{
if(weighting_)
{
labelList& cellsNeigh = neighbourCells[cellID];
sumWeights = 0;
dist_s = 0;
//Info << " index = " << index << " ii = " << ii << " cellID = " << cellID << endl;
forAll(cellsNeigh,jj)
{
// Find distances between particle and neighbouring cells
dist_s = mag(sm.mesh().C()[cellsNeigh[jj]]-position)/pow(sm.mesh().V()[cellsNeigh[jj]],1./3.);
if(dist_s <= 0.5)
{
particleWeights[ii][jj] = 1./4.*pow(dist_s,4)-5./8.*pow(dist_s,2)+115./192.;
}
else if (dist_s > 0.5 && dist_s <= 1.5)
{
particleWeights[ii][jj] = -1./6.*pow(dist_s,4)+5./6.*pow(dist_s,3)-5./4.*pow(dist_s,2)+5./24.*dist_s+55./96.;
}
else if (dist_s > 1.5 && dist_s <= 2.5)
{
particleWeights[ii][jj] = pow(2.5-dist_s,4)/24.;
}
else
{
particleWeights[ii][jj] = 0;
}
sumWeights += particleWeights[ii][jj];
}
forAll(cellsNeigh,jj)
{
if ( sumWeights != 0 )
{
Up_[cellID] += Up*particleWeights[ii][jj]/sumWeights;
MappedDragForce_[cellID] += (WenYuDrag + Volp * gradPg_int) * particleWeights[ii][jj]/sumWeights;
}
else
{
Up_[cellID] = vector(0,0,0);
MappedDragForce_[cellID] = vector(0,0,0);
}
}
}
else
{
