Foam::thermophysicalPropertiesSelector<ThermophysicalProperties>:: thermophysicalPropertiesSelector ( const dictionary& dict ) { const word name(dict.first()->keyword()); if (dict.isDict(name)) { propertiesPtr_ = ThermophysicalProperties::New(dict.subDict(name)); } else { propertiesPtr_ = ThermophysicalProperties::New(name); } }
typename Table::iterator Foam::basicThermo::lookupThermo ( const dictionary& thermoDict, Table* tablePtr ) { word thermoTypeName; if (thermoDict.isDict("thermoType")) { const dictionary& thermoTypeDict(thermoDict.subDict("thermoType")); Info<< "Selecting thermodynamics package " << thermoTypeDict << endl; const int nCmpt = 7; const char* cmptNames[nCmpt] = { "type", "mixture", "transport", "thermo", "equationOfState", "specie", "energy" }; // Construct the name of the thermo package from the components thermoTypeName = word(thermoTypeDict.lookup("type")) + '<' + word(thermoTypeDict.lookup("mixture")) + '<' + word(thermoTypeDict.lookup("transport")) + '<' + word(thermoTypeDict.lookup("thermo")) + '<' + word(thermoTypeDict.lookup("equationOfState")) + '<' + word(thermoTypeDict.lookup("specie")) + ">>," + word(thermoTypeDict.lookup("energy")) + ">>>"; // Lookup the thermo package typename Table::iterator cstrIter = tablePtr->find(thermoTypeName); // Print error message if package not found in the table if (cstrIter == tablePtr->end()) { FatalErrorInFunction << "Unknown " << Thermo::typeName << " type " << nl << "thermoType" << thermoTypeDict << nl << nl << "Valid " << Thermo::typeName << " types are:" << nl << nl; // Get the list of all the suitable thermo packages available wordList validThermoTypeNames ( tablePtr->sortedToc() ); // Build a table of the thermo packages constituent parts // Note: row-0 contains the names of constituent parts List<wordList> validThermoTypeNameCmpts ( validThermoTypeNames.size() + 1 ); validThermoTypeNameCmpts[0].setSize(nCmpt); forAll(validThermoTypeNameCmpts[0], j) { validThermoTypeNameCmpts[0][j] = cmptNames[j]; } // Split the thermo package names into their constituent parts forAll(validThermoTypeNames, i) { validThermoTypeNameCmpts[i+1] = Thermo::splitThermoName(validThermoTypeNames[i], nCmpt); } // Print the table of available packages // in terms of their constituent parts printTable(validThermoTypeNameCmpts, FatalError); FatalError<< exit(FatalError); }
Foam::searchableSurfaces::searchableSurfaces ( const IOobject& io, const dictionary& topDict ) : PtrList<searchableSurface>(topDict.size()), names_(topDict.size()), regionNames_(topDict.size()), allSurfaces_(identity(topDict.size())) { label surfI = 0; forAllConstIter(dictionary, topDict, iter) { const word& key = iter().keyword(); if (!topDict.isDict(key)) { FatalErrorIn ( "searchableSurfaces::searchableSurfaces" "( const IOobject&, const dictionary&)" ) << "Found non-dictionary entry " << iter() << " in top-level dictionary " << topDict << exit(FatalError); } const dictionary& dict = topDict.subDict(key); names_[surfI] = key; dict.readIfPresent("name", names_[surfI]); // Make IOobject with correct name autoPtr<IOobject> namedIO(io.clone()); // Note: we would like to e.g. register triSurface 'sphere.stl' as // 'sphere'. Unfortunately // no support for having object read from different location than // their object name. Maybe have stlTriSurfaceMesh which appends .stl // when reading/writing? namedIO().rename(key); // names_[surfI] // Create and hook surface set ( surfI, searchableSurface::New ( dict.lookup("type"), namedIO(), dict ) ); const searchableSurface& s = operator[](surfI); // Construct default region names by prepending surface name // to region name. const wordList& localNames = s.regions(); wordList& rNames = regionNames_[surfI]; rNames.setSize(localNames.size()); forAll(localNames, regionI) { rNames[regionI] = names_[surfI] + '_' + localNames[regionI]; } // See if dictionary provides any global region names. if (dict.found("regions")) { const dictionary& regionsDict = dict.subDict("regions"); forAllConstIter(dictionary, regionsDict, iter) { const word& key = iter().keyword(); if (regionsDict.isDict(key)) { // Get the dictionary for region iter.keyword() const dictionary& regionDict = regionsDict.subDict(key); label index = findIndex(localNames, key); if (index == -1) { FatalErrorIn ( "searchableSurfaces::searchableSurfaces" "( const IOobject&, const dictionary&)" ) << "Unknown region name " << key << " for surface " << s.name() << endl << "Valid region names are " << localNames << exit(FatalError); } rNames[index] = word(regionDict.lookup("name")); } } } surfI++; }
void extractFeatures ( const fileName& surfaceFileName, const Time& runTime, const dictionary& dict ) { const fileName sFeatFileName = surfaceFileName.lessExt().name(); Info<< "Surface : " << surfaceFileName << nl << endl; const Switch writeVTK = dict.lookupOrDefault<Switch>("writeVTK", "off"); const Switch writeObj = dict.lookupOrDefault<Switch>("writeObj", "off"); const Switch verboseObj = dict.lookupOrDefault<Switch>("verboseObj", "off"); const Switch curvature = dict.lookupOrDefault<Switch>("curvature", "off"); const Switch featureProximity = dict.lookupOrDefault<Switch>("featureProximity", "off"); const Switch closeness = dict.lookupOrDefault<Switch>("closeness", "off"); Info<< nl << "Feature line extraction is only valid on closed manifold " << "surfaces." << endl; // Read // ~~~~ triSurface surf(runTime.constantPath()/"triSurface"/surfaceFileName); Info<< "Statistics:" << endl; surf.writeStats(Info); Info<< endl; const faceList faces(surf.faces()); // Either construct features from surface & featureAngle or read set. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ const scalar includedAngle = readScalar(dict.lookup("includedAngle")); autoPtr<surfaceFeatures> set ( surfaceFeatureSet ( surfaceFileName, surf, dict, includedAngle ) ); // Trim set // ~~~~~~~~ if (dict.isDict("trimFeatures")) { dictionary trimDict = dict.subDict("trimFeatures"); scalar minLen = trimDict.lookupOrAddDefault<scalar>("minLen", -great); label minElem = trimDict.lookupOrAddDefault<label>("minElem", 0); // Trim away small groups of features if (minElem > 0 || minLen > 0) { Info<< "Removing features of length < " << minLen << endl; Info<< "Removing features with number of edges < " << minElem << endl; set().trimFeatures(minLen, minElem, includedAngle); } } // Subset // ~~~~~~ // Convert to marked edges, points List<surfaceFeatures::edgeStatus> edgeStat(set().toStatus()); if (dict.isDict("subsetFeatures")) { const dictionary& subsetDict = dict.subDict ( "subsetFeatures" ); if (subsetDict.found("insideBox")) { treeBoundBox bb(subsetDict.lookup("insideBox")()); Info<< "Selecting edges inside bb " << bb; if (writeObj) { Info << " see insideBox.obj"; bb.writeOBJ("insideBox.obj"); } Info<< endl; selectBox(surf, bb, true, edgeStat); } else if (subsetDict.found("outsideBox")) { treeBoundBox bb(subsetDict.lookup("outsideBox")()); Info<< "Removing all edges inside bb " << bb; if (writeObj) { Info<< " see outsideBox.obj" << endl; bb.writeOBJ("outsideBox.obj"); } Info<< endl; selectBox(surf, bb, false, edgeStat); } const Switch nonManifoldEdges = subsetDict.lookupOrDefault<Switch>("nonManifoldEdges", "yes"); if (!nonManifoldEdges) { Info<< "Removing all non-manifold edges" << " (edges with > 2 connected faces) unless they" << " cross multiple regions" << endl; selectManifoldEdges(surf, 1e-5, includedAngle, edgeStat); } const Switch openEdges = subsetDict.lookupOrDefault<Switch>("openEdges", "yes"); if (!openEdges) { Info<< "Removing all open edges" << " (edges with 1 connected face)" << endl; forAll(edgeStat, edgei) { if (surf.edgeFaces()[edgei].size() == 1) { edgeStat[edgei] = surfaceFeatures::NONE; } } } if (subsetDict.found("plane")) { const plane cutPlane(subsetDict.lookup("plane")()); selectCutEdges(surf, cutPlane, edgeStat); Info<< "Only edges that intersect the plane with normal " << cutPlane.normal() << " and base point " << cutPlane.refPoint() << " will be included as feature edges."<< endl; } }