static word getFieldViewName(const word& foamName)
{
if (FieldviewNames.found(foamName))
{
return FieldviewNames[foamName];
}
else
{
return foamName;
}
}
Foam::label Foam::HashTable<T, Key, Hash>::erase
(
const HashTable<AnyType, Key, AnyHash>& rhs
)
{
label count = 0;
// Remove rhs keys from this table - terminates early if possible
// Could optimize depending on which hash is smaller ...
for (iterator iter = begin(); iter != end(); ++iter)
{
if (rhs.found(iter.key()) && erase(iter))
{
count++;
}
}
return count;
}
/* For each column of fixed x value, find the point whose z value is closest to h.
Update those points to have a z value of h.
*/
void snapNearestPointsToSurface(
IOField<point>& newPoints,
const Mountain& mountain)
{
HashTable<int, scalar> minDistances;
HashTable<int, scalar> closestZcoords;
forAll(newPoints, ip)
{
int x = roundUp(newPoints[ip].x(), 10); // FIXME: this hashtable method is dubious because it's not safe to compare doubles for equality
scalar z = newPoints[ip].z();
scalar h = mountain.heightAt(x);
scalar distance = abs(z - h);
if (!minDistances.found(x) || distance < minDistances[x])
{
minDistances.set(x, distance);
closestZcoords.set(x, z);
}
}
Foam::processorGAMGInterface::processorGAMGInterface
(
const lduInterface& fineInterface,
const labelField& localRestrictAddressing,
const labelField& neighbourRestrictAddressing
)
:
GAMGInterface
(
fineInterface,
localRestrictAddressing,
neighbourRestrictAddressing
),
fineProcInterface_(refCast<const processorLduInterface>(fineInterface))
{
// Make a lookup table of entries for owner/neighbour
HashTable<SLList<label>, label, Hash<label> > neighboursTable
(
localRestrictAddressing.size()
);
// Table of face-sets to be agglomerated
HashTable<SLList<SLList<label> >, label, Hash<label> > faceFaceTable
(
localRestrictAddressing.size()
);
label nCoarseFaces = 0;
forAll (localRestrictAddressing, ffi)
{
label curMaster = -1;
label curSlave = -1;
// Do switching on master/slave indexes based on the owner/neighbour of
// the processor index such that both sides get the same answer.
if (myProcNo() < neighbProcNo())
{
// Master side
curMaster = localRestrictAddressing[ffi];
curSlave = neighbourRestrictAddressing[ffi];
}
else
{
// Slave side
curMaster = neighbourRestrictAddressing[ffi];
curSlave = localRestrictAddressing[ffi];
}
// Look for the master cell. If it has already got a face,
// add the coefficient to the face. If not, create a new face.
if (neighboursTable.found(curMaster))
{
// Check all current neighbours to see if the current slave already
// exists and if so, add the fine face to the agglomeration.
SLList<label>& curNbrs = neighboursTable.find(curMaster)();
SLList<SLList<label> >& curFaceFaces =
faceFaceTable.find(curMaster)();
bool nbrFound = false;
SLList<label>::iterator nbrsIter = curNbrs.begin();
SLList<SLList<label> >::iterator faceFacesIter =
curFaceFaces.begin();
for
(
;
nbrsIter != curNbrs.end(), faceFacesIter != curFaceFaces.end();
++nbrsIter, ++faceFacesIter
)
{
if (nbrsIter() == curSlave)
{
nbrFound = true;
faceFacesIter().append(ffi);
break;
}
}
if (!nbrFound)
{
curNbrs.append(curSlave);
curFaceFaces.append(ffi);
// New coarse face created
nCoarseFaces++;
}
}
else
{
// This master has got no neighbours yet. Add a neighbour
// and a coefficient, thus creating a new face
neighboursTable.insert(curMaster, SLList<label>(curSlave));
faceFaceTable.insert(curMaster, SLList<SLList<label> >(ffi));
// New coarse face created
nCoarseFaces++;
}
} // end for all fine faces
void setUpdater::updateSets(const mapPolyMesh& morphMap) const
{
//
// Update all sets in memory.
//
HashTable<const Type*> memSets =
morphMap.mesh().objectRegistry::lookupClass<Type>();
for
(
typename HashTable<const Type*>::iterator iter = memSets.begin();
iter != memSets.end();
++iter
)
{
Type& set = const_cast<Type&>(*iter());
if (debug)
{
Pout<< "Set:" << set.name() << " size:" << set.size()
<< " updated in memory" << endl;
}
set.updateMesh(morphMap);
// Write or not? Debatable.
set.write();
}
//
// Update all sets on disk
//
// Get last valid mesh (discard points-only change)
IOobjectList Objects
(
morphMap.mesh().time(),
morphMap.mesh().time().findInstance
(
morphMap.mesh().meshDir(),
"faces"
),
"polyMesh/sets"
);
IOobjectList fileSets(Objects.lookupClass(Type::typeName));
for
(
IOobjectList::const_iterator iter = fileSets.begin();
iter != fileSets.end();
++iter
)
{
if (!memSets.found(iter.key()))
{
// Not in memory. Load it.
Type set(*iter());
if (debug)
{
Pout<< "Set:" << set.name() << " size:" << set.size()
<< " updated on disk" << endl;
}
set.updateMesh(morphMap);
set.write();
}
else
{
if (debug)
{
Pout<< "Set:" << iter.key() << " already updated from memory"
<< endl;
}
}
}
}
void Foam::PrintTable<KeyType, DataType>::print
(
Ostream& os,
const bool printSum,
const bool printAverage
) const
{
HashTable<HashTable<DataType, label>, KeyType> combinedTable;
List<HashTableData> procData(Pstream::nProcs(), HashTableData());
procData[Pstream::myProcNo()] = table_;
Pstream::gatherList(procData);
if (Pstream::master())
{
label largestKeyLength = 6;
label largestDataLength = 0;
List<label> largestProcSize(Pstream::nProcs(), 0);
forAll(procData, procI)
{
const HashTableData& procIData = procData[procI];
for
(
typename HashTableData::const_iterator iter = procIData.begin();
iter != procIData.end();
++iter
)
{
if (!combinedTable.found(iter.key()))
{
combinedTable.insert
(
iter.key(),
HashTable<DataType, label>()
);
}
HashTable<DataType, label>& key = combinedTable[iter.key()];
key.insert(procI, iter());
for
(
typename HashTable<DataType, label>
::const_iterator dataIter = key.begin();
dataIter != key.end();
++dataIter
)
{
std::ostringstream buf;
buf << dataIter();
largestDataLength = max
(
largestDataLength,
label(buf.str().length())
);
}
std::ostringstream buf;
buf << iter.key();
largestKeyLength = max
(
largestKeyLength,
label(buf.str().length())
);
}
}
os.width(largestKeyLength);
os << nl << indent << tab << "# " << title_.c_str() << endl;
os.width(largestKeyLength);
os << indent << "# Proc";
forAll(procData, procI)
{
os << tab;
os.width(largestDataLength);
os << procI;
}
if (printSum)
{
os << tab;
os.width(largestDataLength);
os << "Sum";
}
if (printAverage)
{
os << tab;
os.width(largestDataLength);
os << "Average";
}
os << endl;
const List<KeyType>& sortedTable = combinedTable.sortedToc();
forAll(sortedTable, keyI)
{
const HashTable<DataType, label>& procDataList
= combinedTable[sortedTable[keyI]];
os.width(largestKeyLength);
os << indent << sortedTable[keyI];
forAll(procDataList, elemI)
{
os << tab;
os.width(largestDataLength);
os << procDataList[elemI];
}
if (printSum)
{
DataType sum = 0;
forAll(procDataList, elemI)
{
sum += procDataList[elemI];
}
os << tab;
os.width(largestDataLength);
os << sum;
if (printAverage)
{
os << tab;
os.width(largestDataLength);
os << sum/Pstream::nProcs();
}
}
os << endl;
}