├── bin ├── Q ├── org-html ├── org-latex ├── org-pdflatex ├── Lambda2 ├── R ├── enstrophy ├── flowType ├── foamPackThirdPartyBin ├── vorticity ├── yPlus ├── foamPackThirdPartyBinAll ├── wallShearStress ├── foamNewSource ├── foamNewTemplate └── tools │ ├── README │ └── scanpackages ├── applications ├── test │ ├── graphXi │ │ └── r.ps │ ├── ensightFoamReader │ │ ├── udr_checker.c │ │ ├── global_extern.h │ │ └── global_extern_proto.h │ ├── FixedList │ │ └── fixedListFile │ ├── volField │ │ ├── README.txt │ │ └── cavity │ │ │ └── Allrun │ ├── dictionary │ │ ├── value │ │ └── testDictInc │ ├── patchRegion │ │ ├── README │ │ └── cavity_pinched │ │ │ └── README.txt │ ├── fieldMapping │ │ ├── README.txt │ │ └── pipe1D │ │ │ └── Allrun │ ├── Field │ │ └── Test-Field.C │ ├── tensor2D │ │ └── Test-tensor2D.C │ ├── hexRef8 │ │ ├── README.txt │ │ └── block │ │ │ └── Allrun │ ├── UniformField │ │ └── Test-UniformField.C │ ├── alloc │ │ ├── Test-alloc.C │ │ ├── Test-new.C │ │ └── Test-malloc.C │ ├── rigidBodyDynamics │ │ └── sphericalJoint │ │ │ └── sphericalJoint │ ├── thermoMixture │ │ └── thermoDict │ ├── cyclic │ │ └── createFields.H │ └── maxMem │ │ └── Test-maxMem.C ├── utilities │ ├── mesh │ │ ├── conversion │ │ │ ├── sammToFoam │ │ │ │ └── starMesh.H │ │ │ ├── Optional │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ccm26ToFoam │ │ │ │ │ └── Make │ │ │ │ │ │ ├── files │ │ │ │ │ │ └── options │ │ │ │ └── Allwmake │ │ │ └── kivaToFoam │ │ │ │ └── kiva3v-valves.pdf │ │ ├── generation │ │ │ ├── extrude │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── extrudeMesh │ │ │ │ │ └── createTimeExtruded.H │ │ │ ├── extrude2DMesh │ │ │ │ └── Allwclean │ │ │ ├── CMakeLists.txt │ │ │ └── foamyMesh │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Allwclean │ │ ├── CMakeLists.txt │ │ ├── manipulation │ │ │ ├── checkMesh │ │ │ │ ├── printMeshStats.H │ │ │ │ ├── checkMeshQuality.H │ │ │ │ └── checkTopology.H │ │ │ ├── mirrorMesh │ │ │ │ └── readMirrorDict.H │ │ │ └── mergeMeshes │ │ │ │ └── createTimes.H │ │ └── advanced │ │ │ └── CMakeLists.txt │ ├── postProcessing │ │ ├── graphics │ │ │ ├── PV3Readers │ │ │ │ ├── PV3FoamReader │ │ │ │ │ ├── PV3FoamReader │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── PV3FoamReader.qrc │ │ │ │ │ │ └── PV3FoamReader.xml │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Allwclean │ │ │ │ ├── PV3blockMeshReader │ │ │ │ │ ├── PV3blockMeshReader │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── PV3blockMeshReader.qrc │ │ │ │ │ │ └── PV3blockMeshReader.xml │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Allwclean │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Allwclean │ │ │ ├── ensightFoamReader │ │ │ │ ├── USERD_API.H │ │ │ │ ├── USERD_stop_part_building.H │ │ │ │ ├── USERD_exit_routine.H │ │ │ │ ├── USERD_get_number_of_model_parts.H │ │ │ │ ├── USERD_set_server_number.H │ │ │ │ ├── USERD_get_matf_set_info.H │ │ │ │ ├── USERD_get_number_timesets.H │ │ │ │ ├── USERD_get_number_of_material_sets.H │ │ │ │ ├── USERD_get_number_of_materials.H │ │ │ │ ├── USERD_get_matf_var_info.H │ │ │ │ ├── USERD_get_model_extents.H │ │ │ │ ├── USERD_get_geom_timeset_number.H │ │ │ │ ├── USERD_get_number_of_variables.H │ │ │ │ ├── USERD_get_dataset_query_file_info.H │ │ │ │ ├── USERD_size_matf_data.H │ │ │ │ ├── USERD_load_matf_data.H │ │ │ │ ├── USERD_get_changing_geometry_status.H │ │ │ │ ├── USERD_get_border_availability.H │ │ │ │ ├── USERD_bkup.H │ │ │ │ ├── USERD_get_node_label_status.H │ │ │ │ ├── USERD_get_constant_val.H │ │ │ │ ├── USERD_get_element_label_status.H │ │ │ │ ├── USERD_get_reader_release.H │ │ │ │ ├── USERD_get_reader_version.H │ │ │ │ ├── USERD_get_num_of_time_steps.H │ │ │ │ ├── USERD_get_border_elements_by_type.H │ │ │ │ ├── USERD_get_number_of_files_in_dataset.H │ │ │ │ ├── USERD_get_name_of_reader.H │ │ │ │ ├── USERD_get_timeset_description.H │ │ │ │ ├── getLagrangianScalar.H │ │ │ │ └── tensorConversion.H │ │ │ ├── CMakeLists.txt │ │ │ └── PVReaders │ │ │ │ ├── PVFoamReader │ │ │ │ ├── PVFoamReader │ │ │ │ │ ├── PVFoamReader.qrc │ │ │ │ │ └── PVFoamReader.xml │ │ │ │ └── Allwclean │ │ │ │ ├── PVblockMeshReader │ │ │ │ ├── PVblockMeshReader │ │ │ │ │ ├── PVblockMeshReader.qrc │ │ │ │ │ └── PVblockMeshReader.xml │ │ │ │ └── Allwclean │ │ │ │ └── Allwclean │ │ ├── dataConversion │ │ │ ├── foamToGMV │ │ │ │ ├── gmvOutputTail.H │ │ │ │ └── moveMesh.H │ │ │ ├── foamToEnsightParts │ │ │ │ ├── moveMesh.H │ │ │ │ └── checkHasMovingMesh.H │ │ │ ├── CMakeLists.txt │ │ │ └── foamToEnsight │ │ │ │ ├── checkData.H │ │ │ │ └── checkMeshMoving.H │ │ ├── miscellaneous │ │ │ ├── CMakeLists.txt │ │ │ └── postChannel │ │ │ │ └── readTransportProperties.H │ │ ├── CMakeLists.txt │ │ └── toBeFunctionObjects │ │ │ ├── CMakeLists.txt │ │ │ └── lagrangian │ │ │ ├── steadyParticleTracks │ │ │ └── createFields.H │ │ │ └── particleTracks │ │ │ └── createFields.H │ ├── parallelProcessing │ │ └── CMakeLists.txt │ ├── surface │ │ └── surfaceCoarsen │ │ │ └── bunnylod │ │ │ ├── font.h │ │ │ ├── README │ │ │ └── bunnylod.dsw │ ├── thermophysical │ │ └── CMakeLists.txt │ ├── miscellaneous │ │ ├── foamHelp │ │ │ └── Allwclean │ │ └── CMakeLists.txt │ ├── CMakeLists.txt │ └── preProcessing │ │ ├── boxTurb │ │ ├── createFields.H │ │ └── readBoxTurbDict.H │ │ ├── mapFieldsPar │ │ └── createTimes.H │ │ ├── CMakeLists.txt │ │ └── mapFields │ │ └── createTimes.H ├── CMakeLists.txt └── solvers │ ├── combustion │ ├── PDRFoam │ │ ├── createFieldRefs.H │ │ ├── ftEqn.H │ │ ├── readCombustionProperties.H │ │ ├── UEqn.H │ │ └── EaEqn.H │ ├── XiFoam │ │ ├── createFieldRefs.H │ │ ├── UEqn.H │ │ ├── ftEqn.H │ │ └── EaEqn.H │ ├── fireFoam │ │ ├── solidRegionDiffusionNo.H │ │ ├── createPyrolysisModel.H │ │ ├── createFieldRefs.H │ │ ├── createClouds.H │ │ ├── createSurfaceFilmModel.H │ │ └── UEqn.H │ ├── coldEngineFoam │ │ ├── createFieldRefs.H │ │ ├── startSummary.H │ │ └── logSummary.H │ ├── reactingFoam │ │ ├── createFieldRefs.H │ │ ├── rhoReactingFoam │ │ │ └── createFieldRefs.H │ │ ├── rhoReactingBuoyantFoam │ │ │ ├── createFieldRefs.H │ │ │ └── UEqn.H │ │ └── UEqn.H │ ├── engineFoam │ │ ├── readEngineTimeControls.H │ │ ├── UEqn.H │ │ ├── startSummary.H │ │ └── logSummary.H │ ├── chemFoam │ │ ├── readControls.H │ │ ├── createControls.H │ │ ├── setDeltaT.H │ │ ├── solveChemistry.H │ │ ├── createFieldRefs.H │ │ ├── YEqn.H │ │ ├── hEqn.H │ │ ├── output.H │ │ └── pEqn.H │ └── CMakeLists.txt │ ├── compressible │ ├── rhoPimpleFoam │ │ ├── createFieldRefs.H │ │ ├── rhoPimpleDyMFoam │ │ │ ├── correctPhi.H │ │ │ ├── readControls.H │ │ │ └── createControls.H │ │ ├── UEqn.H │ │ └── EEqn.H │ ├── rhoSimpleFoam │ │ ├── createFieldRefs.H │ │ ├── UEqn.H │ │ ├── EEqn.H │ │ └── rhoPorousSimpleFoam │ │ │ ├── EEqn.H │ │ │ └── createZones.H │ ├── sonicFoam │ │ ├── createFieldRefs.H │ │ ├── sonicLiquidFoam │ │ │ ├── readTransportProperties.H │ │ │ └── compressibleContinuityErrs.H │ │ ├── UEqn.H │ │ └── EEqn.H │ ├── rhoCentralFoam │ │ ├── Allwclean │ │ ├── createFieldRefs.H │ │ └── readFluxScheme.H │ └── CMakeLists.txt │ ├── heatTransfer │ ├── buoyantPimpleFoam │ │ └── createFieldRefs.H │ ├── buoyantSimpleFoam │ │ ├── createFieldRefs.H │ │ └── EEqn.H │ ├── chtMultiRegionFoam │ │ ├── createFields.H │ │ ├── fluid │ │ │ ├── initContinuityErrs.H │ │ │ ├── storeOldFluidFields.H │ │ │ ├── readFluidMultiRegionPIMPLEControls.H │ │ │ ├── solveFluid.H │ │ │ ├── compressibleContinuityErrors.H │ │ │ └── createFluidMeshes.H │ │ ├── createMeshes.H │ │ ├── solid │ │ │ └── readSolidMultiRegionPIMPLEControls.H │ │ ├── chtMultiRegionSimpleFoam │ │ │ ├── solid │ │ │ │ ├── readSolidMultiRegionSIMPLEControls.H │ │ │ │ └── solveSolid.H │ │ │ └── fluid │ │ │ │ ├── readFluidMultiRegionSIMPLEControls.H │ │ │ │ ├── compressibleMultiRegionCourantNo.H │ │ │ │ ├── solveFluid.H │ │ │ │ ├── compressibleContinuityErrors.H │ │ │ │ ├── UEqn.H │ │ │ │ └── createFluidMeshes.H │ │ ├── createMeshesPostProcess.H │ │ └── readPIMPLEControls.H │ ├── CMakeLists.txt │ ├── buoyantBoussinesqSimpleFoam │ │ ├── readTransportProperties.H │ │ └── TEqn.H │ ├── buoyantBoussinesqPimpleFoam │ │ ├── TEqn.H │ │ └── UEqn.H │ └── thermoFoam │ │ └── EEqn.H │ ├── electromagnetics │ ├── mhdFoam │ │ ├── createControl.H │ │ ├── readBPISOControls.H │ │ └── magneticFieldErr.H │ └── CMakeLists.txt │ ├── discreteMethods │ ├── CMakeLists.txt │ ├── molecularDynamics │ │ ├── CMakeLists.txt │ │ ├── mdFoam │ │ │ └── createFields.H │ │ └── mdEquilibrationFoam │ │ │ └── readmdEquilibrationDict.H │ └── dsmc │ │ └── dsmcFoam │ │ └── createFields.H │ ├── stressAnalysis │ ├── CMakeLists.txt │ ├── solidEquilibriumDisplacementFoam │ │ ├── createControls.H │ │ └── readSteadyStressFoamControls.H │ └── solidDisplacementFoam │ │ ├── createControl.H │ │ ├── createControls.H │ │ └── readSolidDisplacementFoamControls.H │ ├── lagrangian │ ├── reactingParcelFoam │ │ ├── createFieldRefs.H │ │ ├── createClouds.H │ │ ├── simpleReactingParcelFoam │ │ │ ├── createClouds.H │ │ │ └── UEqn.H │ │ └── UEqn.H │ ├── sprayFoam │ │ ├── sprayEngineFoam │ │ │ ├── readEngineTimeControls.H │ │ │ ├── startSummary.H │ │ │ └── logSummary.H │ │ ├── createClouds.H │ │ └── UEqn.H │ ├── reactingParcelFilmFoam │ │ ├── createClouds.H │ │ ├── createSurfaceFilmModel.H │ │ └── UEqn.H │ ├── coalChemistryFoam │ │ ├── createClouds.H │ │ └── UEqn.H │ ├── CMakeLists.txt │ └── DPMFoam │ │ └── UcEqn.H │ ├── basic │ ├── CMakeLists.txt │ └── potentialFoam │ │ └── createControls.H │ ├── multiphase │ ├── cavitatingFoam │ │ ├── readControls.H │ │ ├── createControls.H │ │ ├── cavitatingDyMFoam │ │ │ ├── readControls.H │ │ │ ├── createControls.H │ │ │ └── createPcorrTypes.H │ │ ├── rhoEqn.H │ │ ├── UEqn.H │ │ ├── alphavPsi.H │ │ └── continuityErrs.H │ ├── twoPhaseEulerFoam │ │ ├── createMRF.H │ │ ├── pUf │ │ │ ├── DDtU.H │ │ │ └── createDDtU.H │ │ ├── correctContErrs.H │ │ ├── pU │ │ │ ├── DDtU.H │ │ │ └── createDDtU.H │ │ ├── CourantNos.H │ │ ├── contErrs.H │ │ ├── write.H │ │ └── createFieldRefs.H │ ├── twoLiquidMixingFoam │ │ ├── alphaControls.H │ │ ├── alphaDiffusionEqn.H │ │ ├── UEqn.H │ │ └── alphaEqn.H │ ├── reactingEulerFoam │ │ ├── reactingMultiphaseEulerFoam │ │ │ └── createFieldRefs.H │ │ ├── reactingTwoPhaseEulerFoam │ │ │ ├── pUf │ │ │ │ ├── DDtU.H │ │ │ │ └── createDDtU.H │ │ │ └── CourantNos.H │ │ └── CMakeLists.txt │ ├── multiphaseEulerFoam │ │ ├── MRFCorrectBCs.H │ │ ├── correctPhi.H │ │ ├── createMRFZones.H │ │ └── DDtU.H │ ├── interFoam │ │ ├── correctPhi.H │ │ ├── interDyMFoam │ │ │ ├── correctPhi.H │ │ │ ├── readControls.H │ │ │ └── createDyMControls.H │ │ ├── interMixingFoam │ │ │ └── alphaControls.H │ │ └── UEqn.H │ ├── interPhaseChangeFoam │ │ ├── interPhaseChangeDyMFoam │ │ │ └── correctPhi.H │ │ └── UEqn.H │ ├── compressibleInterFoam │ │ ├── alphaControls.H │ │ ├── compressibleInterDyMFoam │ │ │ ├── readControls.H │ │ │ ├── correctPhi.H │ │ │ └── createControls.H │ │ ├── TEqn.H │ │ └── UEqn.H │ ├── potentialFreeSurfaceFoam │ │ ├── potentialFreeSurfaceDyMFoam │ │ │ └── correctPhi.H │ │ └── UEqn.H │ ├── compressibleMultiphaseInterFoam │ │ ├── TEqn.H │ │ └── UEqn.H │ └── driftFluxFoam │ │ └── alphaControls.H │ ├── incompressible │ ├── pimpleFoam │ │ ├── pimpleDyMFoam │ │ │ ├── readControls.H │ │ │ ├── correctPhi.H │ │ │ └── createControls.H │ │ ├── UEqn.H │ │ └── SRFPimpleFoam │ │ │ └── UrelEqn.H │ ├── pisoFoam │ │ └── UEqn.H │ ├── CMakeLists.txt │ ├── simpleFoam │ │ ├── UEqn.H │ │ ├── SRFSimpleFoam │ │ │ └── UrelEqn.H │ │ └── porousSimpleFoam │ │ │ └── createPorousZones.H │ └── shallowWaterFoam │ │ └── readGravitationalAcceleration.H │ ├── DNS │ └── dnsFoam │ │ ├── globalProperties.H │ │ ├── readTransportProperties.H │ │ ├── readTurbulenceProperties.H │ │ └── createFields.H │ └── CMakeLists.txt ├── etc ├── templates │ ├── closedVolume │ │ └── constant │ │ │ └── triSurface │ │ │ └── .keep │ ├── inflowOutflow │ │ └── constant │ │ │ └── triSurface │ │ │ └── .keep │ ├── closedVolumeRotating │ │ ├── constant │ │ │ └── triSurface │ │ │ │ └── .keep │ │ └── README │ ├── inflowOutflowRotating │ │ └── constant │ │ │ └── triSurface │ │ │ └── .keep │ ├── compressibleInflowOutflow │ │ └── constant │ │ │ └── triSurface │ │ │ └── .keep │ └── axisymmetricJet │ │ ├── Allclean │ │ └── Allrun ├── CMakeLists.txt └── caseDicts │ └── postProcessing │ ├── minMax │ ├── cellMax │ ├── cellMin │ ├── faceMax │ ├── faceMin │ ├── cellMin.cfg │ ├── faceMin.cfg │ └── minMaxComponents.cfg │ ├── forces │ ├── forceCoeffs.cfg │ └── forcesIncompressible.cfg │ ├── surfaceRegion │ ├── patch.cfg │ └── faceZone.cfg │ ├── solvers │ └── scalarTransport │ │ └── scalarTransport.cfg │ ├── flowRate │ └── flowRatePatch.cfg │ └── probes │ ├── probes.cfg │ ├── cloud.cfg │ └── probes ├── src ├── OpenFOAM │ ├── db │ │ ├── IOstreams │ │ │ └── gzstream │ │ │ │ └── version │ │ └── dynamicLibrary │ │ │ └── dynamicCode │ │ │ └── installPaths.H.in │ ├── include │ │ ├── createTime.H │ │ ├── setRootCase.H │ │ ├── addOverwriteOption.H │ │ ├── addRegionOption.H │ │ ├── checkTimeOptionsNoConstant.H │ │ ├── addDictOption.H │ │ ├── checkTimeOptions.H │ │ ├── checkConstantOption.H │ │ ├── createMesh.H │ │ ├── checkTimeOption.H │ │ ├── createPolyMesh.H │ │ ├── createMeshNoClear.H │ │ ├── addTimeOptions.H │ │ ├── setSystemMeshDictionaryIO.H │ │ ├── setConstantMeshDictionaryIO.H │ │ ├── setSystemRunTimeDictionaryIO.H │ │ ├── createNamedMesh.H │ │ ├── createNamedPolyMesh.H │ │ └── addFunctionObjectOptions.H │ └── global │ │ └── caseDirs.H ├── OSspecific │ └── POSIX │ │ └── etcDir.H.in ├── finiteVolume │ └── cfdTools │ │ └── general │ │ ├── include │ │ ├── createMRF.H │ │ ├── createPisoControl.H │ │ ├── createPimpleControl.H │ │ ├── createSimpleControl.H │ │ ├── createFvOptions.H │ │ ├── readGravitationalAcceleration.H │ │ ├── readhRef.H │ │ ├── readpRef.H │ │ ├── gh.H │ │ ├── volContinuity.H │ │ ├── createRDeltaT.H │ │ ├── checkPatchFieldTypes.H │ │ └── alphaControls.H │ │ └── solutionControl │ │ └── createControl.H ├── Pstream │ └── CMakeLists.txt ├── rigidBodyMeshMotion │ └── Make │ │ ├── files │ │ └── options ├── mesh │ ├── CMakeLists.txt │ └── snappyHexMesh │ │ └── Make │ │ └── options ├── fvAgglomerationMethods │ └── CMakeLists.txt ├── meshTools │ └── momentOfInertia │ │ ├── volInt.ps.gz │ │ └── volumeIntegration │ │ ├── tetra │ │ └── cube ├── parallel │ ├── CMakeLists.txt │ └── decompose │ │ ├── CMakeLists.txt │ │ ├── decompositionMethods │ │ └── Make │ │ │ └── options │ │ └── AllwmakeLnInclude ├── renumber │ └── CMakeLists.txt ├── TurbulenceModels │ └── CMakeLists.txt ├── lagrangian │ ├── molecularDynamics │ │ ├── CMakeLists.txt │ │ └── molecule │ │ │ └── mdTools │ │ │ ├── md.H │ │ │ ├── createRefUnits.H │ │ │ ├── calculateMDFields.H │ │ │ └── resetMDFields.H │ ├── CMakeLists.txt │ └── spray │ │ └── submodels │ │ ├── BreakupModel │ │ └── TAB │ │ │ └── TABSMDCalcMethod1.H │ │ └── AtomizationModel │ │ └── LISAAtomization │ │ └── LISASMDCalcMethod1.H ├── dummyThirdParty │ └── CMakeLists.txt ├── functionObjects │ └── CMakeLists.txt ├── thermophysicalModels │ ├── radiation │ │ └── include │ │ │ └── createRadiationModel.H │ ├── properties │ │ ├── CMakeLists.txt │ │ └── liquidProperties │ │ │ └── IDEA │ │ │ └── IDEA.thermo │ └── CMakeLists.txt ├── engine │ └── include │ │ ├── createEngineTime.H │ │ └── createEngineMesh.H ├── transportModels │ └── CMakeLists.txt ├── regionModels │ ├── CMakeLists.txt │ └── Allwclean ├── randomProcesses │ ├── fft │ │ └── calcEk.H │ └── turbulence │ │ └── Ek.H ├── dynamicFvMesh │ └── include │ │ └── createDynamicFvMesh.H └── rigidBodyDynamics │ └── joints │ └── joints.H └── doc ├── tools ├── README ├── find-trailingspace └── find-its └── Doxygen └── footer.html /bin/Q: -------------------------------------------------------------------------------- 1 | supercededByPostProcess -------------------------------------------------------------------------------- /bin/org-html: -------------------------------------------------------------------------------- 1 | tools/org-batch -------------------------------------------------------------------------------- /bin/org-latex: -------------------------------------------------------------------------------- 1 | tools/org-batch -------------------------------------------------------------------------------- /applications/test/graphXi/r.ps: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /bin/org-pdflatex: -------------------------------------------------------------------------------- 1 | tools/org-batch -------------------------------------------------------------------------------- /bin/Lambda2: -------------------------------------------------------------------------------- 1 | supercededByPostProcess -------------------------------------------------------------------------------- /bin/R: -------------------------------------------------------------------------------- 1 | supercededByPostProcessOption -------------------------------------------------------------------------------- /bin/enstrophy: -------------------------------------------------------------------------------- 1 | supercededByPostProcess -------------------------------------------------------------------------------- /bin/flowType: -------------------------------------------------------------------------------- 1 | supercededByPostProcess -------------------------------------------------------------------------------- /bin/foamPackThirdPartyBin: -------------------------------------------------------------------------------- 1 | foamPackBin -------------------------------------------------------------------------------- /bin/vorticity: -------------------------------------------------------------------------------- 1 | supercededByPostProcess -------------------------------------------------------------------------------- /bin/yPlus: -------------------------------------------------------------------------------- 1 | supercededByPostProcessOption -------------------------------------------------------------------------------- /bin/foamPackThirdPartyBinAll: -------------------------------------------------------------------------------- 1 | foamPackBinAll -------------------------------------------------------------------------------- /bin/wallShearStress: -------------------------------------------------------------------------------- 1 | supercededByPostProcessOption -------------------------------------------------------------------------------- /etc/templates/closedVolume/constant/triSurface/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /etc/templates/inflowOutflow/constant/triSurface/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /bin/foamNewSource: -------------------------------------------------------------------------------- 1 | ../etc/codeTemplates/source/foamNewSource -------------------------------------------------------------------------------- /etc/templates/closedVolumeRotating/constant/triSurface/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /etc/templates/inflowOutflowRotating/constant/triSurface/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /applications/test/ensightFoamReader/udr_checker.c: -------------------------------------------------------------------------------- 1 | udr_checker-80.c -------------------------------------------------------------------------------- /bin/foamNewTemplate: -------------------------------------------------------------------------------- 1 | ../etc/codeTemplates/template/foamNewTemplate -------------------------------------------------------------------------------- /etc/templates/compressibleInflowOutflow/constant/triSurface/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /src/OpenFOAM/db/IOstreams/gzstream/version: -------------------------------------------------------------------------------- 1 | 1.5 (08 Jan 2003) 2 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/sammToFoam/starMesh.H: -------------------------------------------------------------------------------- 1 | #include "sammMesh.H" 2 | -------------------------------------------------------------------------------- /src/OSspecific/POSIX/etcDir.H.in: -------------------------------------------------------------------------------- 1 | #cmakedefine CONFIG_DIRECTORY "@CONFIG_DIRECTORY@" 2 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createMRF.H: -------------------------------------------------------------------------------- 1 | IOMRFZoneList MRF(mesh); 2 | -------------------------------------------------------------------------------- /applications/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( utilities ) 2 | add_subdirectory( solvers ) 3 | -------------------------------------------------------------------------------- /src/Pstream/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( dummy ) 2 | add_subdirectory( mpi ) 3 | 4 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createPisoControl.H: -------------------------------------------------------------------------------- 1 | pisoControl piso(mesh); 2 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/Optional/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( ccm26ToFoam ) 2 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createPimpleControl.H: -------------------------------------------------------------------------------- 1 | pimpleControl pimple(mesh); 2 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createSimpleControl.H: -------------------------------------------------------------------------------- 1 | simpleControl simple(mesh); 2 | -------------------------------------------------------------------------------- /applications/solvers/combustion/PDRFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/solvers/combustion/XiFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/test/FixedList/fixedListFile: -------------------------------------------------------------------------------- 1 | 2 | 2 3 | ( 4 | () 5 | () 6 | ) 7 | 8 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoSimpleFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createFvOptions.H: -------------------------------------------------------------------------------- 1 | fv::options& fvOptions(fv::options::New(mesh)); 2 | -------------------------------------------------------------------------------- /src/rigidBodyMeshMotion/Make/files: -------------------------------------------------------------------------------- 1 | rigidBodyMeshMotion.C 2 | 3 | LIB = $(FOAM_LIBBIN)/librigidBodyMeshMotion 4 | -------------------------------------------------------------------------------- /applications/solvers/combustion/fireFoam/solidRegionDiffusionNo.H: -------------------------------------------------------------------------------- 1 | scalar DiNum = pyrolysis.solidRegionDiffNo(); 2 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/buoyantPimpleFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/buoyantSimpleFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | -------------------------------------------------------------------------------- /applications/test/volField/README.txt: -------------------------------------------------------------------------------- 1 | Test field reading and manipulation. 2 | See cavity/Allrun in the subdirectory. 3 | -------------------------------------------------------------------------------- /applications/solvers/electromagnetics/mhdFoam/createControl.H: -------------------------------------------------------------------------------- 1 | pisoControl piso(mesh); 2 | pisoControl bpiso(mesh, "BPISO"); 3 | -------------------------------------------------------------------------------- /applications/test/ensightFoamReader/global_extern.h: -------------------------------------------------------------------------------- 1 | ../../utilities/postProcessing/graphics/ensightFoamReader/global_extern.h -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_API.H: -------------------------------------------------------------------------------- 1 | #define DO_READER 2 | #define USERD_API_203 3 | -------------------------------------------------------------------------------- /applications/solvers/discreteMethods/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( dsmc/dsmcFoam ) 2 | add_subdirectory( molecularDynamics ) 3 | -------------------------------------------------------------------------------- /applications/test/dictionary/value: -------------------------------------------------------------------------------- 1 | // the trailing ';' shouldn't actually be there, but shouldn't cause problems 2 | uniform 2; 3 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/Optional/ccm26ToFoam/Make/files: -------------------------------------------------------------------------------- 1 | ccm26ToFoam.C 2 | 3 | EXE = $(FOAM_APPBIN)/ccm26ToFoam 4 | -------------------------------------------------------------------------------- /src/mesh/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( blockMesh ) 2 | add_subdirectory( extrudeModel ) 3 | add_subdirectory( snappyHexMesh ) 4 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/createFields.H: -------------------------------------------------------------------------------- 1 | #include "createFluidFields.H" 2 | #include "createSolidFields.H" 3 | -------------------------------------------------------------------------------- /applications/test/ensightFoamReader/global_extern_proto.h: -------------------------------------------------------------------------------- 1 | ../../utilities/postProcessing/graphics/ensightFoamReader/global_extern_proto.h -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( PV3Readers ) 2 | add_subdirectory( ensightFoamReader ) 3 | -------------------------------------------------------------------------------- /bin/tools/README: -------------------------------------------------------------------------------- 1 | Misc. tools, scripts, templates that are useful (eg, for building applications) 2 | but don't need to be in the PATH. 3 | -------------------------------------------------------------------------------- /src/fvAgglomerationMethods/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( MGridGenGamgAgglomeration ) 2 | add_subdirectory( pairPatchAgglomeration ) 3 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/initContinuityErrs.H: -------------------------------------------------------------------------------- 1 | List cumulativeContErr(fluidRegions.size(), 0.0); 2 | -------------------------------------------------------------------------------- /applications/utilities/mesh/generation/extrude/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( extrudeToRegionMesh ) 2 | add_subdirectory( extrudeMesh ) 3 | -------------------------------------------------------------------------------- /src/meshTools/momentOfInertia/volInt.ps.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stuart23/cmake-OpenFOAM/HEAD/src/meshTools/momentOfInertia/volInt.ps.gz -------------------------------------------------------------------------------- /applications/solvers/compressible/sonicFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | volScalarField& e = thermo.he(); 2 | const volScalarField& psi = thermo.psi(); 3 | -------------------------------------------------------------------------------- /applications/solvers/discreteMethods/molecularDynamics/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( mdEquilibrationFoam ) 2 | add_subdirectory( mdFoam ) 3 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/storeOldFluidFields.H: -------------------------------------------------------------------------------- 1 | p_rghFluid[i].storePrevIter(); 2 | rhoFluid[i].storePrevIter(); 3 | -------------------------------------------------------------------------------- /applications/test/patchRegion/README: -------------------------------------------------------------------------------- 1 | 2013-05-27 Detect 'pinches' in patch (i.e., non-manifold on point). Run on 2 | cavity_pinched subdirectory. 3 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createTime.H: -------------------------------------------------------------------------------- 1 | Foam::Info<< "Create time\n" << Foam::endl; 2 | 3 | Foam::Time runTime(Foam::Time::controlDictName, args); 4 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/setRootCase.H: -------------------------------------------------------------------------------- 1 | Foam::argList args(argc, argv); 2 | if (!args.checkRootCase()) 3 | { 4 | Foam::FatalError.exit(); 5 | } 6 | -------------------------------------------------------------------------------- /src/parallel/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( decompose ) 2 | add_subdirectory( reconstruct/reconstruct ) 3 | add_subdirectory( distributed ) 4 | -------------------------------------------------------------------------------- /src/renumber/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( renumberMethods ) 2 | add_subdirectory( SloanRenumber ) 3 | add_subdirectory( zoltanRenumber ) 4 | -------------------------------------------------------------------------------- /applications/solvers/combustion/coldEngineFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | const volScalarField& T = thermo.T(); 3 | -------------------------------------------------------------------------------- /applications/solvers/combustion/reactingFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | const volScalarField& T = thermo.T(); 3 | -------------------------------------------------------------------------------- /applications/solvers/discreteMethods/dsmc/dsmcFoam/createFields.H: -------------------------------------------------------------------------------- 1 | Info<< nl << "Constructing dsmcCloud " << endl; 2 | dsmcCloud dsmc("dsmc", mesh); 3 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( solidEquilibriumDisplacementFoam ) 2 | add_subdirectory( solidDisplacementFoam ) 3 | -------------------------------------------------------------------------------- /src/TurbulenceModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( turbulenceModels ) 2 | add_subdirectory( incompressible ) 3 | add_subdirectory( compressible ) 4 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& T = thermo.T(); 2 | const volScalarField& psi = thermo.psi(); 3 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/addOverwriteOption.H: -------------------------------------------------------------------------------- 1 | Foam::argList::addBoolOption 2 | ( 3 | "overwrite", 4 | "overwrite existing mesh/results files" 5 | ); 6 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/addRegionOption.H: -------------------------------------------------------------------------------- 1 | Foam::argList::addOption 2 | ( 3 | "region", 4 | "name", 5 | "specify alternative mesh region" 6 | ); 7 | -------------------------------------------------------------------------------- /applications/solvers/basic/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( potentialFoam ) 2 | add_subdirectory( laplacianFoam ) 3 | add_subdirectory( scalarTransportFoam ) 4 | -------------------------------------------------------------------------------- /applications/solvers/electromagnetics/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( electrostaticFoam ) 2 | add_subdirectory( magneticFoam ) 3 | add_subdirectory( mhdFoam ) 4 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( PV3FoamReader ) 2 | add_subdirectory( vtkPV3Foam ) 3 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/checkTimeOptionsNoConstant.H: -------------------------------------------------------------------------------- 1 | Foam::label startTime = 0; 2 | 3 | // Check -time and -latestTime options 4 | #include "checkTimeOption.H" 5 | -------------------------------------------------------------------------------- /src/lagrangian/molecularDynamics/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( potential ) 2 | add_subdirectory( molecularMeasurements ) 3 | add_subdirectory( molecule ) 4 | -------------------------------------------------------------------------------- /applications/solvers/combustion/engineFoam/readEngineTimeControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | maxDeltaT = runTime.userTimeToTime(maxDeltaT); 4 | -------------------------------------------------------------------------------- /applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | const volScalarField& T = thermo.T(); 3 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/addDictOption.H: -------------------------------------------------------------------------------- 1 | Foam::argList::addOption 2 | ( 3 | "dict", 4 | "file", 5 | "read control dictionary from specified location" 6 | ); 7 | -------------------------------------------------------------------------------- /applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | const volScalarField& T = thermo.T(); 3 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/createControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& stressControl = mesh.solutionDict().subDict("stressAnalysis"); 2 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToGMV/gmvOutputTail.H: -------------------------------------------------------------------------------- 1 | gmvFile 2 | << "probtime " << runTime.timeName() << nl 3 | << "endgmv" << nl; 4 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/createMeshes.H: -------------------------------------------------------------------------------- 1 | regionProperties rp(runTime); 2 | 3 | #include "createFluidMeshes.H" 4 | #include "createSolidMeshes.H" 5 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/readSteadyStressFoamControls.H: -------------------------------------------------------------------------------- 1 | scalar accFac(readScalar(stressControl.lookup("accelerationFactor"))); 2 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( vtkPV3blockMesh ) 2 | add_subdirectory( PV3blockMeshReader ) 3 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/readEngineTimeControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | maxDeltaT = runTime.userTimeToTime(maxDeltaT); 4 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | maxAcousticCo = readScalar(runTime.controlDict().lookup("maxAcousticCo")); 4 | -------------------------------------------------------------------------------- /applications/utilities/mesh/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( generation ) 2 | add_subdirectory( advanced ) 3 | add_subdirectory( conversion ) 4 | add_subdirectory( manipulation ) 5 | -------------------------------------------------------------------------------- /src/OpenFOAM/db/dynamicLibrary/dynamicCode/installPaths.H.in: -------------------------------------------------------------------------------- 1 | #cmakedefine INCLUDE_DIRECTORY "@INCLUDE_DIRECTORY@" 2 | #cmakedefine LIBRARY_DIRECTORY "@LIBRARY_DIRECTORY@" 3 | 4 | -------------------------------------------------------------------------------- /src/dummyThirdParty/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( scotchDecomp ) 2 | add_subdirectory( ptscotchDecomp ) 3 | add_subdirectory( metisDecomp ) 4 | add_subdirectory( MGridGen ) 5 | -------------------------------------------------------------------------------- /applications/solvers/combustion/fireFoam/createPyrolysisModel.H: -------------------------------------------------------------------------------- 1 | Info<< "Creating pyrolysis model" << endl; 2 | 3 | regionModels::pyrolysisModels::pyrolysisModelCollection pyrolysis(mesh); 4 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/kivaToFoam/kiva3v-valves.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stuart23/cmake-OpenFOAM/HEAD/applications/utilities/mesh/conversion/kivaToFoam/kiva3v-valves.pdf -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( PV3blockMeshReader ) 2 | add_subdirectory( PV3FoamReader ) 3 | add_subdirectory( vtkPV3Readers ) 4 | -------------------------------------------------------------------------------- /applications/solvers/combustion/fireFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | const volScalarField& psi = thermo.psi(); 2 | const volScalarField& T = thermo.T(); 3 | filmModelType& surfaceFilm = tsurfaceFilm(); 4 | -------------------------------------------------------------------------------- /src/functionObjects/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( field ) 2 | add_subdirectory( forces ) 3 | add_subdirectory( lagrangian ) 4 | add_subdirectory( solvers ) 5 | add_subdirectory( utilities ) 6 | -------------------------------------------------------------------------------- /src/thermophysicalModels/radiation/include/createRadiationModel.H: -------------------------------------------------------------------------------- 1 | autoPtr radiation 2 | ( 3 | radiation::radiationModel::New(thermo.T()) 4 | ); 5 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/readControls.H: -------------------------------------------------------------------------------- 1 | runTime.controlDict().lookup("adjustTimeStep") >> adjustTimeStep; 2 | 3 | maxDeltaT = readScalar(runTime.controlDict().lookup("maxDeltaT")); 4 | -------------------------------------------------------------------------------- /applications/utilities/mesh/manipulation/checkMesh/printMeshStats.H: -------------------------------------------------------------------------------- 1 | namespace Foam 2 | { 3 | class polyMesh; 4 | 5 | void printMeshStats(const polyMesh& mesh, const bool allTopology); 6 | } 7 | -------------------------------------------------------------------------------- /src/meshTools/momentOfInertia/volumeIntegration/tetra: -------------------------------------------------------------------------------- 1 | 4 2 | 3 | 0 0 0 4 | 5 0 0 5 | 0 4 0 6 | 0 0 3 7 | 8 | 4 9 | 10 | 3 0 3 2 11 | 3 3 0 1 12 | 3 2 1 0 13 | 3 1 2 3 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | scalar maxAcousticCo 4 | ( 5 | readScalar(runTime.controlDict().lookup("maxAcousticCo")) 6 | ); 7 | -------------------------------------------------------------------------------- /applications/test/dictionary/testDictInc: -------------------------------------------------------------------------------- 1 | inlet_4 2 | { 3 | type inletOutlet; 4 | inletValue $internalField; 5 | value $internalField; 6 | } 7 | -------------------------------------------------------------------------------- /applications/test/fieldMapping/README.txt: -------------------------------------------------------------------------------- 1 | Test application for volField and surfaceField mapping with topology 2 | changes. 3 | 4 | Run 5 | 6 | pipe1D/Allrun 7 | 8 | to compile and map a few fields 9 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/createControls.H: -------------------------------------------------------------------------------- 1 | Switch adjustTimeStep(runTime.controlDict().lookup("adjustTimeStep")); 2 | scalar maxDeltaT(readScalar(runTime.controlDict().lookup("maxDeltaT"))); 3 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/setDeltaT.H: -------------------------------------------------------------------------------- 1 | if (adjustTimeStep) 2 | { 3 | runTime.setDeltaT(min(dtChem, maxDeltaT)); 4 | Info<< "deltaT = " << runTime.deltaT().value() << endl; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/createMRF.H: -------------------------------------------------------------------------------- 1 | IOMRFZoneList MRF(mesh); 2 | MRF.correctBoundaryVelocity(U1); 3 | MRF.correctBoundaryVelocity(U2); 4 | MRF.correctBoundaryVelocity(U); 5 | -------------------------------------------------------------------------------- /applications/utilities/parallelProcessing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( decomposePar ) 2 | add_subdirectory( redistributePar ) 3 | add_subdirectory( reconstructParMesh ) 4 | add_subdirectory( reconstructPar ) 5 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/miscellaneous/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( pdfPlot ) 2 | add_subdirectory( engineCompRatio ) 3 | add_subdirectory( postChannel ) 4 | add_subdirectory( temporalInterpolate ) 5 | -------------------------------------------------------------------------------- /bin/tools/scanpackages: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # 3 | # Generate Packages file on debian repositories. 4 | 5 | for D in `find . -mindepth 4 -type d` 6 | do 7 | dpkg-scanpackages $D | gzip -9c > ${D}/Packages.gz 8 | done 9 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/solveChemistry.H: -------------------------------------------------------------------------------- 1 | dtChem = chemistry.solve(runTime.deltaT().value()); 2 | scalar Sh = chemistry.Sh()()[0]/rho[0]; 3 | integratedHeat += Sh*runTime.deltaT().value(); 4 | -------------------------------------------------------------------------------- /applications/solvers/electromagnetics/mhdFoam/readBPISOControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& Bpiso = mesh.solutionDict().subDict("BPISO"); 2 | 3 | const int nBcorr = Bpiso.lookupOrDefault("nCorrectors", 1); 4 | 5 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoLiquidMixingFoam/alphaControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name()); 2 | 3 | label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles"))); 4 | -------------------------------------------------------------------------------- /src/OpenFOAM/global/caseDirs.H: -------------------------------------------------------------------------------- 1 | //#ifndef CASE_DIRS 2 | //#define CASE_DIRS 3 | 4 | namespace Foam 5 | { 6 | extern Foam::string FOAM_CASE; 7 | extern Foam::string FOAM_CASENAME; 8 | } 9 | //#endif 10 | -------------------------------------------------------------------------------- /applications/solvers/electromagnetics/mhdFoam/magneticFieldErr.H: -------------------------------------------------------------------------------- 1 | Info<< "magnetic flux divergence error = " 2 | << runTime.deltaTValue() 3 | *mag(fvc::div(phiB))().weightedAverage(mesh.V()).value() 4 | << endl; 5 | -------------------------------------------------------------------------------- /src/parallel/decompose/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( decompose ) 2 | add_subdirectory( metisDecomp ) 3 | add_subdirectory( ptscotchDecomp ) 4 | add_subdirectory( decompositionMethods ) 5 | add_subdirectory( scotchDecomp ) 6 | -------------------------------------------------------------------------------- /src/thermophysicalModels/properties/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( liquidProperties ) 2 | add_subdirectory( liquidMixtureProperties ) 3 | add_subdirectory( solidProperties ) 4 | add_subdirectory( solidMixtureProperties ) 5 | -------------------------------------------------------------------------------- /applications/test/Field/Test-Field.C: -------------------------------------------------------------------------------- 1 | #include "Test-Field.H" 2 | 3 | int main() 4 | { 5 | Vector v1(1, 2); 6 | Vector v2(2, 3); 7 | 8 | std::cout << v1 + v2; 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVFoamReader/PVFoamReader/PVFoamReader.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | PVFoamReader.xml 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/engine/include/createEngineTime.H: -------------------------------------------------------------------------------- 1 | Info<< "Create engine time\n" << endl; 2 | 3 | engineTime runTime 4 | ( 5 | Time::controlDictName, 6 | args.rootPath(), 7 | args.caseName() 8 | ); 9 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/sprayFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing reacting cloud" << endl; 2 | basicSprayCloud parcels 3 | ( 4 | "sprayCloud", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | surfaceScalarField& phi = fluid.phi(); 2 | 3 | const IOMRFZoneList& MRF = fluid.MRF(); 4 | fv::options& fvOptions = fluid.fvOptions(); 5 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | PV3FoamReader.xml 4 | 5 | 6 | -------------------------------------------------------------------------------- /applications/solvers/combustion/fireFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing reacting cloud" << endl; 2 | basicReactingCloud parcels 3 | ( 4 | "reactingCloud1", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/solidDisplacementFoam/createControl.H: -------------------------------------------------------------------------------- 1 | const dictionary& stressControl = mesh.solutionDict().subDict("stressAnalysis"); 2 | 3 | Switch compactNormalStress(stressControl.lookup("compactNormalStress")); 4 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVblockMeshReader/PVblockMeshReader/PVblockMeshReader.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | PVblockMeshReader.xml 4 | 5 | 6 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/multiphaseEulerFoam/MRFCorrectBCs.H: -------------------------------------------------------------------------------- 1 | forAllIter(PtrDictionary, fluid.phases(), iter) 2 | { 3 | MRF.correctBoundaryVelocity(iter().U()); 4 | } 5 | 6 | MRF.correctBoundaryVelocity(U); 7 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/PV3blockMeshReader.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | PV3blockMeshReader.xml 4 | 5 | 6 | -------------------------------------------------------------------------------- /etc/templates/axisymmetricJet/Allclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # run from this directory 3 | 4 | # Source tutorial clean functions 5 | . $WM_PROJECT_DIR/bin/tools/CleanFunctions 6 | 7 | cleanCase 8 | rm constant/polyMesh/boundary 9 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/rhoPimpleDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p, 6 | rho, 7 | psi, 8 | dimensionedScalar("rAUf", dimTime, 1), 9 | divrhoU, 10 | pimple 11 | ); 12 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFilmFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing reacting cloud" << endl; 2 | basicReactingCloud parcels 3 | ( 4 | "reactingCloud1", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/solidDisplacementFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createControl.H" 2 | 3 | int nCorr = stressControl.lookupOrDefault("nCorrectors", 1); 4 | 5 | scalar convergenceTolerance(readScalar(stressControl.lookup("D"))); 6 | -------------------------------------------------------------------------------- /applications/utilities/surface/surfaceCoarsen/bunnylod/font.h: -------------------------------------------------------------------------------- 1 | #ifndef FONT_H 2 | #define FONT_H 3 | 4 | void PrintString(char *s,int x=0,int y=-1); 5 | void PostString(char *_s,int _x,int _y,float _life=5.0); 6 | void RenderStrings(); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /applications/utilities/thermophysical/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( equilibriumFlameT ) 2 | add_subdirectory( mixtureAdiabaticFlameT ) 3 | add_subdirectory( chemkinToFoam ) 4 | add_subdirectory( adiabaticFlameT ) 5 | add_subdirectory( equilibriumCO ) 6 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/solid/readSolidMultiRegionPIMPLEControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& pimple = mesh.solutionDict().subDict("PIMPLE"); 2 | 3 | int nNonOrthCorr = 4 | pimple.lookupOrDefault("nNonOrthogonalCorrectors", 0); 5 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing reacting cloud" << endl; 2 | basicReactingMultiphaseCloud parcels 3 | ( 4 | "reactingCloud1", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/pUf/DDtU.H: -------------------------------------------------------------------------------- 1 | ddtPhi1 = 2 | ( 3 | (phi1 - phi1.oldTime())/runTime.deltaT() 4 | ); 5 | 6 | ddtPhi2 = 7 | ( 8 | (phi2 - phi2.oldTime())/runTime.deltaT() 9 | ); 10 | -------------------------------------------------------------------------------- /applications/utilities/miscellaneous/foamHelp/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | 4 | wclean libso helpTypes 5 | wclean 6 | 7 | 8 | #------------------------------------------------------------------------------ 9 | -------------------------------------------------------------------------------- /applications/utilities/mesh/generation/extrude/extrudeMesh/createTimeExtruded.H: -------------------------------------------------------------------------------- 1 | Info<< "Create time\n" << endl; 2 | 3 | Time runTimeExtruded 4 | ( 5 | Time::controlDictName, 6 | args.rootPath(), 7 | args.caseName() 8 | ); 9 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/checkTimeOptions.H: -------------------------------------------------------------------------------- 1 | Foam::label startTime = 0; 2 | 3 | // Unless -constant is present, skip startTime if it is "constant" 4 | #include "checkConstantOption.H" 5 | 6 | // Check -time and -latestTime options 7 | #include "checkTimeOption.H" 8 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | correctPhi = pimple.dict().lookupOrDefault("correctPhi", false); 4 | 5 | checkMeshCourantNo = pimple.dict().lookupOrDefault("checkMeshCourantNo", false); 6 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | maxAcousticCo = readScalar(runTime.controlDict().lookup("maxAcousticCo")); 4 | correctPhi = pimple.dict().lookupOrDefault("correctPhi", true); 5 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( dataConversion ) 2 | add_subdirectory( noise ) 3 | add_subdirectory( miscellaneous ) 4 | add_subdirectory( postProcess ) 5 | # LEAVING OUT FOR NOW. NEEDS MORE WORK 6 | # add_subdirectory( graphics ) 7 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_stop_part_building.H: -------------------------------------------------------------------------------- 1 | // Not in use 2 | void USERD_stop_part_building(void) 3 | { 4 | #ifdef ENSIGHTDEBUG 5 | Info<< "Entering: USERD_stop_part_building" << endl << flush; 6 | #endif 7 | 8 | } 9 | -------------------------------------------------------------------------------- /applications/solvers/combustion/fireFoam/createSurfaceFilmModel.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing surface film model" << endl; 2 | 3 | typedef regionModels::surfaceFilmModels::surfaceFilmModel filmModelType; 4 | 5 | autoPtr tsurfaceFilm(filmModelType::New(mesh, g)); 6 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p, 6 | dimensionedScalar("rAUf", dimTime, 1), 7 | geometricZeroField(), 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/utilities/mesh/generation/extrude2DMesh/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | wclean libso extrude2DMesh 6 | wclean 7 | 8 | #------------------------------------------------------------------------------ 9 | -------------------------------------------------------------------------------- /src/lagrangian/molecularDynamics/molecule/mdTools/md.H: -------------------------------------------------------------------------------- 1 | #ifndef md_H 2 | #define md_H 3 | #include "potential.H" 4 | #include "moleculeCloud.H" 5 | #include "correlationFunction.H" 6 | #include "distribution.H" 7 | #include "reducedUnits.H" 8 | #endif 9 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p_rgh, 6 | dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1), 7 | geometricZeroField(), 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/utilities/mesh/generation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( extrude ) 2 | add_subdirectory( blockMesh ) 3 | add_subdirectory( foamyMesh ) 4 | add_subdirectory( extrude2DMesh/extrude2DMesh ) 5 | add_subdirectory( extrude2DMesh ) 6 | add_subdirectory( snappyHexMesh ) 7 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVFoamReader/PVFoamReader/PVFoamReader.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /applications/solvers/basic/potentialFoam/createControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& potentialFlow 2 | ( 3 | mesh.solutionDict().subDict("potentialFlow") 4 | ); 5 | 6 | const int nNonOrthCorr 7 | ( 8 | potentialFlow.lookupOrDefault("nNonOrthogonalCorrectors", 0) 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing reacting cloud" << endl; 2 | basicReactingMultiphaseCloud parcels 3 | ( 4 | "reactingCloud1", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/interDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p_rgh, 6 | surfaceScalarField("rAUf", fvc::interpolate(rAU)), 7 | geometricZeroField(), 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/pUf/DDtU.H: -------------------------------------------------------------------------------- 1 | ddtPhi1 = 2 | ( 3 | (phi1 - phi1.oldTime())/runTime.deltaT() 4 | ); 5 | 6 | ddtPhi2 = 7 | ( 8 | (phi2 - phi2.oldTime())/runTime.deltaT() 9 | ); 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | scalar dtChem = refCast(chemistry).deltaTChem()[0]; 2 | basicMultiComponentMixture& composition = thermo.composition(); 3 | PtrList& Y = composition.Y(); 4 | volScalarField& p = thermo.p(); 5 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/readSolidMultiRegionSIMPLEControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& simple = mesh.solutionDict().subDict("SIMPLE"); 2 | 3 | const int nNonOrthCorr = 4 | simple.lookupOrDefault("nNonOrthogonalCorrectors", 0); 5 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interPhaseChangeFoam/interPhaseChangeDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p_rgh, 6 | surfaceScalarField("rAUf", fvc::interpolate(rAU)), 7 | divU, 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/multiphaseEulerFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p_rgh, 6 | dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1), 7 | geometricZeroField(), 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/multiphaseEulerFoam/createMRFZones.H: -------------------------------------------------------------------------------- 1 | IOMRFZoneList MRF(mesh); 2 | 3 | forAllIter(PtrDictionary, fluid.phases(), iter) 4 | { 5 | MRF.correctBoundaryVelocity(iter().U()); 6 | } 7 | 8 | MRF.correctBoundaryVelocity(U); 9 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/alphaControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name()); 2 | 3 | label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr"))); 4 | 5 | label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles"))); 6 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/correctContErrs.H: -------------------------------------------------------------------------------- 1 | contErr1 = 2 | fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1) 3 | - (fvOptions(alpha1, rho1)&rho1); 4 | 5 | contErr2 = 6 | fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2) 7 | - (fvOptions(alpha2, rho2)&rho2); 8 | -------------------------------------------------------------------------------- /applications/solvers/stressAnalysis/solidDisplacementFoam/readSolidDisplacementFoamControls.H: -------------------------------------------------------------------------------- 1 | nCorr = stressControl.lookupOrDefault("nCorrectors", 1); 2 | convergenceTolerance = readScalar(stressControl.lookup("D")); 3 | stressControl.lookup("compactNormalStress") >> compactNormalStress; 4 | -------------------------------------------------------------------------------- /applications/utilities/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( parallelProcessing ) 2 | add_subdirectory( preProcessing ) 3 | add_subdirectory( surface ) 4 | add_subdirectory( thermophysical ) 5 | add_subdirectory( mesh ) 6 | add_subdirectory( postProcessing ) 7 | add_subdirectory( miscellaneous ) 8 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/YEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | forAll(Y, specieI) 3 | { 4 | volScalarField& Yi = Y[specieI]; 5 | 6 | solve 7 | ( 8 | fvm::ddt(rho, Yi) - chemistry.RR(specieI), 9 | mesh.solver("Yi") 10 | ); 11 | } 12 | } -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoCentralFoam/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | wclean libso BCs 6 | wclean 7 | wclean rhoCentralDyMFoam 8 | 9 | #------------------------------------------------------------------------------ 10 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/rhoPimpleDyMFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | correctPhi = pimple.dict().lookupOrDefault("correctPhi", true); 4 | 5 | checkMeshCourantNo = 6 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false); 7 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/interMixingFoam/alphaControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name()); 2 | 3 | label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr"))); 4 | 5 | label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles"))); 6 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/pUf/createDDtU.H: -------------------------------------------------------------------------------- 1 | surfaceScalarField ddtPhi1 2 | ( 3 | (phi1 - phi1.oldTime())/runTime.deltaT() 4 | ); 5 | 6 | surfaceScalarField ddtPhi2 7 | ( 8 | (phi2 - phi2.oldTime())/runTime.deltaT() 9 | ); 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVblockMeshReader/PVblockMeshReader/PVblockMeshReader.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_exit_routine.H: -------------------------------------------------------------------------------- 1 | // Do nothing 2 | void USERD_exit_routine 3 | ( 4 | void 5 | ) 6 | { 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_exit_routine" << endl 9 | << flush; 10 | #endif 11 | 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/transportModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( twoPhaseMixture ) 2 | add_subdirectory( interfaceProperties ) 3 | add_subdirectory( twoPhaseProperties ) 4 | add_subdirectory( incompressible ) 5 | add_subdirectory( compressible ) 6 | add_subdirectory( immiscibleIncompressibleTwoPhaseMixture ) 7 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/createMeshesPostProcess.H: -------------------------------------------------------------------------------- 1 | #include "createMeshes.H" 2 | 3 | if (!fluidRegions.size()) 4 | { 5 | FatalErrorIn(args.executable()) 6 | << "No fluid meshes present" << exit(FatalError); 7 | } 8 | 9 | fvMesh& mesh = fluidRegions[0]; 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/PV3blockMeshReader.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/checkConstantOption.H: -------------------------------------------------------------------------------- 1 | // Unless -constant is present, skip startTime if it is "constant" 2 | 3 | if 4 | ( 5 | !args.optionFound("constant") 6 | && (startTime < Times.size()-1) 7 | && (Times[startTime].name() == "constant") 8 | ) 9 | { 10 | startTime++; 11 | } 12 | -------------------------------------------------------------------------------- /src/parallel/decompose/decompositionMethods/Make/options: -------------------------------------------------------------------------------- 1 | EXE_INC = \ 2 | -I$(LIB_SRC)/meshTools/lnInclude \ 3 | -I$(LIB_SRC)/dynamicMesh/lnInclude \ 4 | -I$(LIB_SRC)/finiteVolume/lnInclude 5 | 6 | LIB_LIBS = \ 7 | -lmeshTools \ 8 | -ldynamicMesh \ 9 | -lfiniteVolume 10 | -------------------------------------------------------------------------------- /applications/solvers/combustion/PDRFoam/ftEqn.H: -------------------------------------------------------------------------------- 1 | if (composition.contains("ft")) 2 | { 3 | volScalarField& ft = composition.Y("ft"); 4 | 5 | solve 6 | ( 7 | betav*fvm::ddt(rho, ft) 8 | + mvConvection->fvmDiv(phi, ft) 9 | - fvm::laplacian(Db, ft) 10 | ); 11 | } 12 | -------------------------------------------------------------------------------- /src/regionModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( regionModel ) 2 | add_subdirectory( pyrolysisModels ) 3 | add_subdirectory( surfaceFilmModels ) 4 | add_subdirectory( surfaceFilmModels/derivedFvPatchFields/wallFunctions ) 5 | add_subdirectory( thermalBaffleModels ) 6 | add_subdirectory( regionCoupling ) 7 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | correctPhi = pimple.dict().lookupOrDefault("correctPhi", true); 4 | 5 | checkMeshCourantNo = 6 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false); 7 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/potentialFreeSurfaceFoam/potentialFreeSurfaceDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p_gh, 6 | surfaceScalarField("rAUf", fvc::interpolate(rAU)), 7 | geometricZeroField(), 8 | pimple 9 | ); 10 | 11 | #include "continuityErrs.H" 12 | -------------------------------------------------------------------------------- /applications/test/tensor2D/Test-tensor2D.C: -------------------------------------------------------------------------------- 1 | #include "tensor2D.H" 2 | #include "IOstreams.H" 3 | 4 | using namespace Foam; 5 | 6 | int main() 7 | { 8 | vector2D v1(1, 2), v2(3, 4); 9 | tensor2D t = v1*v2; 10 | 11 | Info<< "v1(1, 2)*v2(3, 4) = " << t << endl; 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /applications/utilities/miscellaneous/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( foamDictionary ) 2 | add_subdirectory( foamFormatConvert ) 3 | add_subdirectory( patchSummary ) 4 | add_subdirectory( foamHelp/helpTypes ) 5 | add_subdirectory( foamHelp ) 6 | add_subdirectory( foamList ) 7 | add_subdirectory( foamListTimes ) 8 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& simple = fluidRegions[i].solutionDict().subDict("SIMPLE"); 2 | 3 | const int nNonOrthCorr = 4 | simple.lookupOrDefault("nNonOrthogonalCorrectors", 0); 5 | 6 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_of_model_parts.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_get_number_of_model_parts(void) 3 | { 4 | #ifdef ENSIGHTDEBUG 5 | Info<< "Entering: USERD_get_number_of_model_parts" << endl << flush; 6 | #endif 7 | 8 | return Numparts_available; 9 | } 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/pUf/createDDtU.H: -------------------------------------------------------------------------------- 1 | surfaceScalarField ddtPhi1 2 | ( 3 | (phi1 - phi1.oldTime())/runTime.deltaT() 4 | ); 5 | 6 | surfaceScalarField ddtPhi2 7 | ( 8 | (phi2 - phi2.oldTime())/runTime.deltaT() 9 | ); 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_set_server_number.H: -------------------------------------------------------------------------------- 1 | void USERD_set_server_number 2 | ( 3 | int cur_serv, 4 | int tot_serv 5 | ) 6 | { 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_set_server_number" << endl 9 | << flush; 10 | #endif 11 | 12 | } 13 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/toBeFunctionObjects/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( lagrangian\particleTracks ) 2 | add_subdirectory( lagrangian\steadyParticleTracks ) 3 | add_subdirectory( streamFunction ) 4 | add_subdirectory( wallHeatFlux ) 5 | add_subdirectory( wdot ) 6 | add_subdirectory( writeCellCentres ) 7 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/solutionControl/createControl.H: -------------------------------------------------------------------------------- 1 | #if defined(NO_CONTROL) 2 | #elif defined(PISO_CONTROL) 3 | #include "createPisoControl.H" 4 | #elif defined(PIMPLE_CONTROL) 5 | #include "createPimpleControl.H" 6 | #elif defined(SIMPLE_CONTROL) 7 | #include "createSimpleControl.H" 8 | #endif 9 | -------------------------------------------------------------------------------- /src/meshTools/momentOfInertia/volumeIntegration/cube: -------------------------------------------------------------------------------- 1 | 8 2 | 3 | -10 -10 -10 4 | +10 -10 -10 5 | +10 +10 -10 6 | -10 +10 -10 7 | -10 -10 +10 8 | +10 -10 +10 9 | +10 +10 +10 10 | -10 +10 +10 11 | 12 | 6 13 | 14 | 4 0 3 2 1 15 | 4 4 5 6 7 16 | 4 0 1 5 4 17 | 4 6 2 3 7 18 | 4 1 2 6 5 19 | 4 0 4 7 3 20 | 21 | 22 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/hEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& h = thermo.he(); 3 | 4 | if (constProp == "volume") 5 | { 6 | h[0] = u0 + p[0]/rho[0] + integratedHeat; 7 | } 8 | else 9 | { 10 | h[0] = h0 + integratedHeat; 11 | } 12 | 13 | thermo.correct(); 14 | } 15 | -------------------------------------------------------------------------------- /applications/utilities/mesh/manipulation/checkMesh/checkMeshQuality.H: -------------------------------------------------------------------------------- 1 | #include "polyMesh.H" 2 | 3 | namespace Foam 4 | { 5 | class surfaceWriter; 6 | 7 | label checkMeshQuality 8 | ( 9 | const polyMesh&, 10 | const dictionary&, 11 | const autoPtr& 12 | ); 13 | } 14 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/correctPhi.H: -------------------------------------------------------------------------------- 1 | CorrectPhi 2 | ( 3 | U, 4 | phi, 5 | p, 6 | dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1), 7 | divU, 8 | pimple 9 | ); 10 | 11 | //***HGW phi.oldTime() = phi; 12 | 13 | #include "continuityErrs.H" 14 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | wclean libso vtkPVReaders 6 | PVblockMeshReader/Allwclean 7 | PVFoamReader/Allwclean 8 | 9 | #------------------------------------------------------------------------------ 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | scalar maxAcousticCo 4 | ( 5 | readScalar(runTime.controlDict().lookup("maxAcousticCo")) 6 | ); 7 | 8 | bool correctPhi 9 | ( 10 | pimple.dict().lookupOrDefault("correctPhi", true) 11 | ); 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | wclean libso vtkPV3Readers 6 | PV3blockMeshReader/Allwclean 7 | PV3FoamReader/Allwclean 8 | 9 | #------------------------------------------------------------------------------ 10 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFilmFoam/createSurfaceFilmModel.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing surface film model" << endl; 2 | 3 | typedef regionModels::surfaceFilmModels::surfaceFilmModel filmModelType; 4 | 5 | autoPtr tsurfaceFilm(filmModelType::New(mesh, g)); 6 | filmModelType& surfaceFilm = tsurfaceFilm(); 7 | 8 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoCentralFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | volScalarField& p = thermo.p(); 2 | const volScalarField& T = thermo.T(); 3 | const volScalarField& psi = thermo.psi(); 4 | const volScalarField& mu = thermo.mu(); 5 | 6 | bool inviscid(true); 7 | if (max(mu.primitiveField()) > 0.0) 8 | { 9 | inviscid = false; 10 | } 11 | -------------------------------------------------------------------------------- /applications/utilities/surface/surfaceCoarsen/bunnylod/README: -------------------------------------------------------------------------------- 1 | 2 | Polygon Reduction Demo 3 | By Stan Melax (c) 1998 4 | mailto:melax@cs.ualberta.ca 5 | http://www.cs.ualberta.ca/~melax 6 | 7 | The PC executable bunnylod.exe should run 8 | on a standard PC. 9 | Just run it and enjoy. 10 | Mouse dragging spins the rabbit. 11 | 12 | 13 | -------------------------------------------------------------------------------- /etc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set( CONFIG_FILES 2 | controlDict 3 | cellModels 4 | ) 5 | 6 | set( CONFIG_DIRECTORIES 7 | codeTemplates 8 | caseDicts 9 | ) 10 | 11 | install( FILES ${CONFIG_FILES} 12 | DESTINATION ${CMAKE_INSTALL_PREFIX}/etc ) 13 | 14 | install( DIRECTORY ${CONFIG_DIRECTORIES} 15 | DESTINATION ${CMAKE_INSTALL_PREFIX}/etc ) 16 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/rhoPimpleDyMFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | bool correctPhi 4 | ( 5 | pimple.dict().lookupOrDefault("correctPhi", true) 6 | ); 7 | 8 | bool checkMeshCourantNo 9 | ( 10 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false) 11 | ); 12 | -------------------------------------------------------------------------------- /etc/templates/closedVolumeRotating/README: -------------------------------------------------------------------------------- 1 | Overview 2 | ======== 3 | + Template case for rotating geometry flow for a closed geometry 4 | + Can be used for MRF or AMI simulations 5 | + Setup to run the simpleFoam solver 6 | + Set up is like inflowOutflowRotating but without inlet and outlet 7 | + See $FOAM_ETC/templates/closedVolume/README for details of use -------------------------------------------------------------------------------- /applications/solvers/combustion/coldEngineFoam/startSummary.H: -------------------------------------------------------------------------------- 1 | Info<< "Total cylinder mass: " << fvc::domainIntegrate(rho).value() << endl; 2 | 3 | OFstream logSummaryFile 4 | ( 5 | runTime.path()/("logSummary." + runTime.timeName() + ".dat") 6 | ); 7 | 8 | logSummaryFile 9 | << "# CA" << " p" << " T" << " u'" << endl; 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_matf_set_info.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_get_matf_set_info 3 | ( 4 | int *mat_set_ids, 5 | char **mat_set_name 6 | ) 7 | { 8 | #ifdef ENSIGHTDEBUG 9 | Info<< "Entering: USERD_get_matf_set_info" << endl 10 | << flush; 11 | #endif 12 | 13 | return Z_ERR; 14 | } 15 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_timesets.H: -------------------------------------------------------------------------------- 1 | int USERD_get_number_of_timesets 2 | ( 3 | void 4 | ) 5 | { 6 | #ifdef ENSIGHTDEBUG 7 | Info<< "Entering: USERD_get_number_of_timesets" << endl 8 | << flush; 9 | #endif 10 | 11 | Num_timesets = 1; 12 | return Num_timesets; 13 | } 14 | -------------------------------------------------------------------------------- /src/lagrangian/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( distributionModels ) 2 | add_subdirectory( basic ) 3 | add_subdirectory( solidParticle ) 4 | add_subdirectory( intermediate ) 5 | add_subdirectory( turbulence ) 6 | add_subdirectory( spray ) 7 | add_subdirectory( DSMC ) 8 | add_subdirectory( coalCombustion ) 9 | add_subdirectory( molecularDynamics ) 10 | -------------------------------------------------------------------------------- /src/parallel/decompose/AllwmakeLnInclude: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | wmakeLnInclude decompositionMethods 6 | wmakeLnInclude metisDecomp 7 | wmakeLnInclude scotchDecomp 8 | wmakeLnInclude ptscotchDecomp 9 | 10 | #------------------------------------------------------------------------------ 11 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createControl.H" 2 | #include "createTimeControls.H" 3 | 4 | bool correctPhi 5 | ( 6 | pimple.dict().lookupOrDefault("correctPhi", false) 7 | ); 8 | 9 | bool checkMeshCourantNo 10 | ( 11 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false) 12 | ); 13 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/createControls.H: -------------------------------------------------------------------------------- 1 | #include "createTimeControls.H" 2 | 3 | bool correctPhi 4 | ( 5 | pimple.dict().lookupOrDefault("correctPhi", true) 6 | ); 7 | 8 | bool checkMeshCourantNo 9 | ( 10 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false) 11 | ); 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/toBeFunctionObjects/lagrangian/steadyParticleTracks/createFields.H: -------------------------------------------------------------------------------- 1 | const word dictName("particleTrackDict"); 2 | 3 | #include "setConstantMeshDictionaryIO.H" 4 | 5 | IOdictionary propsDict(dictIO); 6 | 7 | word cloudName(propsDict.lookup("cloudName")); 8 | 9 | List userFields(propsDict.lookup("fields")); 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_of_material_sets.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_get_number_of_material_sets 3 | ( 4 | void 5 | ) 6 | { 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_get_number_of_material_sets" << endl 9 | << flush; 10 | #endif 11 | 12 | // No materials 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_of_materials.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_get_number_of_materials 3 | ( 4 | int set_index 5 | ) 6 | { 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_get_number_of_materials" << endl 9 | << flush; 10 | #endif 11 | 12 | // No materials 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createMesh.H: -------------------------------------------------------------------------------- 1 | Foam::Info 2 | << "Create mesh for time = " 3 | << runTime.timeName() << Foam::nl << Foam::endl; 4 | 5 | Foam::fvMesh mesh 6 | ( 7 | Foam::IOobject 8 | ( 9 | Foam::fvMesh::defaultRegion, 10 | runTime.timeName(), 11 | runTime, 12 | Foam::IOobject::MUST_READ 13 | ) 14 | ); 15 | -------------------------------------------------------------------------------- /src/lagrangian/spray/submodels/BreakupModel/TAB/TABSMDCalcMethod1.H: -------------------------------------------------------------------------------- 1 | { 2 | bool found = false; 3 | scalar random = rndGen.sample01(); 4 | while (!found && (n<99)) 5 | { 6 | if (rrd_[n]>random) 7 | { 8 | found = true; 9 | } 10 | n++; 11 | } 12 | rNew = 0.04*n*rs; 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/pU/DDtU.H: -------------------------------------------------------------------------------- 1 | { 2 | DDtU1 = 3 | fvc::ddt(U1) 4 | + fvc::div(phi1, U1) 5 | - fvc::div(phi1)*U1; 6 | MRF.addAcceleration(U1, DDtU1); 7 | 8 | DDtU2 = 9 | fvc::ddt(U2) 10 | + fvc::div(phi2, U2) 11 | - fvc::div(phi2)*U2; 12 | MRF.addAcceleration(U2, DDtU2); 13 | } 14 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( thermoFoam ) 2 | add_subdirectory( buoyantPimpleFoam ) 3 | add_subdirectory( chtMultiRegionFoam ) 4 | add_subdirectory( chtMultiRegionFoam/chtMultiRegionSimpleFoam ) 5 | add_subdirectory( buoyantSimpleFoam ) 6 | add_subdirectory( buoyantBoussinesqPimpleFoam ) 7 | add_subdirectory( buoyantBoussinesqSimpleFoam ) 8 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_matf_var_info.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_get_matf_var_info 3 | ( 4 | int set_index, 5 | int *mat_ids, 6 | char **mat_desc 7 | ) 8 | { 9 | #ifdef ENSIGHTDEBUG 10 | Info<< "Entering: USERD_get_matf_var_info" << endl 11 | << flush; 12 | #endif 13 | 14 | return Z_ERR; 15 | } 16 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_model_extents.H: -------------------------------------------------------------------------------- 1 | 2 | // Not used. Let EnSight do the job. 3 | 4 | int USERD_get_model_extents 5 | ( 6 | float extents[6] 7 | ) 8 | { 9 | #ifdef ENSIGHTDEBUG 10 | Info<< "Entering: USERD_get_model_extents" << endl 11 | << flush; 12 | #endif 13 | 14 | return Z_ERR; 15 | } 16 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_geom_timeset_number.H: -------------------------------------------------------------------------------- 1 | int USERD_get_geom_timeset_number 2 | ( 3 | void 4 | ) 5 | { 6 | #ifdef ENSIGHTDEBUG 7 | Info<< "Entering: USERD_get_geom_timeset_number" << endl 8 | << flush; 9 | #endif 10 | 11 | Geom_timeset_number = 1; 12 | 13 | return Geom_timeset_number; 14 | } 15 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_of_variables.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | int USERD_get_number_of_variables(void) 3 | { 4 | #ifdef ENSIGHTDEBUG 5 | Info<< "Entering: USERD_get_number_of_variables" << endl << flush; 6 | #endif 7 | 8 | return Num_variables; 9 | } 10 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/checkTimeOption.H: -------------------------------------------------------------------------------- 1 | // Check -time and -latestTime options 2 | 3 | if (args.optionFound("time")) 4 | { 5 | Foam::scalar timeValue = args.optionRead("time"); 6 | 7 | startTime = Foam::Time::findClosestTimeIndex(Times, timeValue); 8 | } 9 | 10 | if (args.optionFound("latestTime")) 11 | { 12 | startTime = Times.size() - 1; 13 | } 14 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createPolyMesh.H: -------------------------------------------------------------------------------- 1 | Foam::Info 2 | << "Create polyMesh for time = " 3 | << runTime.timeName() << Foam::nl << Foam::endl; 4 | 5 | Foam::polyMesh mesh 6 | ( 7 | Foam::IOobject 8 | ( 9 | Foam::polyMesh::defaultRegion, 10 | runTime.timeName(), 11 | runTime, 12 | Foam::IOobject::MUST_READ 13 | ) 14 | ); 15 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/readGravitationalAcceleration.H: -------------------------------------------------------------------------------- 1 | Info<< "\nReading g" << endl; 2 | uniformDimensionedVectorField g 3 | ( 4 | IOobject 5 | ( 6 | "g", 7 | runTime.constant(), 8 | mesh, 9 | IOobject::MUST_READ, 10 | IOobject::NO_WRITE 11 | ) 12 | ); 13 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/readPIMPLEControls.H: -------------------------------------------------------------------------------- 1 | // We do not have a top-level mesh. Construct the fvSolution for 2 | // the runTime instead. 3 | fvSolution solutionDict(runTime); 4 | 5 | const dictionary& pimple = solutionDict.subDict("PIMPLE"); 6 | 7 | const int nOuterCorr = 8 | pimple.lookupOrDefault("nOuterCorrectors", 1); 9 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/multiphaseEulerFoam/DDtU.H: -------------------------------------------------------------------------------- 1 | forAllIter(PtrDictionary, fluid.phases(), iter) 2 | { 3 | phaseModel& phase = iter(); 4 | 5 | phase.DDtU() = 6 | fvc::ddt(phase.U()) 7 | + fvc::div(phase.phi(), phase.U()) 8 | - fvc::div(phase.phi())*phase.U(); 9 | 10 | MRF.addAcceleration(phase.U(), phase.DDtU()); 11 | } 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/CourantNos.H: -------------------------------------------------------------------------------- 1 | #include "CourantNo.H" 2 | 3 | { 4 | scalar UrCoNum = 0.5*gMax 5 | ( 6 | fvc::surfaceSum(mag(phi1 - phi2))().primitiveField()/mesh.V().field() 7 | )*runTime.deltaTValue(); 8 | 9 | Info<< "Max Ur Courant Number = " << UrCoNum << endl; 10 | 11 | CoNum = max(CoNum, UrCoNum); 12 | } 13 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/contErrs.H: -------------------------------------------------------------------------------- 1 | volScalarField contErr1 2 | ( 3 | "contErr1", 4 | fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1) 5 | - (fvOptions(alpha1, rho1)&rho1) 6 | ); 7 | 8 | volScalarField contErr2 9 | ( 10 | "contErr2", 11 | fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2) 12 | - (fvOptions(alpha2, rho2)&rho2) 13 | ); 14 | -------------------------------------------------------------------------------- /applications/utilities/mesh/manipulation/checkMesh/checkTopology.H: -------------------------------------------------------------------------------- 1 | #include "label.H" 2 | #include "autoPtr.H" 3 | 4 | namespace Foam 5 | { 6 | class polyMesh; 7 | class surfaceWriter; 8 | 9 | label checkTopology 10 | ( 11 | const polyMesh&, 12 | const bool, 13 | const bool, 14 | const autoPtr& 15 | ); 16 | } 17 | -------------------------------------------------------------------------------- /applications/utilities/preProcessing/boxTurb/createFields.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading field U\n" << endl; 2 | 3 | volVectorField U 4 | ( 5 | IOobject 6 | ( 7 | "U", 8 | runTime.timeName(), 9 | mesh, 10 | IOobject::MUST_READ, 11 | IOobject::AUTO_WRITE 12 | ), 13 | mesh 14 | ); 15 | -------------------------------------------------------------------------------- /applications/test/hexRef8/README.txt: -------------------------------------------------------------------------------- 1 | Test application for volField and surfaceField mapping with 2 | refinement/unrefinement 3 | 4 | Run 5 | 6 | block/Allrun 7 | 8 | to compile and map a few fields. Note that hexRef8 cannot be 9 | run in inflation mode - there is the problem of getting 10 | a set of faces to sweep that is consistent for a cell and 11 | all its neighbours. 12 | -------------------------------------------------------------------------------- /applications/utilities/mesh/generation/foamyMesh/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( conformalVoronoiMesh ) 2 | add_subdirectory( conformalVoronoi2DMesh ) 3 | add_subdirectory( foamyHexMesh ) 4 | add_subdirectory( foamyQuadMesh ) 5 | # # add_subdirectory( foamyHexMeshSurfaceSimplify ) 6 | # # add_subdirectory( foamyHexMeshBackgroundMesh ) 7 | # # add_subdirectory( cellSizeAndAlignmentGrid ) 8 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/output.H: -------------------------------------------------------------------------------- 1 | runTime.write(); 2 | 3 | Info<< "Sh = " << Sh 4 | << ", T = " << thermo.T()[0] 5 | << ", p = " << thermo.p()[0] 6 | << ", " << Y[0].name() << " = " << Y[0][0] 7 | << endl; 8 | 9 | post<< runTime.value() << token::TAB << thermo.T()[0] << token::TAB 10 | << thermo.p()[0] << endl; 11 | 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/rhoEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | fvScalarMatrix rhoEqn 3 | ( 4 | fvm::ddt(rho) 5 | + fvm::div(phi, rho) 6 | ); 7 | 8 | rhoEqn.solve(); 9 | 10 | rhoPhi = rhoEqn.flux(); 11 | 12 | Info<< "max-min rho: " << max(rho).value() 13 | << " " << min(rho).value() << endl; 14 | 15 | rho == max(rho, rhoMin); 16 | } 17 | -------------------------------------------------------------------------------- /applications/test/UniformField/Test-UniformField.C: -------------------------------------------------------------------------------- 1 | #include "UniformField.H" 2 | #include "vector.H" 3 | #include "IOstreams.H" 4 | 5 | using namespace Foam; 6 | 7 | int main() 8 | { 9 | UniformField uf1(13.1); 10 | UniformField uf2(vector(1, 2, 3)); 11 | 12 | Info<< "uf1 = " << uf1[22] << "; uf2 = " << uf2[1002] << endl; 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /doc/tools/README: -------------------------------------------------------------------------------- 1 | Misc. tools for finding and/or repairing common documentation problems 2 | See the comments in the scripts. 3 | 4 | 1. find-suspiciousTags 5 | 2. fix-Class 6 | 3. find-tinyDescription 7 | 4. find-placeholderDescription 8 | 5. find-retagged 9 | 10 | Misc Tools 11 | 1. find-templateInComments 12 | 2. find-its 13 | 3. find-junkFiles 14 | 4. find-longlines 15 | 16 | -------------------------------------------------------------------------------- /applications/solvers/combustion/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( coldEngineFoam ) 2 | add_subdirectory( fireFoam ) 3 | add_subdirectory( engineFoam ) 4 | add_subdirectory( XiFoam ) 5 | add_subdirectory( PDRFoam ) 6 | add_subdirectory( reactingFoam ) 7 | add_subdirectory( reactingFoam/rhoReactingBuoyantFoam ) 8 | add_subdirectory( reactingFoam/rhoReactingFoam ) 9 | add_subdirectory( chemFoam ) 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/CourantNos.H: -------------------------------------------------------------------------------- 1 | #include "CourantNo.H" 2 | 3 | { 4 | scalar UrCoNum = 0.5*gMax 5 | ( 6 | fvc::surfaceSum(mag(phi1 - phi2))().primitiveField()/mesh.V().field() 7 | )*runTime.deltaTValue(); 8 | 9 | Info<< "Max Ur Courant Number = " << UrCoNum << endl; 10 | 11 | CoNum = max(CoNum, UrCoNum); 12 | } 13 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_dataset_query_file_info.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // NOT SUPPORTED... yet, if ever! 3 | //====================================================================== 4 | int USERD_get_dataset_query_file_info(Z_QFILES *qfiles) 5 | { 6 | // just return OK 7 | return Z_OK; 8 | } 9 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_size_matf_data.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_size_matf_data 3 | ( 4 | int set_index, 5 | int part_id, 6 | int wtyp, 7 | int mat_type, 8 | int *matf_size 9 | ) 10 | { 11 | #ifdef ENSIGHTDEBUG 12 | Info<< "Entering: USERD_size_matf_data" << endl 13 | << flush; 14 | #endif 15 | 16 | return Z_ERR; 17 | } 18 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/interDyMFoam/readControls.H: -------------------------------------------------------------------------------- 1 | #include "readTimeControls.H" 2 | 3 | correctPhi = pimple.dict().lookupOrDefault("correctPhi", true); 4 | 5 | checkMeshCourantNo = 6 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false); 7 | 8 | moveMeshOuterCorrectors = 9 | pimple.dict().lookupOrDefault("moveMeshOuterCorrectors", false); 10 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(rhoPhi, U) 5 | + turbulence->divDevRhoReff(rho, U) 6 | ); 7 | 8 | UEqn.relax(); 9 | 10 | if (pimple.momentumPredictor()) 11 | { 12 | solve(UEqn == -fvc::grad(p)); 13 | } 14 | 15 | Info<< "max(U) " << max(mag(U)).value() << endl; 16 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/Optional/ccm26ToFoam/Make/options: -------------------------------------------------------------------------------- 1 | LIBCCMIO_DIR = $(WM_THIRD_PARTY_DIR)/libccmio-2.6.1 2 | 3 | EXE_INC = \ 4 | -I$(LIB_SRC)/finiteVolume/lnInclude \ 5 | -I$(LIB_SRC)/meshTools/lnInclude \ 6 | -I$(LIBCCMIO_DIR) \ 7 | -I$(LIBCCMIO_DIR)/lnInclude 8 | 9 | EXE_LIBS = \ 10 | -lfiniteVolume \ 11 | -lmeshTools \ 12 | -L$(FOAM_EXT_LIBBIN) -lccmio 13 | -------------------------------------------------------------------------------- /applications/test/patchRegion/cavity_pinched/README.txt: -------------------------------------------------------------------------------- 1 | constant/ 2 | cavity blockMesh 3 | point (0.05 0.05 0.01) moved to (0.05 0.05 0.001) 4 | 5 | 0.005/ 6 | collapseEdges with 7 | 8 | collapseEdgesCoeffs.minimumEdgeLength 0.0011; 9 | 10 | so it collapses the one edge 11 | 12 | 13 | processor*/0.005/ 14 | decomposePar 15 | 16 | 17 | mpirun -np 2 Test-patchRegion -parallel 18 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVFoamReader/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | # deal with client/server vs combined plugins 6 | rm -f $FOAM_LIBBIN/libPVFoamReader* 2>/dev/null 7 | 8 | rm -rf PVFoamReader/Make 9 | wclean libso vtkPVFoam 10 | 11 | #------------------------------------------------------------------------------ 12 | -------------------------------------------------------------------------------- /applications/solvers/combustion/engineFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(phi, U) 5 | + turbulence->divDevRhoReff(U) 6 | == 7 | fvOptions(rho, U) 8 | ); 9 | 10 | if (pimple.momentumPredictor()) 11 | { 12 | solve(UEqn == -fvc::grad(p)); 13 | 14 | fvOptions.correct(U); 15 | K = 0.5*magSqr(U); 16 | } 17 | -------------------------------------------------------------------------------- /applications/solvers/discreteMethods/molecularDynamics/mdFoam/createFields.H: -------------------------------------------------------------------------------- 1 | Info<< "\nReading field U\n" << endl; 2 | volVectorField U 3 | ( 4 | IOobject 5 | ( 6 | "U", 7 | runTime.timeName(), 8 | mesh, 9 | IOobject::MUST_READ, 10 | IOobject::AUTO_WRITE 11 | ), 12 | mesh 13 | ); 14 | 15 | potential pot(mesh); 16 | 17 | moleculeCloud molecules(mesh, pot); 18 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | # deal with client/server vs combined plugins 6 | rm -f $FOAM_LIBBIN/libPV3FoamReader* 2>/dev/null 7 | 8 | rm -rf PV3FoamReader/Make 9 | wclean libso vtkPV3Foam 10 | 11 | #------------------------------------------------------------------------------ 12 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/readhRef.H: -------------------------------------------------------------------------------- 1 | Info<< "\nReading hRef" << endl; 2 | uniformDimensionedScalarField hRef 3 | ( 4 | IOobject 5 | ( 6 | "hRef", 7 | runTime.constant(), 8 | mesh, 9 | IOobject::READ_IF_PRESENT, 10 | IOobject::NO_WRITE 11 | ), 12 | dimensionedScalar("hRef", dimLength, 0) 13 | ); 14 | -------------------------------------------------------------------------------- /src/regionModels/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | makeType=${1:-libso} 4 | set -x 5 | 6 | wclean $makeType regionModel 7 | wclean $makeType pyrolysisModels 8 | wclean $makeType surfaceFilmModels 9 | wclean $makeType thermalBaffleModels 10 | wclean $makeType regionCoupling 11 | 12 | 13 | #------------------------------------------------------------------------------ 14 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/coalChemistryFoam/createClouds.H: -------------------------------------------------------------------------------- 1 | Info<< "\nConstructing coal cloud" << endl; 2 | coalCloud coalParcels 3 | ( 4 | "coalCloud1", 5 | rho, 6 | U, 7 | g, 8 | slgThermo 9 | ); 10 | 11 | Info<< "\nConstructing limestone cloud" << endl; 12 | basicThermoCloud limestoneParcels 13 | ( 14 | "limestoneCloud1", 15 | rho, 16 | U, 17 | g, 18 | slgThermo 19 | ); 20 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToEnsightParts/moveMesh.H: -------------------------------------------------------------------------------- 1 | { 2 | IOobject io 3 | ( 4 | "points", 5 | runTime.timeName(), 6 | polyMesh::meshSubDir, 7 | mesh 8 | ); 9 | 10 | if (io.headerOk()) 11 | { 12 | // Read new points 13 | io.readOpt() = IOobject::MUST_READ; 14 | mesh.movePoints(pointIOField(io)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_load_matf_data.H: -------------------------------------------------------------------------------- 1 | 2 | int USERD_load_matf_data 3 | ( 4 | int set_index, 5 | int part_id, 6 | int wtyp, 7 | int mat_type, 8 | int *ids_list, 9 | float *val_list 10 | ) 11 | { 12 | #ifdef ENSIGHTDEBUG 13 | Info<< "Entering: USERD_load_matf_data" << endl 14 | << flush; 15 | #endif 16 | 17 | return Z_ERR; 18 | } 19 | -------------------------------------------------------------------------------- /etc/templates/axisymmetricJet/Allrun: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # run from this directory 3 | 4 | # Source tutorial run functions 5 | . $WM_PROJECT_DIR/bin/tools/RunFunctions 6 | 7 | application=`getApplication` 8 | 9 | runApplication blockMesh 10 | runApplication extrudeMesh 11 | 12 | runApplication $application 13 | 14 | #------------------------------------------------------------------------------ 15 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/readpRef.H: -------------------------------------------------------------------------------- 1 | Info<< "\nReading pRef" << endl; 2 | uniformDimensionedScalarField pRef 3 | ( 4 | IOobject 5 | ( 6 | "pRef", 7 | runTime.constant(), 8 | mesh, 9 | IOobject::READ_IF_PRESENT, 10 | IOobject::NO_WRITE 11 | ), 12 | dimensionedScalar("pRef", dimPressure, 0) 13 | ); 14 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/interDyMFoam/createDyMControls.H: -------------------------------------------------------------------------------- 1 | bool correctPhi 2 | ( 3 | pimple.dict().lookupOrDefault("correctPhi", true) 4 | ); 5 | 6 | bool checkMeshCourantNo 7 | ( 8 | pimple.dict().lookupOrDefault("checkMeshCourantNo", false) 9 | ); 10 | 11 | bool moveMeshOuterCorrectors 12 | ( 13 | pimple.dict().lookupOrDefault("moveMeshOuterCorrectors", false) 14 | ); 15 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createMeshNoClear.H: -------------------------------------------------------------------------------- 1 | // Currently identical to createMesh.H 2 | 3 | Foam::Info 4 | << "Create mesh, no clear-out for time = " 5 | << runTime.timeName() << Foam::nl << Foam::endl; 6 | 7 | Foam::fvMesh mesh 8 | ( 9 | Foam::IOobject 10 | ( 11 | Foam::fvMesh::defaultRegion, 12 | runTime.timeName(), 13 | runTime, 14 | Foam::IOobject::MUST_READ 15 | ) 16 | ); 17 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/gh.H: -------------------------------------------------------------------------------- 1 | Info<< "Calculating field g.h\n" << endl; 2 | dimensionedScalar ghRef 3 | ( 4 | mag(g.value()) > SMALL 5 | ? g & (cmptMag(g.value())/mag(g.value()))*hRef 6 | : dimensionedScalar("ghRef", g.dimensions()*dimLength, 0) 7 | ); 8 | volScalarField gh("gh", (g & mesh.C()) - ghRef); 9 | surfaceScalarField ghf("ghf", (g & mesh.Cf()) - ghRef); 10 | -------------------------------------------------------------------------------- /applications/solvers/DNS/dnsFoam/globalProperties.H: -------------------------------------------------------------------------------- 1 | { 2 | Info<< "k(" << runTime.timeName() << ") = " 3 | << 3.0/2.0*average(magSqr(U)).value() << endl; 4 | 5 | Info<< "epsilon(" << runTime.timeName() << ") = " 6 | << (0.5*nu*average(magSqr(twoSymm(fvc::grad(U))))).value() << endl; 7 | 8 | Info<< "U.f(" << runTime.timeName() << ") = " 9 | << 181.0*average(U & force).value() << endl; 10 | } 11 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PVReaders/PVblockMeshReader/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | # deal with client/server vs combined plugins 6 | rm -f $FOAM_LIBBIN/libPVblockMeshReader* 2>/dev/null 7 | 8 | rm -rf PVblockMeshReader/Make 9 | wclean libso vtkPVblockMesh 10 | 11 | #------------------------------------------------------------------------------ 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_changing_geometry_status.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | int USERD_get_changing_geometry_status(void) 3 | { 4 | #ifdef ENSIGHTDEBUG 5 | Info<< "Entering: USERD_get_changing_geometry_status" << endl << flush; 6 | #endif 7 | 8 | // Choose the most general option 9 | return Z_CHANGE_CONN; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/Allwclean: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | set -x 4 | 5 | # deal with client/server vs combined plugins 6 | rm -f $FOAM_LIBBIN/libPV3blockMeshReader* 2>/dev/null 7 | 8 | rm -rf PV3blockMeshReader/Make 9 | wclean libso vtkPV3blockMesh 10 | 11 | #------------------------------------------------------------------------------ 12 | -------------------------------------------------------------------------------- /applications/solvers/combustion/chemFoam/pEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | rho = thermo.rho(); 3 | if (constProp == "volume") 4 | { 5 | scalar invW = 0.0; 6 | forAll(Y, i) 7 | { 8 | invW += Y[i][0]/specieData[i].W(); 9 | } 10 | 11 | Rspecific[0] = 1000.0*constant::physicoChemical::R.value()*invW; 12 | 13 | p[0] = rho0*Rspecific[0]*thermo.T()[0]; 14 | rho[0] = rho0; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /applications/solvers/compressible/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( rhoSimpleFoam ) 2 | add_subdirectory( rhoSimpleFoam/rhoPorousSimpleFoam ) 3 | add_subdirectory( sonicFoam ) 4 | add_subdirectory( sonicFoam/sonicDyMFoam ) 5 | add_subdirectory( sonicFoam/sonicLiquidFoam ) 6 | add_subdirectory( rhoCentralFoam/BCs ) 7 | add_subdirectory( rhoCentralFoam ) 8 | add_subdirectory( rhoPimpleFoam ) 9 | add_subdirectory( rhoPimpleFoam/rhoPimpleDyMFoam ) 10 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Requires third party lib 2 | # add_subdirectory( foamToTecplot360 ) 3 | add_subdirectory( foamToEnsightParts ) 4 | add_subdirectory( foamToGMV ) 5 | add_subdirectory( foamToTetDualMesh ) 6 | add_subdirectory( foamToEnsight ) 7 | add_subdirectory( foamDataToFluent ) 8 | add_subdirectory( smapToFoam ) 9 | add_subdirectory( foamToVTK/foamToVTK ) 10 | add_subdirectory( foamToVTK ) 11 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_border_availability.H: -------------------------------------------------------------------------------- 1 | 2 | // Not used 3 | 4 | int USERD_get_border_availability 5 | ( 6 | int part_number, 7 | int number_of_elements[Z_MAXTYPE] 8 | ) 9 | { 10 | #ifdef ENSIGHTDEBUG 11 | Info<< "Entering: USERD_get_border_availability for part_number " 12 | << part_number << endl 13 | << flush; 14 | #endif 15 | 16 | return Z_ERR; 17 | } 18 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/miscellaneous/postChannel/readTransportProperties.H: -------------------------------------------------------------------------------- 1 | Info<< nl << "Reading transportProperties" << endl; 2 | 3 | IOdictionary transportProperties 4 | ( 5 | IOobject 6 | ( 7 | "transportProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | -------------------------------------------------------------------------------- /applications/solvers/combustion/engineFoam/startSummary.H: -------------------------------------------------------------------------------- 1 | Info<< "Total cylinder mass: " << fvc::domainIntegrate(rho).value() << endl; 2 | //Info<< "Total fuel mass: " 3 | // << fvc::domainIntegrate(rho*compostion.ft()).value() << endl; 4 | 5 | OFstream logSummaryFile 6 | ( 7 | runTime.path()/("logSummary." + runTime.timeName() + ".dat") 8 | ); 9 | 10 | logSummaryFile 11 | << "# CA" << " p" << " T" << " u'" << endl; 12 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/createPcorrTypes.H: -------------------------------------------------------------------------------- 1 | wordList pcorrTypes 2 | ( 3 | p.boundaryField().size(), 4 | zeroGradientFvPatchScalarField::typeName 5 | ); 6 | 7 | for (label i=0; i("nCorrectors", 1); 5 | 6 | const int nNonOrthCorr = 7 | pimple.lookupOrDefault("nNonOrthogonalCorrectors", 0); 8 | 9 | const bool momentumPredictor = 10 | pimple.lookupOrDefault("momentumPredictor", true); 11 | -------------------------------------------------------------------------------- /applications/utilities/preProcessing/mapFieldsPar/createTimes.H: -------------------------------------------------------------------------------- 1 | Info<< "\nCreate databases as time" << endl; 2 | 3 | HashTable srcOptions(args.options()); 4 | srcOptions.erase("case"); 5 | srcOptions.insert("case", fileName(rootDirSource/caseDirSource)); 6 | 7 | argList argsSrc(args, srcOptions, false, false, false); 8 | 9 | Time runTimeSource(Time::controlDictName, argsSrc); 10 | 11 | Time runTimeTarget(Time::controlDictName, args); 12 | -------------------------------------------------------------------------------- /src/rigidBodyMeshMotion/Make/options: -------------------------------------------------------------------------------- 1 | EXE_INC = \ 2 | -I$(LIB_SRC)/rigidBodyDynamics/lnInclude \ 3 | -I$(LIB_SRC)/finiteVolume/lnInclude \ 4 | -I$(LIB_SRC)/meshTools/lnInclude \ 5 | -I$(LIB_SRC)/functionObjects/forces/lnInclude \ 6 | -I$(LIB_SRC)/fileFormats/lnInclude \ 7 | -I$(LIB_SRC)/dynamicMesh/lnInclude 8 | 9 | LIB_LIBS = \ 10 | -lrigidBodyDynamics \ 11 | -lforces \ 12 | -lmeshTools \ 13 | -lfileFormats \ 14 | -ldynamicMesh 15 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pisoFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | fvVectorMatrix UEqn 6 | ( 7 | fvm::ddt(U) + fvm::div(phi, U) 8 | + MRF.DDt(U) 9 | + turbulence->divDevReff(U) 10 | == 11 | fvOptions(U) 12 | ); 13 | 14 | UEqn.relax(); 15 | 16 | fvOptions.constrain(UEqn); 17 | 18 | if (piso.momentumPredictor()) 19 | { 20 | solve(UEqn == -fvc::grad(p)); 21 | 22 | fvOptions.correct(U); 23 | } 24 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_bkup.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // backup is not implemented 3 | //====================================================================== 4 | int USERD_bkup 5 | ( 6 | FILE *archive_file, 7 | int backup_type) 8 | { 9 | #ifdef ENSIGHTDEBUG 10 | Info<< "Entering: USERD_bkup" << endl 11 | << flush; 12 | #endif 13 | return Z_ERR; 14 | } 15 | -------------------------------------------------------------------------------- /applications/solvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( heatTransfer ) 2 | add_subdirectory( multiphase ) 3 | add_subdirectory( discreteMethods ) 4 | add_subdirectory( stressAnalysis ) 5 | add_subdirectory( electromagnetics ) 6 | add_subdirectory( financial/financialFoam ) 7 | add_subdirectory( lagrangian ) 8 | add_subdirectory( basic ) 9 | add_subdirectory( combustion ) 10 | add_subdirectory( DNS/dnsFoam ) 11 | add_subdirectory( compressible ) 12 | add_subdirectory( incompressible ) 13 | -------------------------------------------------------------------------------- /applications/solvers/combustion/PDRFoam/readCombustionProperties.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading combustion properties\n" << endl; 2 | 3 | IOdictionary combustionProperties 4 | ( 5 | IOobject 6 | ( 7 | "combustionProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | ignition ign(combustionProperties, runTime, mesh); 16 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_node_label_status.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // if TRUE: set in USERD_get_global_node_ids 3 | //====================================================================== 4 | int USERD_get_node_label_status(void) 5 | { 6 | #ifdef ENSIGHTDEBUG 7 | Info<< "Entering: USERD_node_label_status" << endl << flush; 8 | #endif 9 | 10 | return TRUE; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_constant_val.H: -------------------------------------------------------------------------------- 1 | 2 | //====================================================================== 3 | // Not in use 4 | //====================================================================== 5 | float USERD_get_constant_val 6 | ( 7 | int which_var, 8 | int imag_data 9 | ) 10 | { 11 | #ifdef ENSIGHTDEBUG 12 | Info<< "Entering: USERD_get_constant_val" << endl << flush; 13 | #endif 14 | return 0.0; 15 | } 16 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_element_label_status.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // if TRUE: set in USERD_get_element_ids_for_part 3 | //====================================================================== 4 | int USERD_get_element_label_status(void) 5 | { 6 | #ifdef ENSIGHTDEBUG 7 | Info<< "Entering: USERD_get_element_label_status" << endl << flush; 8 | #endif 9 | return TRUE; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_reader_release.H: -------------------------------------------------------------------------------- 1 | int USERD_get_reader_release 2 | ( 3 | char release_number[Z_MAX_USERD_NAME] 4 | ) 5 | { 6 | 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_get_reader_release" << endl; 9 | #endif 10 | 11 | strncpy(release_number, Foam::FOAMbuild, Z_MAX_USERD_NAME); 12 | 13 | #ifdef ENSIGHTDEBUG 14 | Info<< "Leaving: USERD_get_reader_release" << endl; 15 | #endif 16 | 17 | return Z_OK; 18 | } 19 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_reader_version.H: -------------------------------------------------------------------------------- 1 | int USERD_get_reader_version 2 | ( 3 | char version_number[Z_MAX_USERD_NAME] 4 | ) 5 | { 6 | 7 | #ifdef ENSIGHTDEBUG 8 | Info<< "Entering: USERD_get_reader_version" << endl; 9 | #endif 10 | 11 | strncpy(version_number, readerVersion, Z_MAX_USERD_NAME); 12 | 13 | #ifdef ENSIGHTDEBUG 14 | Info<< "Leaving: USERD_get_reader_version" << endl; 15 | #endif 16 | 17 | return Z_OK; 18 | } 19 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/compressibleMultiRegionCourantNo.H: -------------------------------------------------------------------------------- 1 | scalar CoNum = -GREAT; 2 | forAll(fluidRegions, regionI) 3 | { 4 | CoNum = max 5 | ( 6 | compressibleCourantNo 7 | ( 8 | fluidRegions[regionI], 9 | runTime, 10 | rhoFluid[regionI], 11 | phiFluid[regionI] 12 | ), 13 | CoNum 14 | ); 15 | } 16 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/potentialFreeSurfaceFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | tmp tUEqn 4 | ( 5 | fvm::ddt(U) + fvm::div(phi, U) 6 | + MRF.DDt(U) 7 | + turbulence->divDevReff(U) 8 | == 9 | fvOptions(U) 10 | ); 11 | fvVectorMatrix& UEqn = tUEqn.ref(); 12 | 13 | UEqn.relax(); 14 | 15 | fvOptions.constrain(UEqn); 16 | 17 | if (pimple.momentumPredictor()) 18 | { 19 | solve(UEqn == -fvc::grad(p_gh)); 20 | 21 | fvOptions.correct(U); 22 | } 23 | -------------------------------------------------------------------------------- /applications/solvers/compressible/sonicFoam/sonicLiquidFoam/readTransportProperties.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading transportProperties\n" << endl; 2 | 3 | IOdictionary transportProperties 4 | ( 5 | IOobject 6 | ( 7 | "transportProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | dimensionedScalar mu 16 | ( 17 | "mu", 18 | dimDynamicViscosity, 19 | transportProperties 20 | ); 21 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleMultiphaseInterFoam/TEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | fvScalarMatrix TEqn 3 | ( 4 | fvm::ddt(rho, T) 5 | + fvm::div(mixture.rhoPhi(), T) 6 | - fvm::laplacian(mixture.alphaEff(turbulence->mut()), T) 7 | + ( 8 | fvc::div(fvc::absolute(phi, U), p) 9 | + fvc::ddt(rho, K) + fvc::div(mixture.rhoPhi(), K) 10 | )*mixture.rCv() 11 | ); 12 | 13 | TEqn.relax(); 14 | TEqn.solve(); 15 | 16 | mixture.correct(); 17 | } 18 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoLiquidMixingFoam/alphaDiffusionEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | fvScalarMatrix alpha1Eqn 3 | ( 4 | fvm::ddt(alpha1) 5 | - fvc::ddt(alpha1) 6 | - fvm::laplacian 7 | ( 8 | volScalarField("Dab", Dab + alphatab*turbulence->nut()), 9 | alpha1 10 | ) 11 | ); 12 | 13 | alpha1Eqn.solve(); 14 | 15 | alpha2 = 1.0 - alpha1; 16 | rhoPhi += alpha1Eqn.flux()*(rho1 - rho2); 17 | } 18 | 19 | rho = alpha1*rho1 + alpha2*rho2; 20 | -------------------------------------------------------------------------------- /src/randomProcesses/fft/calcEk.H: -------------------------------------------------------------------------------- 1 | #ifndef calcEk_H 2 | #define calcEk_H 3 | 4 | #include "volFieldsFwd.H" 5 | 6 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // 7 | 8 | namespace Foam 9 | { 10 | 11 | class graph; 12 | class Kmesh; 13 | 14 | graph calcEk 15 | ( 16 | const volVectorField& U, 17 | const Kmesh& K 18 | ); 19 | 20 | 21 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // 22 | 23 | } // End namespace Foam 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /applications/test/alloc/Test-alloc.C: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() 7 | { 8 | int *ptrs[500000]; 9 | 10 | // for (;;); 11 | 12 | cerr << "allocating ints\n"; 13 | 14 | for (int i=0; i<500000; i++) 15 | { 16 | ptrs[i] = new int[1]; 17 | delete[] ptrs[i]; 18 | } 19 | 20 | for (;;); 21 | 22 | cerr << "allocating double\n"; 23 | 24 | double* array = new double[500000]; 25 | 26 | for (;;); 27 | } 28 | -------------------------------------------------------------------------------- /applications/utilities/preProcessing/boxTurb/readBoxTurbDict.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading boxTurbDict\n" << endl; 2 | 3 | IOdictionary boxTurbDict 4 | ( 5 | IOobject 6 | ( 7 | "boxTurbDict", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | scalar Ea(readScalar(boxTurbDict.lookup("Ea"))); 16 | 17 | scalar k0(readScalar(boxTurbDict.lookup("k0"))); 18 | -------------------------------------------------------------------------------- /src/engine/include/createEngineMesh.H: -------------------------------------------------------------------------------- 1 | Info<< "Create mesh for time = " 2 | << runTime.timeName() << nl << endl; 3 | 4 | autoPtr meshPtr 5 | ( 6 | engineMesh::New 7 | ( 8 | IOobject 9 | ( 10 | engineMesh::defaultRegion, 11 | runTime.timeName(), 12 | runTime, 13 | Foam::IOobject::MUST_READ 14 | ) 15 | ) 16 | ); 17 | 18 | engineMesh& mesh = meshPtr(); 19 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/addTimeOptions.H: -------------------------------------------------------------------------------- 1 | Foam::argList::addBoolOption 2 | ( 3 | "constant", 4 | "include the 'constant/' dir in the times list" 5 | ); 6 | 7 | Foam::argList::addBoolOption 8 | ( 9 | "latestTime", 10 | "select the latest time" 11 | ); 12 | 13 | Foam::argList::addBoolOption 14 | ( 15 | "noZero", 16 | "exclude the '0/' dir from the times list" 17 | ); 18 | 19 | Foam::argList::addOption 20 | ( 21 | "time", 22 | "time", 23 | "specify a single time value to select" 24 | ); 25 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/solveFluid.H: -------------------------------------------------------------------------------- 1 | // Pressure-velocity SIMPLE corrector 2 | 3 | { 4 | if (frozenFlow) 5 | { 6 | #include "EEqn.H" 7 | } 8 | else 9 | { 10 | p_rgh.storePrevIter(); 11 | rho.storePrevIter(); 12 | 13 | #include "UEqn.H" 14 | #include "EEqn.H" 15 | #include "pEqn.H" 16 | 17 | turb.correct(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /applications/solvers/compressible/sonicFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | fvVectorMatrix UEqn 6 | ( 7 | fvm::ddt(rho, U) + fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turbulence->divDevRhoReff(U) 10 | == 11 | fvOptions(rho, U) 12 | ); 13 | 14 | UEqn.relax(); 15 | 16 | fvOptions.constrain(UEqn); 17 | 18 | if (pimple.momentumPredictor()) 19 | { 20 | solve(UEqn == -fvc::grad(p)); 21 | 22 | fvOptions.correct(U); 23 | K = 0.5*magSqr(U); 24 | } 25 | -------------------------------------------------------------------------------- /applications/solvers/compressible/sonicFoam/sonicLiquidFoam/compressibleContinuityErrs.H: -------------------------------------------------------------------------------- 1 | { 2 | scalar sumLocalContErr = 3 | (sum(mag(rho - rho0 - psi*(p - p0)))/sum(rho)).value(); 4 | 5 | scalar globalContErr = (sum(rho - rho0 - psi*(p - p0))/sum(rho)).value(); 6 | 7 | cumulativeContErr += globalContErr; 8 | 9 | Info<< "time step continuity errors : sum local = " << sumLocalContErr 10 | << ", global = " << globalContErr 11 | << ", cumulative = " << cumulativeContErr << endl; 12 | } 13 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pimpleFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::ddt(U) + fvm::div(phi, U) 8 | + MRF.DDt(U) 9 | + turbulence->divDevReff(U) 10 | == 11 | fvOptions(U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | if (pimple.momentumPredictor()) 20 | { 21 | solve(UEqn == -fvc::grad(p)); 22 | 23 | fvOptions.correct(U); 24 | } 25 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_num_of_time_steps.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // don't use multiple time sets...NN 3 | //====================================================================== 4 | int USERD_get_num_of_time_steps 5 | ( 6 | int timeset_number 7 | ) 8 | { 9 | #ifdef ENSIGHTDEBUG 10 | Info<< "Entering: USERD_get_num_of_time_steps" << endl 11 | << flush; 12 | #endif 13 | 14 | return Num_time_steps; 15 | } 16 | -------------------------------------------------------------------------------- /src/dynamicFvMesh/include/createDynamicFvMesh.H: -------------------------------------------------------------------------------- 1 | Info<< "Create mesh for time = " 2 | << runTime.timeName() << nl << endl; 3 | 4 | autoPtr meshPtr 5 | ( 6 | dynamicFvMesh::New 7 | ( 8 | IOobject 9 | ( 10 | dynamicFvMesh::defaultRegion, 11 | runTime.timeName(), 12 | runTime, 13 | IOobject::MUST_READ 14 | ) 15 | ) 16 | ); 17 | 18 | dynamicFvMesh& mesh = meshPtr(); 19 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoSimpleFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turbulence->divDevRhoReff(U) 10 | == 11 | fvOptions(rho, U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | solve(UEqn == -fvc::grad(p)); 20 | 21 | fvOptions.correct(U); 22 | -------------------------------------------------------------------------------- /doc/tools/find-trailingspace: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | #------------------------------------------------------------------------------ 3 | # Script 4 | # find-trailingspace 5 | # 6 | # Description 7 | # Search for files with trailing whitesapce 8 | # 9 | #------------------------------------------------------------------------------ 10 | set -x 11 | cd $WM_PROJECT_DIR || exit 1 12 | 13 | tab=$'\t' 14 | 15 | git grep -c -E "[ $tab]+"'$' -- $@ 16 | 17 | #------------------------------------------------------------------------------ 18 | -------------------------------------------------------------------------------- /applications/solvers/discreteMethods/molecularDynamics/mdEquilibrationFoam/readmdEquilibrationDict.H: -------------------------------------------------------------------------------- 1 | Info<< nl << "Reading MD Equilibration Dictionary" << nl << endl; 2 | 3 | IOdictionary mdEquilibrationDict 4 | ( 5 | IOobject 6 | ( 7 | "mdEquilibrationDict", 8 | runTime.system(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | scalar targetTemperature = readScalar 16 | ( 17 | mdEquilibrationDict.lookup("targetTemperature") 18 | ); 19 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/UrelEqn.H: -------------------------------------------------------------------------------- 1 | // Relative momentum predictor 2 | tmp tUrelEqn 3 | ( 4 | fvm::ddt(Urel) 5 | + fvm::div(phi, Urel) 6 | + turbulence->divDevReff(Urel) 7 | + SRF->Su() 8 | == 9 | fvOptions(Urel) 10 | ); 11 | fvVectorMatrix& UrelEqn = tUrelEqn.ref(); 12 | 13 | UrelEqn.relax(); 14 | 15 | fvOptions.constrain(UrelEqn); 16 | 17 | solve(UrelEqn == -fvc::grad(p)); 18 | 19 | fvOptions.correct(Urel); 20 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_border_elements_by_type.H: -------------------------------------------------------------------------------- 1 | 2 | // Not called if USERD_border_availability returns Z_ERR 3 | 4 | int USERD_get_border_elements_by_type 5 | ( 6 | int part_number, 7 | int element_type, 8 | int **conn_array, 9 | short *parent_element_type, 10 | int *parnet_element_type 11 | ) 12 | { 13 | #ifdef ENSIGHTDEBUG 14 | Info<< "Entering: USERD_get_border_elements_by_type" << endl 15 | << flush; 16 | #endif 17 | 18 | return Z_ERR; 19 | } 20 | -------------------------------------------------------------------------------- /applications/solvers/DNS/dnsFoam/readTransportProperties.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading transportProperties\n" << endl; 2 | 3 | IOdictionary transportProperties 4 | ( 5 | IOobject 6 | ( 7 | "transportProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | dimensionedScalar nu 16 | ( 17 | "nu", 18 | dimViscosity, 19 | transportProperties 20 | ); 21 | -------------------------------------------------------------------------------- /applications/solvers/combustion/XiFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | fvOptions(rho, U) 10 | ); 11 | 12 | UEqn.relax(); 13 | 14 | fvOptions.constrain(UEqn); 15 | 16 | if (pimple.momentumPredictor()) 17 | { 18 | solve(UEqn == -fvc::grad(p)); 19 | 20 | fvOptions.correct(U); 21 | K = 0.5*magSqr(U); 22 | } 23 | -------------------------------------------------------------------------------- /applications/solvers/compressible/sonicFoam/EEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | fvScalarMatrix EEqn 3 | ( 4 | fvm::ddt(rho, e) + fvm::div(phi, e) 5 | + fvc::ddt(rho, K) + fvc::div(phi, K) 6 | + fvc::div(fvc::absolute(phi/fvc::interpolate(rho), U), p, "div(phiv,p)") 7 | - fvm::laplacian(turbulence->alphaEff(), e) 8 | == 9 | fvOptions(rho, e) 10 | ); 11 | 12 | EEqn.relax(); 13 | 14 | fvOptions.constrain(EEqn); 15 | 16 | EEqn.solve(); 17 | 18 | fvOptions.correct(e); 19 | 20 | thermo.correct(); 21 | } 22 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( boundaryFoam ) 2 | add_subdirectory( nonNewtonianIcoFoam ) 3 | add_subdirectory( shallowWaterFoam ) 4 | add_subdirectory( adjointShapeOptimizationFoam ) 5 | add_subdirectory( simpleFoam ) 6 | add_subdirectory( simpleFoam/porousSimpleFoam ) 7 | add_subdirectory( simpleFoam/SRFSimpleFoam ) 8 | add_subdirectory( pimpleFoam ) 9 | add_subdirectory( pimpleFoam/pimpleDyMFoam ) 10 | add_subdirectory( pimpleFoam/SRFPimpleFoam ) 11 | add_subdirectory( icoFoam ) 12 | add_subdirectory( pisoFoam ) 13 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/alphavPsi.H: -------------------------------------------------------------------------------- 1 | { 2 | alphav = 3 | max 4 | ( 5 | min 6 | ( 7 | (rho - rholSat)/(rhovSat - rholSat), 8 | scalar(1) 9 | ), 10 | scalar(0) 11 | ); 12 | alphal = 1.0 - alphav; 13 | 14 | Info<< "max-min alphav: " << max(alphav).value() 15 | << " " << min(alphav).value() << endl; 16 | 17 | psiModel->correct(); 18 | 19 | //Info<< "min a: " << 1.0/sqrt(max(psi)).value() << endl; 20 | } 21 | -------------------------------------------------------------------------------- /src/thermophysicalModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( specie ) 2 | add_subdirectory( solidSpecie ) 3 | add_subdirectory( thermophysicalFunctions ) 4 | add_subdirectory( properties ) 5 | add_subdirectory( basic ) 6 | add_subdirectory( reactionThermo ) 7 | add_subdirectory( laminarFlameSpeed ) 8 | add_subdirectory( chemistryModel ) 9 | add_subdirectory( barotropicCompressibilityModel ) 10 | add_subdirectory( SLGThermo ) 11 | 12 | add_subdirectory( solidThermo ) 13 | add_subdirectory( solidChemistryModel ) 14 | 15 | add_subdirectory( radiation ) 16 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | tmp tUEqn 4 | ( 5 | fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | rho()*g 10 | + parcels.SU(U) 11 | + fvOptions(rho, U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | solve(UEqn == -fvc::grad(p)); 20 | 21 | fvOptions.correct(U); 22 | -------------------------------------------------------------------------------- /applications/solvers/combustion/reactingFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::ddt(rho, U) + fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turbulence->divDevRhoReff(U) 10 | == 11 | fvOptions(rho, U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | if (pimple.momentumPredictor()) 20 | { 21 | solve(UEqn == -fvc::grad(p)); 22 | 23 | fvOptions.correct(U); 24 | K = 0.5*magSqr(U); 25 | } 26 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoCentralFoam/readFluxScheme.H: -------------------------------------------------------------------------------- 1 | word fluxScheme("Kurganov"); 2 | if (mesh.schemesDict().readIfPresent("fluxScheme", fluxScheme)) 3 | { 4 | if ((fluxScheme == "Tadmor") || (fluxScheme == "Kurganov")) 5 | { 6 | Info<< "fluxScheme: " << fluxScheme << endl; 7 | } 8 | else 9 | { 10 | FatalErrorInFunction 11 | << "fluxScheme: " << fluxScheme 12 | << " is not a valid choice. " 13 | << "Options are: Tadmor, Kurganov" 14 | << abort(FatalError); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /applications/utilities/mesh/manipulation/mirrorMesh/readMirrorDict.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading mirrorMeshDict\n" << endl; 2 | 3 | IOdictionary mirrorMeshDict 4 | ( 5 | IOobject 6 | ( 7 | "mirrorMeshDict", 8 | runTime.system(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | plane mirrorPlane(mirrorMeshDict); 16 | 17 | scalar planeTolerance 18 | ( 19 | readScalar(mirrorMeshDict.lookup("planeTolerance")) 20 | ); 21 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::ddt(rho, U) + fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turbulence->divDevRhoReff(U) 10 | == 11 | fvOptions(rho, U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | if (pimple.momentumPredictor()) 20 | { 21 | solve(UEqn == -fvc::grad(p)); 22 | 23 | fvOptions.correct(U); 24 | K = 0.5*magSqr(U); 25 | } 26 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/simpleFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Momentum predictor 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::div(phi, U) 8 | + MRF.DDt(U) 9 | + turbulence->divDevReff(U) 10 | == 11 | fvOptions(U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | if (simple.momentumPredictor()) 20 | { 21 | solve(UEqn == -fvc::grad(p)); 22 | 23 | fvOptions.correct(U); 24 | } 25 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasMovingMesh.H: -------------------------------------------------------------------------------- 1 | // check for "points" in all of the result directories 2 | 3 | bool hasMovingMesh = false; 4 | if (timeDirs.size() > 1) 5 | { 6 | hasMovingMesh = true; 7 | for (label i=0; i < timeDirs.size() && hasMovingMesh; ++i) 8 | { 9 | hasMovingMesh = IOobject 10 | ( 11 | "points", 12 | timeDirs[i].name(), 13 | polyMesh::meshSubDir, 14 | mesh, 15 | IOobject::NO_READ 16 | ).headerOk(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_number_of_files_in_dataset.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // 3 | //====================================================================== 4 | int USERD_get_number_of_files_in_dataset(void) 5 | { 6 | #ifdef ENSIGHTDEBUG 7 | Info<< "Entering: USERD_get_number_of_files_in_dataset" << endl << flush; 8 | #endif 9 | 10 | // use 1 insted of 0 which gives an un-necessary warning. 11 | Num_dataset_files = 1; 12 | return Num_dataset_files; 13 | } 14 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/simpleFoam/SRFSimpleFoam/UrelEqn.H: -------------------------------------------------------------------------------- 1 | // Relative momentum predictor 2 | 3 | tmp tUrelEqn 4 | ( 5 | fvm::div(phi, Urel) 6 | + turbulence->divDevReff(Urel) 7 | + SRF->Su() 8 | == 9 | fvOptions(Urel) 10 | ); 11 | fvVectorMatrix& UrelEqn = tUrelEqn.ref(); 12 | 13 | UrelEqn.relax(); 14 | 15 | fvOptions.constrain(UrelEqn); 16 | 17 | if (simple.momentumPredictor()) 18 | { 19 | solve(UrelEqn == -fvc::grad(p)); 20 | 21 | fvOptions.correct(Urel); 22 | } 23 | -------------------------------------------------------------------------------- /applications/solvers/combustion/coldEngineFoam/logSummary.H: -------------------------------------------------------------------------------- 1 | Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; 2 | Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl; 3 | Info<< "Mean u':" 4 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 5 | << endl; 6 | 7 | logSummaryFile 8 | << runTime.theta() << tab 9 | << p.weightedAverage(mesh.V()).value() << tab 10 | << T.weightedAverage(mesh.V()).value() << tab 11 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 12 | << endl; 13 | -------------------------------------------------------------------------------- /applications/test/rigidBodyDynamics/sphericalJoint/sphericalJoint: -------------------------------------------------------------------------------- 1 | solver 2 | { 3 | type Newmark; 4 | } 5 | 6 | // It is necessary to iterate for the Newmark solver 7 | nIter 2; 8 | 9 | bodies 10 | { 11 | pendulum 12 | { 13 | type rigidBody; 14 | mass 1; 15 | centreOfMass (0 -1 0); 16 | inertia (0.001 0 0 0.001 0 0.001); 17 | parent root; 18 | transform (1 0 0 0 1 0 0 0 1) (0 0 0); 19 | joint 20 | { 21 | type Rs; 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/readTransportProperties.H: -------------------------------------------------------------------------------- 1 | singlePhaseTransportModel laminarTransport(U, phi); 2 | 3 | // Thermal expansion coefficient [1/K] 4 | dimensionedScalar beta 5 | ( 6 | "beta", 7 | dimless/dimTemperature, 8 | laminarTransport 9 | ); 10 | 11 | // Reference temperature [K] 12 | dimensionedScalar TRef("TRef", dimTemperature, laminarTransport); 13 | 14 | // Laminar Prandtl number 15 | dimensionedScalar Pr("Pr", dimless, laminarTransport); 16 | 17 | // Turbulent Prandtl number 18 | dimensionedScalar Prt("Prt", dimless, laminarTransport); 19 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/logSummary.H: -------------------------------------------------------------------------------- 1 | Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; 2 | Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl; 3 | Info<< "Mean u':" 4 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 5 | << endl; 6 | 7 | logSummaryFile 8 | << runTime.theta() << tab 9 | << p.weightedAverage(mesh.V()).value() << tab 10 | << T.weightedAverage(mesh.V()).value() << tab 11 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 12 | << endl; 13 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/reactingEulerFoam/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( phaseSystems ) 2 | add_subdirectory( interfacialModels ) 3 | add_subdirectory( interfacialCompositionModels ) 4 | add_subdirectory( reactingMultiphaseEulerFoam/multiphaseSystem ) 5 | add_subdirectory( reactingMultiphaseEulerFoam/multiphaseCompressibleTurbulenceModels ) 6 | add_subdirectory( reactingMultiphaseEulerFoam ) 7 | add_subdirectory( reactingTwoPhaseEulerFoam/twoPhaseSystem ) 8 | add_subdirectory( reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels ) 9 | add_subdirectory( reactingTwoPhaseEulerFoam ) 10 | -------------------------------------------------------------------------------- /applications/test/thermoMixture/thermoDict: -------------------------------------------------------------------------------- 1 | specie1 2 | { 3 | specie 4 | { 5 | nMoles 1; 6 | molWeight 1; 7 | } 8 | 9 | thermodynamics 10 | { 11 | Cp 1; 12 | Cv 1; 13 | Hf 0; 14 | } 15 | 16 | transport 17 | { 18 | mu 1; 19 | Pr 1; 20 | } 21 | } 22 | 23 | specie2 24 | { 25 | specie 26 | { 27 | nMoles 1; 28 | molWeight 0.5; 29 | } 30 | 31 | thermodynamics 32 | { 33 | Cp 2; 34 | Cv 2; 35 | Hf 0; 36 | } 37 | 38 | transport 39 | { 40 | mu 1; 41 | Pr 1; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | rho()*g 10 | + parcels.SU(U) 11 | + fvOptions(rho, U) 12 | ); 13 | 14 | UEqn.relax(); 15 | 16 | fvOptions.constrain(UEqn); 17 | 18 | if (pimple.momentumPredictor()) 19 | { 20 | solve(UEqn == -fvc::grad(p)); 21 | 22 | fvOptions.correct(U); 23 | K = 0.5*magSqr(U); 24 | } 25 | -------------------------------------------------------------------------------- /applications/test/alloc/Test-new.C: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() 4 | { 5 | int* intPtrs[500000]; 6 | 7 | cerr << "allocating ints\n"; 8 | 9 | for (int i=0; i<500000; i++) 10 | { 11 | intPtrs[i] = new int[1]; 12 | } 13 | 14 | cerr << "allocated ints\n"; 15 | 16 | cerr << "deallocating ints\n"; 17 | 18 | for (i=0; i<500000; i++) 19 | { 20 | delete[] intPtrs[i]; 21 | } 22 | 23 | cerr << "deallocated ints\n"; 24 | 25 | cerr << "alloacting doubles\n"; 26 | 27 | double* doubles = new double[500000]; 28 | 29 | for (;;); 30 | } 31 | -------------------------------------------------------------------------------- /doc/tools/find-its: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | #------------------------------------------------------------------------------ 3 | # Script 4 | # find-its 5 | # 6 | # Description 7 | # Search for files with "it's" 8 | # This contraction (== "it is") looks too much like "its" (possesive) 9 | # and confuses non-native (and some native) English speakers. 10 | # 11 | #------------------------------------------------------------------------------ 12 | set -x 13 | cd $WM_PROJECT_DIR || exit 1 14 | 15 | git grep -e "it's" 16 | 17 | #------------------------------------------------------------------------------ 18 | -------------------------------------------------------------------------------- /src/lagrangian/molecularDynamics/molecule/mdTools/createRefUnits.H: -------------------------------------------------------------------------------- 1 | reducedUnits refUnits; 2 | 3 | IOobject reducedUnitsDictIOobject 4 | ( 5 | "reducedUnitsDict", 6 | runTime.system(), 7 | mesh, 8 | IOobject::READ_IF_PRESENT, 9 | IOobject::NO_WRITE 10 | ); 11 | 12 | if (reducedUnitsDictIOobject.headerOk()) 13 | { 14 | Info<< nl 15 | << "Reading reference quantities from reducedUnitsDict file." << endl; 16 | 17 | IOdictionary reducedUnitsDict(reducedUnitsDictIOobject); 18 | 19 | refUnits.setRefValues(reducedUnitsDict); 20 | } 21 | 22 | Info << refUnits << endl; 23 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/sprayFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::ddt(rho, U) + fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turbulence->divDevRhoReff(U) 10 | == 11 | rho()*g 12 | + parcels.SU(U) 13 | + fvOptions(rho, U) 14 | ); 15 | fvVectorMatrix& UEqn = tUEqn.ref(); 16 | 17 | UEqn.relax(); 18 | 19 | fvOptions.constrain(UEqn); 20 | 21 | if (pimple.momentumPredictor()) 22 | { 23 | solve(UEqn == -fvc::grad(p)); 24 | 25 | fvOptions.correct(U); 26 | K = 0.5*magSqr(U); 27 | } 28 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoLiquidMixingFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(rhoPhi, U) 5 | + turbulence->divDevRhoReff(rho, U) 6 | ); 7 | 8 | UEqn.relax(); 9 | 10 | if (pimple.momentumPredictor()) 11 | { 12 | solve 13 | ( 14 | UEqn 15 | == 16 | fvc::reconstruct 17 | ( 18 | ( 19 | - ghf*fvc::snGrad(rho) 20 | - fvc::snGrad(p_rgh) 21 | ) * mesh.magSf() 22 | ) 23 | ); 24 | } 25 | -------------------------------------------------------------------------------- /applications/test/alloc/Test-malloc.C: -------------------------------------------------------------------------------- 1 | #include "stream.h" 2 | #include 3 | #include 4 | 5 | main() 6 | { 7 | int *ptrs[500000]; 8 | 9 | cerr << "allocating ints\n"; 10 | 11 | for (int i=0; i<500000; i++) 12 | { 13 | ptrs[i] = (int*)malloc(sizeof(int)); 14 | } 15 | 16 | // for (;;); 17 | 18 | cerr << "deallocating ints\n"; 19 | 20 | for (i=0; i<500000; i++) 21 | { 22 | free(ptrs[i]); 23 | } 24 | 25 | cerr << "allocating double\n"; 26 | 27 | double* array = (double*)malloc(500000*sizeof(double)); 28 | 29 | for (;;); 30 | } 31 | -------------------------------------------------------------------------------- /src/rigidBodyDynamics/joints/joints.H: -------------------------------------------------------------------------------- 1 | // Null joint for the root-body 2 | #include "nullJoint.H" 3 | 4 | // Composite joint to handle combination of rotations and translations 5 | #include "compositeJoint.H" 6 | 7 | // 6-DoF joint for floating bodies 8 | #include "floatingJoint.H" 9 | 10 | // Revolute joints 11 | #include "Rx.H" 12 | #include "Ry.H" 13 | #include "Rz.H" 14 | #include "Ra.H" 15 | #include "Rs.H" 16 | #include "Rzyx.H" 17 | #include "Rxyz.H" 18 | #include "Ryxz.H" 19 | 20 | // Prismatic joints 21 | #include "Px.H" 22 | #include "Py.H" 23 | #include "Pz.H" 24 | #include "Pa.H" 25 | #include "Pxyz.H" 26 | -------------------------------------------------------------------------------- /applications/test/fieldMapping/pipe1D/Allrun: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | 4 | # Source tutorial run functions 5 | . $WM_PROJECT_DIR/bin/tools/RunFunctions 6 | 7 | # Get application name 8 | application=Test-fieldMapping 9 | 10 | # Compile 11 | wmake .. 12 | 13 | runApplication blockMesh 14 | 15 | # Run with inflation 16 | runApplication $application true 17 | mv "log.$application" "log.$application-inflate" 18 | 19 | # Run without inflation 20 | runApplication $application false 21 | 22 | 23 | #------------------------------------------------------------------------------ 24 | -------------------------------------------------------------------------------- /applications/test/hexRef8/block/Allrun: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ${0%/*} || exit 1 # Run from this directory 3 | 4 | # Source tutorial run functions 5 | . $WM_PROJECT_DIR/bin/tools/RunFunctions 6 | 7 | # Get application name 8 | application=Test-hexRef8 9 | 10 | # Compile 11 | runApplication wmake .. 12 | 13 | runApplication blockMesh 14 | 15 | # Run with inflation 16 | runApplication $application true 17 | mv "log.$application" "log.$application-inflate" 18 | 19 | # Run without inflation 20 | runApplication $application false 21 | 22 | 23 | #------------------------------------------------------------------------------ 24 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/setSystemMeshDictionaryIO.H: -------------------------------------------------------------------------------- 1 | fileName dictPath = ""; 2 | if (args.optionFound("dict")) 3 | { 4 | dictPath = args["dict"]; 5 | if (isDir(dictPath)) 6 | { 7 | dictPath = dictPath / dictName; 8 | } 9 | } 10 | 11 | IOobject dictIO 12 | ( 13 | dictName, 14 | runTime.system(), 15 | mesh, 16 | IOobject::MUST_READ_IF_MODIFIED, 17 | IOobject::NO_WRITE 18 | ); 19 | 20 | if (dictPath.size()) 21 | { 22 | dictIO = IOobject 23 | ( 24 | dictPath, 25 | mesh, 26 | IOobject::MUST_READ_IF_MODIFIED, 27 | IOobject::NO_WRITE 28 | ); 29 | } 30 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/setConstantMeshDictionaryIO.H: -------------------------------------------------------------------------------- 1 | fileName dictPath = ""; 2 | if (args.optionFound("dict")) 3 | { 4 | dictPath = args["dict"]; 5 | if (isDir(dictPath)) 6 | { 7 | dictPath = dictPath / dictName; 8 | } 9 | } 10 | 11 | IOobject dictIO 12 | ( 13 | dictName, 14 | runTime.constant(), 15 | mesh, 16 | IOobject::MUST_READ_IF_MODIFIED, 17 | IOobject::NO_WRITE 18 | ); 19 | 20 | if (dictPath.size()) 21 | { 22 | dictIO = IOobject 23 | ( 24 | dictPath, 25 | mesh, 26 | IOobject::MUST_READ_IF_MODIFIED, 27 | IOobject::NO_WRITE 28 | ); 29 | } 30 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H: -------------------------------------------------------------------------------- 1 | // ignore special fields or fields that we don't handle 2 | // 3 | bool variableGood = true; 4 | for (label n1=0; n1 2 && fieldName(fieldName.size() - 2, 2) == "_0") 8 | { 9 | variableGood = false; 10 | } 11 | else 12 | { 13 | variableGood = IOobject 14 | ( 15 | fieldName, 16 | Times[n1].name(), 17 | mesh, 18 | IOobject::NO_READ 19 | ).headerOk(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/setSystemRunTimeDictionaryIO.H: -------------------------------------------------------------------------------- 1 | fileName dictPath = ""; 2 | if (args.optionFound("dict")) 3 | { 4 | dictPath = args["dict"]; 5 | if (isDir(dictPath)) 6 | { 7 | dictPath = dictPath / dictName; 8 | } 9 | } 10 | 11 | IOobject dictIO 12 | ( 13 | dictName, 14 | runTime.system(), 15 | runTime, 16 | IOobject::MUST_READ_IF_MODIFIED, 17 | IOobject::NO_WRITE 18 | ); 19 | 20 | if (dictPath.size()) 21 | { 22 | dictIO = IOobject 23 | ( 24 | dictPath, 25 | runTime, 26 | IOobject::MUST_READ_IF_MODIFIED, 27 | IOobject::NO_WRITE 28 | ); 29 | } 30 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/TEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | fvScalarMatrix TEqn 3 | ( 4 | fvm::ddt(rho, T) 5 | + fvm::div(rhoPhi, T) 6 | - fvm::laplacian(mixture.alphaEff(turbulence->mut()), T) 7 | + ( 8 | fvc::div(fvc::absolute(phi, U), p) 9 | + fvc::ddt(rho, K) + fvc::div(rhoPhi, K) 10 | ) 11 | *( 12 | alpha1/mixture.thermo1().Cv() 13 | + alpha2/mixture.thermo2().Cv() 14 | ) 15 | ); 16 | 17 | TEqn.relax(); 18 | TEqn.solve(); 19 | 20 | mixture.correct(); 21 | 22 | Info<< "min(T) " << min(T).value() << endl; 23 | } 24 | -------------------------------------------------------------------------------- /applications/utilities/mesh/conversion/Optional/Allwmake: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # 3 | # Build optional components (eg, may depend on third-party libraries) 4 | # ----------------------------------------------------------------------------- 5 | cd ${0%/*} || exit 1 # Run from this directory 6 | set -x 7 | 8 | # build libccmio and create lnInclude directory 9 | $WM_THIRD_PARTY_DIR/AllwmakeLibccmio 10 | 11 | # if the library built properly, the headers should exist too 12 | if [ -e $FOAM_EXT_LIBBIN/libccmio.so ] 13 | then 14 | wmake ccm26ToFoam 15 | fi 16 | 17 | # ----------------------------------------------------------------- end-of-file 18 | -------------------------------------------------------------------------------- /applications/solvers/DNS/dnsFoam/readTurbulenceProperties.H: -------------------------------------------------------------------------------- 1 | Info<< "Reading turbulenceProperties\n" << endl; 2 | 3 | IOdictionary turbulenceProperties 4 | ( 5 | IOobject 6 | ( 7 | "turbulenceProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | volVectorField force 16 | ( 17 | U/dimensionedScalar("dt", dimTime, runTime.deltaTValue()) 18 | ); 19 | 20 | Kmesh K(mesh); 21 | UOprocess forceGen(K, runTime.deltaTValue(), turbulenceProperties); 22 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/coalChemistryFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | rho()*g 10 | + coalParcels.SU(U) 11 | + limestoneParcels.SU(U) 12 | + fvOptions(rho, U) 13 | ); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | if (pimple.momentumPredictor()) 20 | { 21 | solve(UEqn == -fvc::grad(p)); 22 | 23 | fvOptions.correct(U); 24 | K = 0.5*magSqr(U); 25 | } 26 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToGMV/moveMesh.H: -------------------------------------------------------------------------------- 1 | IOobject ioPoints 2 | ( 3 | "points", 4 | runTime.timeName(), 5 | mesh.name(), 6 | mesh 7 | ); 8 | 9 | if (ioPoints.headerOk()) 10 | { 11 | Info<< "new points available" << endl; 12 | // Reading new points 13 | pointIOField newPoints 14 | ( 15 | IOobject 16 | ( 17 | "points", 18 | runTime.timeName(), 19 | mesh.name(), 20 | mesh, 21 | IOobject::MUST_READ, 22 | IOobject::NO_WRITE 23 | ) 24 | ); 25 | 26 | mesh.movePoints(newPoints); 27 | } 28 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solveFluid.H: -------------------------------------------------------------------------------- 1 | if (finalIter) 2 | { 3 | mesh.data::add("finalIteration", true); 4 | } 5 | 6 | if (frozenFlow) 7 | { 8 | #include "EEqn.H" 9 | } 10 | else 11 | { 12 | if (oCorr == 0) 13 | { 14 | #include "rhoEqn.H" 15 | } 16 | 17 | #include "UEqn.H" 18 | #include "EEqn.H" 19 | 20 | // --- PISO loop 21 | for (int corr=0; corrnut()/Prt; 3 | alphat.correctBoundaryConditions(); 4 | 5 | volScalarField alphaEff("alphaEff", turbulence->nu()/Pr + alphat); 6 | 7 | fvScalarMatrix TEqn 8 | ( 9 | fvm::div(phi, T) 10 | - fvm::laplacian(alphaEff, T) 11 | == 12 | radiation->ST(rhoCpRef, T) 13 | + fvOptions(T) 14 | ); 15 | 16 | TEqn.relax(); 17 | 18 | fvOptions.constrain(TEqn); 19 | 20 | TEqn.solve(); 21 | 22 | radiation->correct(); 23 | 24 | fvOptions.correct(T); 25 | 26 | rhok = 1.0 - beta*(T - TRef); 27 | } 28 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoSimpleFoam/EEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& he = thermo.he(); 3 | 4 | fvScalarMatrix EEqn 5 | ( 6 | fvm::div(phi, he) 7 | + ( 8 | he.name() == "e" 9 | ? fvc::div(phi, volScalarField("Ekp", 0.5*magSqr(U) + p/rho)) 10 | : fvc::div(phi, volScalarField("K", 0.5*magSqr(U))) 11 | ) 12 | - fvm::laplacian(turbulence->alphaEff(), he) 13 | == 14 | fvOptions(rho, he) 15 | ); 16 | 17 | EEqn.relax(); 18 | 19 | fvOptions.constrain(EEqn); 20 | 21 | EEqn.solve(); 22 | 23 | fvOptions.correct(he); 24 | 25 | thermo.correct(); 26 | } 27 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_name_of_reader.H: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // Setting name in the gui, and specifying one or two input fields 3 | //====================================================================== 4 | int USERD_get_name_of_reader 5 | ( 6 | char reader_name[Z_MAX_USERD_NAME], 7 | int *two_fields 8 | ) 9 | { 10 | #ifdef ENSIGHTDEBUG 11 | Info<< "Entering: USERD_get_name_of_reader" << endl << flush; 12 | #endif 13 | 14 | strncpy(reader_name, readerName, Z_MAX_USERD_NAME); 15 | *two_fields = FALSE; 16 | 17 | return Z_OK; 18 | } 19 | -------------------------------------------------------------------------------- /applications/utilities/preProcessing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( dsmcInitialise ) 2 | add_subdirectory( faceAgglomerate ) 3 | add_subdirectory( foamUpgradeCyclics ) 4 | add_subdirectory( viewFactorsGen ) 5 | add_subdirectory( createExternalCoupledPatchGeometry ) 6 | add_subdirectory( wallFunctionTable/tabulatedWallFunction ) 7 | add_subdirectory( wallFunctionTable ) 8 | add_subdirectory( engineSwirl ) 9 | add_subdirectory( mdInitialise ) 10 | add_subdirectory( mapFieldsPar ) 11 | add_subdirectory( applyBoundaryLayer ) 12 | add_subdirectory( boxTurb ) 13 | add_subdirectory( changeDictionary ) 14 | add_subdirectory( mapFields ) 15 | add_subdirectory( setFields ) 16 | -------------------------------------------------------------------------------- /applications/solvers/combustion/PDRFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | betav*fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | betav*rho*g 10 | + betav*fvOptions(rho, U) 11 | ); 12 | 13 | fvOptions.constrain(UEqn); 14 | 15 | volSymmTensorField invA(inv(I*UEqn.A() + drag->Dcu())); 16 | 17 | if (pimple.momentumPredictor()) 18 | { 19 | U = invA & (UEqn.H() - betav*fvc::grad(p)); 20 | U.correctBoundaryConditions(); 21 | fvOptions.correct(U); 22 | K = 0.5*magSqr(U); 23 | } 24 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createNamedMesh.H: -------------------------------------------------------------------------------- 1 | Foam::word regionName; 2 | 3 | if (args.optionReadIfPresent("region", regionName)) 4 | { 5 | Foam::Info 6 | << "Create mesh " << regionName << " for time = " 7 | << runTime.timeName() << Foam::nl << Foam::endl; 8 | } 9 | else 10 | { 11 | regionName = Foam::fvMesh::defaultRegion; 12 | Foam::Info 13 | << "Create mesh for time = " 14 | << runTime.timeName() << Foam::nl << Foam::endl; 15 | } 16 | 17 | Foam::fvMesh mesh 18 | ( 19 | Foam::IOobject 20 | ( 21 | regionName, 22 | runTime.timeName(), 23 | runTime, 24 | Foam::IOobject::MUST_READ 25 | ) 26 | ); 27 | -------------------------------------------------------------------------------- /applications/solvers/combustion/engineFoam/logSummary.H: -------------------------------------------------------------------------------- 1 | Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; 2 | Info<< "Mean temperature:" << thermo.T().weightedAverage(mesh.V()).value() 3 | << endl; 4 | Info<< "Mean u':" 5 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 6 | << endl; 7 | 8 | logSummaryFile 9 | << runTime.theta() << tab 10 | << p.weightedAverage(mesh.V()).value() << tab 11 | << thermo.T().weightedAverage(mesh.V()).value() << tab 12 | << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() 13 | << tab 14 | << 1 - b.weightedAverage(mesh.V()).value() 15 | << endl; 16 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/EEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& he = thermo.he(); 3 | 4 | fvScalarMatrix EEqn 5 | ( 6 | fvm::div(phi, he) 7 | + ( 8 | he.name() == "e" 9 | ? fvc::div(phi, volScalarField("Ekp", 0.5*magSqr(U) + p/rho)) 10 | : fvc::div(phi, volScalarField("K", 0.5*magSqr(U))) 11 | ) 12 | - fvm::laplacian(turbulence->alphaEff(), he) 13 | == 14 | fvOptions(rho, he) 15 | ); 16 | 17 | EEqn.relax(); 18 | 19 | fvOptions.constrain(EEqn); 20 | 21 | EEqn.solve(); 22 | 23 | fvOptions.correct(he); 24 | 25 | thermo.correct(); 26 | } 27 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/TEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | alphat = turbulence->nut()/Prt; 3 | alphat.correctBoundaryConditions(); 4 | 5 | volScalarField alphaEff("alphaEff", turbulence->nu()/Pr + alphat); 6 | 7 | fvScalarMatrix TEqn 8 | ( 9 | fvm::ddt(T) 10 | + fvm::div(phi, T) 11 | - fvm::laplacian(alphaEff, T) 12 | == 13 | radiation->ST(rhoCpRef, T) 14 | + fvOptions(T) 15 | ); 16 | 17 | TEqn.relax(); 18 | 19 | fvOptions.constrain(TEqn); 20 | 21 | TEqn.solve(); 22 | 23 | radiation->correct(); 24 | 25 | fvOptions.correct(T); 26 | 27 | rhok = 1.0 - beta*(T - TRef); 28 | } 29 | -------------------------------------------------------------------------------- /applications/test/cyclic/createFields.H: -------------------------------------------------------------------------------- 1 | Info<< nl << "Reading field p" << endl; 2 | volScalarField p 3 | ( 4 | IOobject 5 | ( 6 | "p", 7 | runTime.timeName(), 8 | mesh, 9 | IOobject::MUST_READ, 10 | IOobject::AUTO_WRITE 11 | ), 12 | mesh 13 | ); 14 | 15 | Info<< nl << "Reading field U" << endl; 16 | volVectorField U 17 | ( 18 | IOobject 19 | ( 20 | "U", 21 | runTime.timeName(), 22 | mesh, 23 | IOobject::MUST_READ, 24 | IOobject::AUTO_WRITE 25 | ), 26 | mesh 27 | ); 28 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_timeset_description.H: -------------------------------------------------------------------------------- 1 | int USERD_get_timeset_description 2 | ( 3 | int timeset_number, 4 | char timeset_description[Z_BUFL] 5 | ) 6 | { 7 | 8 | #ifdef ENSIGHTDEBUG 9 | Info<< "Entering: USERD_get_timeset_description" << endl; 10 | #endif 11 | 12 | if (timeDirs[1].value() < 0) 13 | { 14 | strncpy(timeset_description, "CAD", Z_BUFL); 15 | } 16 | else 17 | { 18 | strncpy(timeset_description, "seconds", Z_BUFL); 19 | } 20 | 21 | #ifdef ENSIGHTDEBUG 22 | Info<< "Leaving: USERD_get_timeset_description" << endl; 23 | #endif 24 | 25 | return Z_OK; 26 | } 27 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/createNamedPolyMesh.H: -------------------------------------------------------------------------------- 1 | Foam::word regionName; 2 | 3 | if (args.optionReadIfPresent("region", regionName)) 4 | { 5 | Foam::Info 6 | << "Create polyMesh " << regionName << " for time = " 7 | << runTime.timeName() << Foam::nl << Foam::endl; 8 | } 9 | else 10 | { 11 | regionName = Foam::polyMesh::defaultRegion; 12 | Foam::Info 13 | << "Create polyMesh for time = " 14 | << runTime.timeName() << Foam::nl << Foam::endl; 15 | } 16 | 17 | Foam::polyMesh mesh 18 | ( 19 | Foam::IOobject 20 | ( 21 | regionName, 22 | runTime.timeName(), 23 | runTime, 24 | Foam::IOobject::MUST_READ 25 | ) 26 | ); 27 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory( reactingParcelFilmFoam ) 2 | add_subdirectory( icoUncoupledKinematicParcelFoam ) 3 | add_subdirectory( icoUncoupledKinematicParcelFoam/icoUncoupledKinematicParcelDyMFoam ) 4 | add_subdirectory( reactingParcelFoam ) 5 | add_subdirectory( reactingParcelFoam/simpleReactingParcelFoam ) 6 | add_subdirectory( DPMFoam ) 7 | add_subdirectory( DPMFoam/MPPICFoam ) 8 | add_subdirectory( DPMFoam/DPMTurbulenceModels ) 9 | add_subdirectory( sprayFoam/sprayEngineFoam ) 10 | add_subdirectory( sprayFoam/sprayDyMFoam ) 11 | add_subdirectory( sprayFoam ) 12 | add_subdirectory( uncoupledKinematicParcelFoam ) 13 | add_subdirectory( coalChemistryFoam ) 14 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleInterFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(rhoPhi, U) 5 | + turbulence->divDevRhoReff(U) 6 | ); 7 | 8 | UEqn.relax(); 9 | 10 | if (pimple.momentumPredictor()) 11 | { 12 | solve 13 | ( 14 | UEqn 15 | == 16 | fvc::reconstruct 17 | ( 18 | ( 19 | interface.surfaceTensionForce() 20 | - ghf*fvc::snGrad(rho) 21 | - fvc::snGrad(p_rgh) 22 | ) * mesh.magSf() 23 | ) 24 | ); 25 | 26 | K = 0.5*magSqr(U); 27 | } 28 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/driftFluxFoam/alphaControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name()); 2 | 3 | label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr"))); 4 | 5 | label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles"))); 6 | 7 | bool MULESCorr(alphaControls.lookupOrDefault("MULESCorr", false)); 8 | 9 | // Apply the compression correction from the previous iteration 10 | // Improves efficiency for steady-simulations but can only be applied 11 | // once the alpha field is reasonably steady, i.e. fully developed 12 | bool alphaApplyPrevCorr 13 | ( 14 | alphaControls.lookupOrDefault("alphaApplyPrevCorr", false) 15 | ); 16 | -------------------------------------------------------------------------------- /src/mesh/snappyHexMesh/Make/options: -------------------------------------------------------------------------------- 1 | EXE_INC = \ 2 | -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \ 3 | -I$(LIB_SRC)/dynamicMesh/lnInclude \ 4 | -I$(LIB_SRC)/finiteVolume/lnInclude \ 5 | -I$(LIB_SRC)/lagrangian/basic/lnInclude \ 6 | -I$(LIB_SRC)/meshTools/lnInclude \ 7 | -I$(LIB_SRC)/fileFormats/lnInclude \ 8 | -I$(LIB_SRC)/edgeMesh/lnInclude \ 9 | -I$(LIB_SRC)/surfMesh/lnInclude \ 10 | -I$(LIB_SRC)/triSurface/lnInclude 11 | 12 | LIB_LIBS = \ 13 | -ldynamicMesh \ 14 | -lfiniteVolume \ 15 | -llagrangian \ 16 | -lmeshTools \ 17 | -lfileFormats \ 18 | -ledgeMesh \ 19 | -lsurfMesh \ 20 | -ltriSurface \ 21 | -ldistributed 22 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/cavitatingFoam/continuityErrs.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField thermoRho = psi*p + alphal*rhol0; 3 | 4 | dimensionedScalar totalMass = fvc::domainIntegrate(rho); 5 | 6 | scalar sumLocalContErr = 7 | ( 8 | fvc::domainIntegrate(mag(rho - thermoRho))/totalMass 9 | ).value(); 10 | 11 | scalar globalContErr = 12 | ( 13 | fvc::domainIntegrate(rho - thermoRho)/totalMass 14 | ).value(); 15 | 16 | cumulativeContErr += globalContErr; 17 | 18 | Info<< "time step continuity errors : sum local = " << sumLocalContErr 19 | << ", global = " << globalContErr 20 | << ", cumulative = " << cumulativeContErr 21 | << endl; 22 | } 23 | -------------------------------------------------------------------------------- /applications/solvers/combustion/XiFoam/ftEqn.H: -------------------------------------------------------------------------------- 1 | tmp> mvConvection 2 | ( 3 | fv::convectionScheme::New 4 | ( 5 | mesh, 6 | fields, 7 | phi, 8 | mesh.divScheme("div(phi,ft_b_ha_hau)") 9 | ) 10 | ); 11 | 12 | if (composition.contains("ft")) 13 | { 14 | volScalarField& ft = composition.Y("ft"); 15 | 16 | fvScalarMatrix ftEqn 17 | ( 18 | fvm::ddt(rho, ft) 19 | + mvConvection->fvmDiv(phi, ft) 20 | - fvm::laplacian(turbulence->alphaEff(), ft) 21 | == 22 | fvOptions(rho, ft) 23 | ); 24 | 25 | fvOptions.constrain(ftEqn); 26 | 27 | ftEqn.solve(); 28 | 29 | fvOptions.correct(ft); 30 | } 31 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createZones.H: -------------------------------------------------------------------------------- 1 | IOporosityModelList pZones(mesh); 2 | Switch pressureImplicitPorosity(false); 3 | 4 | // nUCorrectors used for pressureImplicitPorosity 5 | int nUCorr = 0; 6 | if (pZones.active()) 7 | { 8 | // nUCorrectors for pressureImplicitPorosity 9 | simple.dict().readIfPresent("nUCorrectors", nUCorr); 10 | 11 | if (nUCorr > 0) 12 | { 13 | pressureImplicitPorosity = true; 14 | Info<< "Using pressure implicit porosity" << endl; 15 | } 16 | else 17 | { 18 | Info<< "Using pressure explicit porosity" << endl; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/compressibleMultiphaseInterFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(mixture.rhoPhi(), U) 5 | + turbulence->divDevRhoReff(U) 6 | ); 7 | 8 | UEqn.relax(); 9 | 10 | if (pimple.momentumPredictor()) 11 | { 12 | solve 13 | ( 14 | UEqn 15 | == 16 | fvc::reconstruct 17 | ( 18 | ( 19 | mixture.surfaceTensionForce() 20 | - ghf*fvc::snGrad(rho) 21 | - fvc::snGrad(p_rgh) 22 | ) * mesh.magSf() 23 | ) 24 | ); 25 | 26 | K = 0.5*magSqr(U); 27 | } 28 | -------------------------------------------------------------------------------- /applications/utilities/mesh/manipulation/mergeMeshes/createTimes.H: -------------------------------------------------------------------------------- 1 | Info<< nl << "Create Times" << endl; 2 | 3 | const fileName masterCasePath = masterCase.path(); 4 | const fileName masterCaseName = masterCase.name(); 5 | 6 | Time runTimeMaster 7 | ( 8 | Time::controlDictName, 9 | masterCasePath, 10 | masterCaseName 11 | ); 12 | runTimeMaster.functionObjects().off(); 13 | 14 | const fileName addCasePath = addCase.path(); 15 | const fileName addCaseName = addCase.name(); 16 | 17 | Time runTimeToAdd 18 | ( 19 | Time::controlDictName, 20 | addCasePath, 21 | addCaseName 22 | ); 23 | runTimeToAdd.functionObjects().off(); 24 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/volContinuity.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField conserve(-fvc::div(mesh.phi())); 3 | // The ddt term constructed by hand because it would be wrong for 4 | // Backward Differencing in time. 5 | 6 | conserve.primitiveFieldRef() += 7 | (1.0 - mesh.V0()/mesh.V())/runTime.deltaTValue(); 8 | 9 | scalar sumLocalContErr = runTime.deltaTValue()* 10 | mag(conserve)().weightedAverage(mesh.V()).value(); 11 | 12 | scalar globalContErr = runTime.deltaTValue()* 13 | conserve.weightedAverage(mesh.V()).value(); 14 | 15 | Info<< "volume continuity errors : sum local = " << sumLocalContErr 16 | << ", global = " << globalContErr << endl; 17 | } 18 | -------------------------------------------------------------------------------- /src/lagrangian/molecularDynamics/molecule/mdTools/calculateMDFields.H: -------------------------------------------------------------------------------- 1 | const List>& cellOccupancy = molecules.cellOccupancy(); 2 | 3 | forAll(cellOccupancy, cell) 4 | { 5 | const List& molsInCell = cellOccupancy[cell]; 6 | 7 | forAll(molsInCell, mIC) 8 | { 9 | molecule* mol = molsInCell[mIC]; 10 | 11 | const label molId = mol->id(); 12 | 13 | const vector& molU = mol->U(); 14 | 15 | allSpeciesN_RU[molId][cell]++; 16 | 17 | allSpeciesM_RU[molId][cell] += mol->mass(); 18 | 19 | allSpeciesVelocitySum_RU[molId][cell] += molU; 20 | 21 | allSpeciesVelocityMagSquaredSum_RU[molId][cell] += molU & molU; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interPhaseChangeFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UEqn 2 | ( 3 | fvm::ddt(rho, U) 4 | + fvm::div(rhoPhi, U) 5 | - fvm::Sp(fvc::ddt(rho) + fvc::div(rhoPhi), U) 6 | + turbulence->divDevRhoReff(rho, U) 7 | ); 8 | 9 | UEqn.relax(); 10 | 11 | if (pimple.momentumPredictor()) 12 | { 13 | solve 14 | ( 15 | UEqn 16 | == 17 | fvc::reconstruct 18 | ( 19 | ( 20 | interface.surfaceTensionForce() 21 | - ghf*fvc::snGrad(rho) 22 | - fvc::snGrad(p_rgh) 23 | ) * mesh.magSf() 24 | ) 25 | ); 26 | } 27 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleContinuityErrors.H: -------------------------------------------------------------------------------- 1 | { 2 | dimensionedScalar totalMass = fvc::domainIntegrate(rho); 3 | 4 | scalar sumLocalContErr = 5 | ( 6 | fvc::domainIntegrate(mag(rho - thermo.rho()))/totalMass 7 | ).value(); 8 | 9 | scalar globalContErr = 10 | ( 11 | fvc::domainIntegrate(rho - thermo.rho())/totalMass 12 | ).value(); 13 | 14 | cumulativeContErr[i] += globalContErr; 15 | 16 | Info<< "time step continuity errors (" << mesh.name() << ")" 17 | << ": sum local = " << sumLocalContErr 18 | << ", global = " << globalContErr 19 | << ", cumulative = " << cumulativeContErr[i] 20 | << endl; 21 | } 22 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/simpleFoam/porousSimpleFoam/createPorousZones.H: -------------------------------------------------------------------------------- 1 | IOporosityModelList pZones(mesh); 2 | Switch pressureImplicitPorosity(false); 3 | 4 | // nUCorrectors used for pressureImplicitPorosity 5 | int nUCorr = 0; 6 | if (pZones.active()) 7 | { 8 | // nUCorrectors for pressureImplicitPorosity 9 | nUCorr = simple.dict().lookupOrDefault("nUCorrectors", 0); 10 | 11 | if (nUCorr > 0) 12 | { 13 | pressureImplicitPorosity = true; 14 | Info<< "Using pressure implicit porosity" << endl; 15 | } 16 | else 17 | { 18 | Info<< "Using pressure explicit porosity" << endl; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /applications/utilities/preProcessing/mapFields/createTimes.H: -------------------------------------------------------------------------------- 1 | Info<< "\nCreate databases as time" << endl; 2 | 3 | const auto caseDirOrig = getEnv("FOAM_CASE"); 4 | const auto caseNameOrig = getEnv("FOAM_CASE_NAME"); 5 | setEnv("FOAM_CASE", rootDirSource/caseDirSource, true); 6 | setEnv("FOAM_CASE_NAME", caseDirSource, true); 7 | Time runTimeSource 8 | ( 9 | Time::controlDictName, 10 | rootDirSource, 11 | caseDirSource 12 | ); 13 | setEnv("FOAM_CASE", caseDirOrig, true); 14 | setEnv("FOAM_CASE_NAME", caseNameOrig, true); 15 | 16 | Time runTimeTarget 17 | ( 18 | Time::controlDictName, 19 | rootDirTarget, 20 | caseDirTarget 21 | ); 22 | -------------------------------------------------------------------------------- /applications/utilities/surface/surfaceCoarsen/bunnylod/bunnylod.dsw: -------------------------------------------------------------------------------- 1 | Microsoft Developer Studio Workspace File, Format Version 5.00 2 | # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! 3 | 4 | ############################################################################### 5 | 6 | Project: "bunnylod"=.\bunnylod.dsp - Package Owner=<4> 7 | 8 | Package=<5> 9 | {{{ 10 | }}} 11 | 12 | Package=<4> 13 | {{{ 14 | }}} 15 | 16 | ############################################################################### 17 | 18 | Global: 19 | 20 | Package=<5> 21 | {{{ 22 | }}} 23 | 24 | Package=<3> 25 | {{{ 26 | }}} 27 | 28 | ############################################################################### 29 | 30 | -------------------------------------------------------------------------------- /applications/test/maxMem/Test-maxMem.C: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | if (argc != 2) 8 | { 9 | cerr << "Usage: " << argv[0] << " \n"; 10 | exit(1); 11 | } 12 | 13 | int nBytes = (1024U*1024U)*atoi(argv[1]); 14 | 15 | char *cPtr; 16 | 17 | for (unsigned i=1;; i++) 18 | { 19 | cPtr = new char[nBytes]; 20 | 21 | /* 22 | for (int j=0; jalphaEff(), he) 13 | == 14 | rho*(U&g) 15 | + radiation->Sh(thermo) 16 | + fvOptions(rho, he) 17 | ); 18 | 19 | EEqn.relax(); 20 | 21 | fvOptions.constrain(EEqn); 22 | 23 | EEqn.solve(); 24 | 25 | fvOptions.correct(he); 26 | 27 | thermo.correct(); 28 | radiation->correct(); 29 | } 30 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/compressibleContinuityErrors.H: -------------------------------------------------------------------------------- 1 | { 2 | dimensionedScalar totalMass = fvc::domainIntegrate(rho); 3 | 4 | scalar sumLocalContErr = 5 | ( 6 | fvc::domainIntegrate(mag(rho - thermo.rho()))/totalMass 7 | ).value(); 8 | 9 | scalar globalContErr = 10 | ( 11 | fvc::domainIntegrate(rho - thermo.rho())/totalMass 12 | ).value(); 13 | 14 | cumulativeContErr[i] += globalContErr; 15 | 16 | Info<< "time step continuity errors (" << mesh.name() << ")" 17 | << ": sum local = " << sumLocalContErr 18 | << ", global = " << globalContErr 19 | << ", cumulative = " << cumulativeContErr[i] 20 | << endl; 21 | } 22 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/createRDeltaT.H: -------------------------------------------------------------------------------- 1 | bool LTS = fv::localEulerDdt::enabled(mesh); 2 | 3 | tmp trDeltaT; 4 | 5 | if (LTS) 6 | { 7 | Info<< "Using LTS" << endl; 8 | 9 | trDeltaT = tmp 10 | ( 11 | new volScalarField 12 | ( 13 | IOobject 14 | ( 15 | fv::localEulerDdt::rDeltaTName, 16 | runTime.timeName(), 17 | mesh, 18 | IOobject::READ_IF_PRESENT, 19 | IOobject::AUTO_WRITE 20 | ), 21 | mesh, 22 | dimensionedScalar("one", dimless/dimTime, 1), 23 | extrapolatedCalculatedFvPatchScalarField::typeName 24 | ) 25 | ); 26 | } 27 | -------------------------------------------------------------------------------- /src/lagrangian/molecularDynamics/molecule/mdTools/resetMDFields.H: -------------------------------------------------------------------------------- 1 | if (runTime.writeTime()) 2 | { 3 | allSpeciesN_RU = List 4 | ( 5 | molecules.potential().nIds(), 6 | scalarField(mesh.nCells(), 0.0) 7 | ); 8 | 9 | allSpeciesM_RU = List 10 | ( 11 | molecules.potential().nIds(), 12 | scalarField(mesh.nCells(), 0.0) 13 | ); 14 | 15 | allSpeciesVelocitySum_RU = List 16 | ( 17 | molecules.potential().nIds(), 18 | vectorField(mesh.nCells(), Zero) 19 | ); 20 | 21 | allSpeciesVelocityMagSquaredSum_RU = List 22 | ( 23 | molecules.potential().nIds(), 24 | scalarField(mesh.nCells(), 0.0) 25 | ); 26 | } 27 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidMeshes.H: -------------------------------------------------------------------------------- 1 | const wordList fluidNames(rp["fluid"]); 2 | 3 | PtrList fluidRegions(fluidNames.size()); 4 | 5 | forAll(fluidNames, i) 6 | { 7 | Info<< "Create fluid mesh for region " << fluidNames[i] 8 | << " for time = " << runTime.timeName() << nl << endl; 9 | 10 | fluidRegions.set 11 | ( 12 | i, 13 | new fvMesh 14 | ( 15 | IOobject 16 | ( 17 | fluidNames[i], 18 | runTime.timeName(), 19 | runTime, 20 | IOobject::MUST_READ 21 | ) 22 | ) 23 | ); 24 | } 25 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/twoPhaseEulerFoam/createFieldRefs.H: -------------------------------------------------------------------------------- 1 | volScalarField& alpha2 = phase2; 2 | 3 | surfaceScalarField& phi1 = phase1.phi(); 4 | surfaceScalarField& alphaPhi1 = phase1.alphaPhi(); 5 | surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi(); 6 | 7 | surfaceScalarField& phi2 = phase2.phi(); 8 | surfaceScalarField& alphaPhi2 = phase2.alphaPhi(); 9 | surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi(); 10 | 11 | surfaceScalarField& phi = fluid.phi(); 12 | 13 | rhoThermo& thermo1 = phase1.thermo(); 14 | rhoThermo& thermo2 = phase2.thermo(); 15 | 16 | volScalarField& rho1 = thermo1.rho(); 17 | const volScalarField& psi1 = thermo1.psi(); 18 | 19 | volScalarField& rho2 = thermo2.rho(); 20 | const volScalarField& psi2 = thermo2.psi(); 21 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the Momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | tmp tUEqn 6 | ( 7 | fvm::div(phi, U) 8 | + MRF.DDt(rho, U) 9 | + turb.divDevRhoReff(U) 10 | == 11 | fvOptions(rho, U) 12 | ); 13 | fvVectorMatrix& UEqn = tUEqn.ref(); 14 | 15 | UEqn.relax(); 16 | 17 | fvOptions.constrain(UEqn); 18 | 19 | solve 20 | ( 21 | UEqn 22 | == 23 | fvc::reconstruct 24 | ( 25 | ( 26 | - ghf*fvc::snGrad(rho) 27 | - fvc::snGrad(p_rgh) 28 | )*mesh.magSf() 29 | ) 30 | ); 31 | 32 | fvOptions.correct(U); 33 | -------------------------------------------------------------------------------- /applications/solvers/combustion/PDRFoam/EaEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& hea = thermo.he(); 3 | 4 | fvScalarMatrix EaEqn 5 | ( 6 | betav*fvm::ddt(rho, hea) + mvConvection->fvmDiv(phi, hea) 7 | + betav*fvc::ddt(rho, K) + fvc::div(phi, K) 8 | + ( 9 | hea.name() == "ea" 10 | ? fvc::div 11 | ( 12 | phi/fvc::interpolate(rho), 13 | p, 14 | "div(phiv,p)" 15 | ) 16 | : -betav*dpdt 17 | ) 18 | - fvm::laplacian(Db, hea) 19 | + betav*fvOptions(rho, hea) 20 | ); 21 | 22 | EaEqn.relax(); 23 | 24 | fvOptions.constrain(EaEqn); 25 | 26 | EaEqn.solve(); 27 | 28 | fvOptions.correct(hea); 29 | 30 | thermo.correct(); 31 | } 32 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/DPMFoam/UcEqn.H: -------------------------------------------------------------------------------- 1 | fvVectorMatrix UcEqn 2 | ( 3 | fvm::ddt(alphac, Uc) + fvm::div(alphaPhic, Uc) 4 | - fvm::Sp(fvc::ddt(alphac) + fvc::div(alphaPhic), Uc) 5 | + continuousPhaseTurbulence->divDevRhoReff(Uc) 6 | == 7 | (1.0/rhoc)*cloudSU 8 | ); 9 | 10 | UcEqn.relax(); 11 | 12 | volScalarField rAUc(1.0/UcEqn.A()); 13 | surfaceScalarField rAUcf("Dp", fvc::interpolate(rAUc)); 14 | 15 | surfaceScalarField phicForces 16 | ( 17 | fvc::flux(rAUc*cloudVolSUSu/rhoc) + rAUcf*(g & mesh.Sf()) 18 | ); 19 | 20 | if (pimple.momentumPredictor()) 21 | { 22 | solve 23 | ( 24 | UcEqn 25 | == 26 | fvc::reconstruct 27 | ( 28 | phicForces/rAUcf - fvc::snGrad(p)*mesh.magSf() 29 | ) 30 | ); 31 | } 32 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H: -------------------------------------------------------------------------------- 1 | const wordList fluidNames(rp["fluid"]); 2 | 3 | PtrList fluidRegions(fluidNames.size()); 4 | 5 | forAll(fluidNames, i) 6 | { 7 | Info<< "Create fluid mesh for region " << fluidNames[i] 8 | << " for time = " << runTime.timeName() << nl << endl; 9 | 10 | fluidRegions.set 11 | ( 12 | i, 13 | new fvMesh 14 | ( 15 | IOobject 16 | ( 17 | fluidNames[i], 18 | runTime.timeName(), 19 | runTime, 20 | IOobject::MUST_READ 21 | ) 22 | ) 23 | ); 24 | } 25 | -------------------------------------------------------------------------------- /applications/solvers/compressible/rhoPimpleFoam/EEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& he = thermo.he(); 3 | 4 | fvScalarMatrix EEqn 5 | ( 6 | fvm::ddt(rho, he) + fvm::div(phi, he) 7 | + fvc::ddt(rho, K) + fvc::div(phi, K) 8 | + ( 9 | he.name() == "e" 10 | ? fvc::div 11 | ( 12 | fvc::absolute(phi/fvc::interpolate(rho), U), 13 | p, 14 | "div(phiv,p)" 15 | ) 16 | : -dpdt 17 | ) 18 | - fvm::laplacian(turbulence->alphaEff(), he) 19 | == 20 | fvOptions(rho, he) 21 | ); 22 | 23 | EEqn.relax(); 24 | 25 | fvOptions.constrain(EEqn); 26 | 27 | EEqn.solve(); 28 | 29 | fvOptions.correct(he); 30 | 31 | thermo.correct(); 32 | } 33 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/cellMax: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | ========= | 3 | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox 4 | \\ / O peration | 5 | \\ / A nd | Web: www.OpenFOAM.org 6 | \\/ M anipulation | 7 | ------------------------------------------------------------------------------- 8 | Description 9 | Writes out the maximum cell value for one or more fields. 10 | 11 | \*---------------------------------------------------------------------------*/ 12 | 13 | #includeEtc "caseDicts/postProcessing/minMax/cellMinMax.cfg" 14 | 15 | fields (U p); 16 | 17 | // ************************************************************************* // 18 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/cellMin: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | ========= | 3 | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox 4 | \\ / O peration | 5 | \\ / A nd | Web: www.OpenFOAM.org 6 | \\/ M anipulation | 7 | ------------------------------------------------------------------------------- 8 | Description 9 | Writes out the minimum cell value for one or more fields. 10 | 11 | \*---------------------------------------------------------------------------*/ 12 | 13 | #includeEtc "caseDicts/postProcessing/minMax/cellMin.cfg" 14 | 15 | fields (U p); 16 | 17 | // ************************************************************************* // 18 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/faceMax: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | ========= | 3 | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox 4 | \\ / O peration | 5 | \\ / A nd | Web: www.OpenFOAM.org 6 | \\/ M anipulation | 7 | ------------------------------------------------------------------------------- 8 | Description 9 | Writes out the maximum face value for one or more fields. 10 | 11 | \*---------------------------------------------------------------------------*/ 12 | 13 | #includeEtc "caseDicts/postProcessing/minMax/faceMinMax.cfg" 14 | 15 | fields (U p); 16 | 17 | // ************************************************************************* // 18 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/faceMin: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | ========= | 3 | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox 4 | \\ / O peration | 5 | \\ / A nd | Web: www.OpenFOAM.org 6 | \\/ M anipulation | 7 | ------------------------------------------------------------------------------- 8 | Description 9 | Writes out the minimum face value for one or more fields. 10 | 11 | \*---------------------------------------------------------------------------*/ 12 | 13 | #includeEtc "caseDicts/postProcessing/minMax/faceMin.cfg" 14 | 15 | fields (U p); 16 | 17 | // ************************************************************************* // 18 | -------------------------------------------------------------------------------- /src/thermophysicalModels/properties/liquidProperties/IDEA/IDEA.thermo: -------------------------------------------------------------------------------- 1 | a1-C10H7-CH3 a1-C10H7-CH3 1 142.2004 200 6000 1000 2 | 21.793921 0.03602141 -1.332287e-05 2.193044e-09 -1.3307138e-13 3162.6144 -94.86754 3 | -1.0304372 0.060335818 5.4565572e-05 -1.2276925e-07 5.5450733e-11 11324.101 32.297061; 4 | 5 | N-C10H22(DECANE) N-C10H22(DECANE) 1 142.28468 200 6000 1000 6 | 29.478296 0.049051894 -1.7031718e-05 2.729193e-09 -1.6337077e-13 -44302.262 -124.06212 7 | 15.432817 -0.013297923 0.00028248058 -3.659233e-07 1.4537212e-10 -35863.283 -27.945434; 8 | 9 | idea = idea 1 142.259 10 | 200 6000 1000 11 | 27.173 0.0451427 -1.59191e-05 2.56835e-09 -1.54281e-13 -30062.8 -115.304 12 | 10.4938 0.0087922 0.000214106 -2.92977e-07 1.18396e-10 -21707.1 -9.87269 13 | ; 14 | -------------------------------------------------------------------------------- /applications/solvers/combustion/XiFoam/EaEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& hea = thermo.he(); 3 | 4 | fvScalarMatrix EaEqn 5 | ( 6 | fvm::ddt(rho, hea) + mvConvection->fvmDiv(phi, hea) 7 | + fvc::ddt(rho, K) + fvc::div(phi, K) 8 | + ( 9 | hea.name() == "ea" 10 | ? fvc::div 11 | ( 12 | fvc::absolute(phi/fvc::interpolate(rho), U), 13 | p, 14 | "div(phiv,p)" 15 | ) 16 | : -dpdt 17 | ) 18 | - fvm::laplacian(turbulence->alphaEff(), hea) 19 | + fvOptions(rho, hea) 20 | ); 21 | 22 | EaEqn.relax(); 23 | 24 | fvOptions.constrain(EaEqn); 25 | 26 | EaEqn.solve(); 27 | 28 | fvOptions.correct(hea); 29 | 30 | thermo.correct(); 31 | } 32 | -------------------------------------------------------------------------------- /applications/solvers/incompressible/shallowWaterFoam/readGravitationalAcceleration.H: -------------------------------------------------------------------------------- 1 | Info<< "\nReading gravitationalProperties" << endl; 2 | 3 | IOdictionary gravitationalProperties 4 | ( 5 | IOobject 6 | ( 7 | "gravitationalProperties", 8 | runTime.constant(), 9 | mesh, 10 | IOobject::MUST_READ_IF_MODIFIED, 11 | IOobject::NO_WRITE 12 | ) 13 | ); 14 | 15 | const dimensionedVector g(gravitationalProperties.lookup("g")); 16 | const Switch rotating(gravitationalProperties.lookup("rotating")); 17 | const dimensionedVector Omega = 18 | rotating ? gravitationalProperties.lookup("Omega") 19 | : dimensionedVector("Omega", -dimTime, vector(0,0,0)); 20 | const dimensionedScalar magg = mag(g); 21 | const dimensionedVector gHat = g/magg; 22 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/toBeFunctionObjects/lagrangian/particleTracks/createFields.H: -------------------------------------------------------------------------------- 1 | IOdictionary propsDict 2 | ( 3 | IOobject 4 | ( 5 | "particleTrackProperties", 6 | runTime.constant(), 7 | mesh, 8 | IOobject::MUST_READ_IF_MODIFIED 9 | ) 10 | ); 11 | 12 | const word cloudName(propsDict.lookup("cloudName")); 13 | 14 | label sampleFrequency(readLabel(propsDict.lookup("sampleFrequency"))); 15 | 16 | // outputMode: compositeFile, filePerTrack 17 | //word outputmode(propsDict.lookup("outputMode")) 18 | 19 | label maxPositions(readLabel(propsDict.lookup("maxPositions"))); 20 | 21 | // outputFormat: raw, vtk 22 | //word outputFormat(propsDict.lookup("outputFormat")); 23 | word setFormat(propsDict.lookupOrDefault("setFormat", "vtk")); 24 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/checkPatchFieldTypes.H: -------------------------------------------------------------------------------- 1 | if (!isA(k_.boundaryField()[patchi])) 2 | { 3 | FatalErrorInFunction 4 | << k_.boundaryField()[patchi].type() 5 | << " is the wrong k patchField type for wall-functions on patch " 6 | << curPatch.name() << nl 7 | << " should be zeroGradient" 8 | << exit(FatalError); 9 | } 10 | 11 | if (!isA(epsilon_.boundaryField()[patchi])) 12 | { 13 | FatalErrorInFunction 14 | << epsilon_.boundaryField()[patchi].type() 15 | << " is the wrong epsilon patchField type for wall-functions on patch " 16 | << curPatch.name() << nl 17 | << " should be zeroGradient" 18 | << exit(FatalError); 19 | } 20 | -------------------------------------------------------------------------------- /src/randomProcesses/turbulence/Ek.H: -------------------------------------------------------------------------------- 1 | #ifndef Ek_H 2 | #define Ek_H 3 | 4 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // 5 | 6 | namespace Foam 7 | { 8 | 9 | inline tmp Ek 10 | ( 11 | const scalar Ea, 12 | const scalar k0, 13 | const scalarField& k 14 | ) 15 | { 16 | tmp tEk = Ea*pow(k/k0, 4.0)*exp(-2.0*sqr(k/k0)); 17 | 18 | /* 19 | scalarField& Ekf = tEk(); 20 | 21 | label i; 22 | forAll(Ekf, i) 23 | { 24 | if (k[i] < 2 || k[i] > 10) 25 | { 26 | Ekf[i] = 0.0; 27 | } 28 | } 29 | */ 30 | 31 | return tEk; 32 | } 33 | 34 | 35 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // 36 | 37 | } // End namespace Foam 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/cellMin.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/minMax/cellMinMax.cfg" 10 | operation min; 11 | 12 | // ************************************************************************* // 13 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/faceMin.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/minMax/faceMinMax.cfg" 10 | operation min; 11 | 12 | // ************************************************************************* // 13 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/minMax/minMaxComponents.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/minMax/fieldMinMax.cfg" 10 | mode component; 11 | 12 | // ************************************************************************* // 13 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/getLagrangianScalar.H: -------------------------------------------------------------------------------- 1 | 2 | // Not sure if this is necessary anymore 3 | nVar -= Num_variables - nSprayVariables; 4 | 5 | if (nVar >= 0) 6 | { 7 | word name = lagrangianScalarNames[nVar]; 8 | 9 | IOField s 10 | ( 11 | IOobject 12 | ( 13 | name, 14 | runTime.timeName(), 15 | cloud::prefix, 16 | mesh, 17 | IOobject::MUST_READ, 18 | IOobject::NO_WRITE 19 | ) 20 | ); 21 | 22 | if (s.size()) 23 | { 24 | forAll(s, n) 25 | { 26 | var_array[n+1] = s[n]; 27 | } 28 | } 29 | } 30 | else 31 | { 32 | // Info<< "getLagrangianScalar: nVar = " << nVar << endl; 33 | return Z_UNDEF; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/forces/forceCoeffs.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/forces/forces.cfg" 10 | 11 | type forceCoeffs; 12 | 13 | // ************************************************************************* // 14 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/solveSolid.H: -------------------------------------------------------------------------------- 1 | { 2 | for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) 3 | { 4 | fvScalarMatrix hEqn 5 | ( 6 | ( 7 | thermo.isotropic() 8 | ? -fvm::laplacian(betav*thermo.alpha(), h, "laplacian(alpha,h)") 9 | : -fvm::laplacian(betav*taniAlpha(), h, "laplacian(alpha,h)") 10 | ) 11 | == 12 | fvOptions(rho, h) 13 | ); 14 | 15 | hEqn.relax(); 16 | 17 | fvOptions.constrain(hEqn); 18 | 19 | hEqn.solve(); 20 | 21 | fvOptions.correct(h); 22 | } 23 | } 24 | 25 | thermo.correct(); 26 | 27 | Info<< "Min/max T:" << min(thermo.T()).value() << ' ' 28 | << max(thermo.T()).value() << endl; 29 | -------------------------------------------------------------------------------- /doc/Doxygen/footer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 12 | 13 | 14 |
15 | $generatedby   16 | doxygen 17 | $doxygenversion 18 |
19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | // Solve the momentum equation 2 | 3 | MRF.correctBoundaryVelocity(U); 4 | 5 | fvVectorMatrix UEqn 6 | ( 7 | fvm::ddt(U) + fvm::div(phi, U) 8 | + MRF.DDt(U) 9 | + turbulence->divDevReff(U) 10 | == 11 | fvOptions(U) 12 | ); 13 | 14 | UEqn.relax(); 15 | 16 | fvOptions.constrain(UEqn); 17 | 18 | if (pimple.momentumPredictor()) 19 | { 20 | solve 21 | ( 22 | UEqn 23 | == 24 | fvc::reconstruct 25 | ( 26 | ( 27 | - ghf*fvc::snGrad(rhok) 28 | - fvc::snGrad(p_rgh) 29 | )*mesh.magSf() 30 | ) 31 | ); 32 | 33 | fvOptions.correct(U); 34 | } 35 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/forces/forcesIncompressible.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/forces/forces.cfg" 10 | 11 | rho rhoInf; 12 | 13 | // ************************************************************************* // 14 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/surfaceRegion/patch.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/surfaceRegion/surfaceRegion.cfg" 10 | 11 | regionType patch; 12 | 13 | // ************************************************************************* // 14 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/solvers/scalarTransport/scalarTransport.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | type scalarTransport; 10 | libs ("libsolverFunctionObjects.so"); 11 | 12 | // ************************************************************************* // 13 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/surfaceRegion/faceZone.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/surfaceRegion/surfaceRegion.cfg" 10 | 11 | regionType faceZone; 12 | 13 | // ************************************************************************* // 14 | -------------------------------------------------------------------------------- /src/lagrangian/spray/submodels/AtomizationModel/LISAAtomization/LISASMDCalcMethod1.H: -------------------------------------------------------------------------------- 1 | { 2 | // calculate the new diameter with a Rosin Rammler distribution 3 | 4 | scalar minValue = min(d, dD/10.0); 5 | scalar maxValue = dD; 6 | 7 | if (maxValue - minValue < SMALL) 8 | { 9 | minValue = d/10.0; 10 | } 11 | 12 | scalar range = maxValue - minValue; 13 | 14 | scalar y = 0; 15 | 16 | bool success = false; 17 | 18 | while(!success) 19 | { 20 | 21 | x = minValue + range*rndGen.sample01(); 22 | y = rndGen.sample01(); 23 | scalar p = 0.0; 24 | scalar nExp = 1; 25 | scalar xx = pow(x/dD, nExp); 26 | 27 | p = xx*exp(-xx); 28 | if (ydivDevRhoReff(U) 8 | == 9 | parcels.SU(U) 10 | + fvOptions(rho, U) 11 | ); 12 | 13 | UEqn.relax(); 14 | 15 | fvOptions.constrain(UEqn); 16 | 17 | if (pimple.momentumPredictor()) 18 | { 19 | solve 20 | ( 21 | UEqn 22 | == 23 | fvc::reconstruct 24 | ( 25 | ( 26 | - ghf*fvc::snGrad(rho) 27 | - fvc::snGrad(p_rgh) 28 | )*mesh.magSf() 29 | ) 30 | ); 31 | 32 | fvOptions.correct(U); 33 | K = 0.5*magSqr(U); 34 | } 35 | -------------------------------------------------------------------------------- /applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | fvOptions(rho, U) 10 | ); 11 | 12 | UEqn.relax(); 13 | 14 | fvOptions.constrain(UEqn); 15 | 16 | if (pimple.momentumPredictor()) 17 | { 18 | solve 19 | ( 20 | UEqn 21 | == 22 | fvc::reconstruct 23 | ( 24 | ( 25 | - ghf*fvc::snGrad(rho) 26 | - fvc::snGrad(p_rgh) 27 | )*mesh.magSf() 28 | ) 29 | ); 30 | 31 | fvOptions.correct(U); 32 | K = 0.5*magSqr(U); 33 | } 34 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H: -------------------------------------------------------------------------------- 1 | // check for "points" in any of the result directories 2 | 3 | bool meshMoving = false; 4 | if (Times.size() > 1) 5 | { 6 | // We already loaded a mesh (usually from constant). See if any other 7 | // points files 8 | forAll(Times, timeI) 9 | { 10 | if (Times[timeI].name() != mesh.pointsInstance()) 11 | { 12 | IOobject io 13 | ( 14 | "points", 15 | Times[timeI].name(), 16 | polyMesh::meshSubDir, 17 | mesh, 18 | IOobject::NO_READ 19 | ); 20 | if (io.headerOk()) 21 | { 22 | meshMoving = true; 23 | break; 24 | } 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/flowRate/flowRatePatch.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | #includeEtc "caseDicts/postProcessing/surfaceRegion/patch.cfg" 10 | 11 | fields (phi); 12 | operation sum; 13 | 14 | // ************************************************************************* // 15 | -------------------------------------------------------------------------------- /src/finiteVolume/cfdTools/general/include/alphaControls.H: -------------------------------------------------------------------------------- 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name()); 2 | 3 | label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr"))); 4 | 5 | label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles"))); 6 | 7 | bool MULESCorr(alphaControls.lookupOrDefault("MULESCorr", false)); 8 | 9 | // Apply the compression correction from the previous iteration 10 | // Improves efficiency for steady-simulations but can only be applied 11 | // once the alpha field is reasonably steady, i.e. fully developed 12 | bool alphaApplyPrevCorr 13 | ( 14 | alphaControls.lookupOrDefault("alphaApplyPrevCorr", false) 15 | ); 16 | 17 | // Isotropic compression coefficient 18 | scalar icAlpha 19 | ( 20 | alphaControls.lookupOrDefault("icAlpha", 0) 21 | ); 22 | -------------------------------------------------------------------------------- /applications/solvers/heatTransfer/thermoFoam/EEqn.H: -------------------------------------------------------------------------------- 1 | { 2 | volScalarField& he = thermo.he(); 3 | 4 | fvScalarMatrix EEqn 5 | ( 6 | fvm::ddt(rho, he) + fvm::div(phi, he) 7 | + fvc::ddt(rho, K) + fvc::div(phi, K) 8 | + ( 9 | he.name() == "e" 10 | ? fvc::div 11 | ( 12 | fvc::absolute(phi/fvc::interpolate(rho), U), 13 | p, 14 | "div(phiv,p)" 15 | ) 16 | : -dpdt 17 | ) 18 | - fvm::laplacian(alphaEff, he) 19 | == 20 | radiation->Sh(thermo) 21 | + fvOptions(rho, he) 22 | ); 23 | 24 | EEqn.relax(); 25 | 26 | fvOptions.constrain(EEqn); 27 | 28 | EEqn.solve(); 29 | 30 | fvOptions.correct(he); 31 | 32 | thermo.correct(); 33 | radiation->correct(); 34 | } 35 | -------------------------------------------------------------------------------- /applications/solvers/multiphase/interFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(rhoPhi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(rho, U) 8 | == 9 | fvOptions(rho, U) 10 | ); 11 | 12 | UEqn.relax(); 13 | 14 | fvOptions.constrain(UEqn); 15 | 16 | if (pimple.momentumPredictor()) 17 | { 18 | solve 19 | ( 20 | UEqn 21 | == 22 | fvc::reconstruct 23 | ( 24 | ( 25 | mixture.surfaceTensionForce() 26 | - ghf*fvc::snGrad(rho) 27 | - fvc::snGrad(p_rgh) 28 | ) * mesh.magSf() 29 | ) 30 | ); 31 | 32 | fvOptions.correct(U); 33 | } 34 | -------------------------------------------------------------------------------- /src/OpenFOAM/include/addFunctionObjectOptions.H: -------------------------------------------------------------------------------- 1 | #include "addDictOption.H" 2 | Foam::argList::addOption 3 | ( 4 | "field", 5 | "name", 6 | "Specify the name of the field to be processed, e.g. U" 7 | ); 8 | Foam::argList::addOption 9 | ( 10 | "fields", 11 | "list", 12 | "Specify a list of fields to be processed, e.g. '(U T p)' - " 13 | "regular expressions not currently supported" 14 | ); 15 | Foam::argList::addOption 16 | ( 17 | "func", 18 | "name", 19 | "Specify the name of the functionObject to execute, e.g. Q" 20 | ); 21 | Foam::argList::addOption 22 | ( 23 | "funcs", 24 | "list", 25 | "Specify the names of the functionObjects to execute, e.g. '(Q div(U))'" 26 | ); 27 | Foam::argList::addBoolOption 28 | ( 29 | "list", 30 | "List the available configured functionObjects" 31 | ); 32 | -------------------------------------------------------------------------------- /applications/utilities/postProcessing/graphics/ensightFoamReader/tensorConversion.H: -------------------------------------------------------------------------------- 1 | if (component == 0) 2 | { 3 | var_array[counter++] = tf[n].xx(); 4 | } 5 | else if (component == 1) 6 | { 7 | var_array[counter++] = tf[n].yy(); 8 | } 9 | else if (component == 2) 10 | { 11 | var_array[counter++] = tf[n].zz(); 12 | } 13 | else if (component == 3) 14 | { 15 | var_array[counter++] = tf[n].xy(); 16 | } 17 | else if (component == 4) 18 | { 19 | var_array[counter++] = tf[n].xz(); 20 | } 21 | else if (component == 5) 22 | { 23 | var_array[counter++] = tf[n].yz(); 24 | } 25 | else if (component == 6) 26 | { 27 | var_array[counter++] = tf[n].yx(); 28 | } 29 | else if (component == 7) 30 | { 31 | var_array[counter++] = tf[n].zx(); 32 | } 33 | else if (component == 8) 34 | { 35 | var_array[counter++] = tf[n].zy(); 36 | } 37 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/probes/probes.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | type probes; 10 | libs ("libsampling.so"); 11 | 12 | writeControl timeStep; 13 | writeInterval 1; 14 | 15 | // ************************************************************************* // 16 | -------------------------------------------------------------------------------- /applications/solvers/lagrangian/reactingParcelFilmFoam/UEqn.H: -------------------------------------------------------------------------------- 1 | MRF.correctBoundaryVelocity(U); 2 | 3 | fvVectorMatrix UEqn 4 | ( 5 | fvm::ddt(rho, U) + fvm::div(phi, U) 6 | + MRF.DDt(rho, U) 7 | + turbulence->divDevRhoReff(U) 8 | == 9 | parcels.SU(U) 10 | + fvOptions(rho, U) 11 | ); 12 | 13 | UEqn.relax(); 14 | 15 | fvOptions.constrain(UEqn); 16 | 17 | if (pimple.momentumPredictor()) 18 | { 19 | solve 20 | ( 21 | UEqn 22 | == 23 | fvc::reconstruct 24 | ( 25 | ( 26 | - ghf*fvc::snGrad(rho) 27 | - fvc::snGrad(p_rgh) 28 | )*mesh.magSf() 29 | ) 30 | ); 31 | 32 | fvOptions.correct(U); 33 | K = 0.5*magSqr(U); 34 | } 35 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/probes/cloud.cfg: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | | ========= | | 3 | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | 4 | | \\ / O peration | Version: 4.x | 5 | | \\ / A nd | Web: www.OpenFOAM.org | 6 | | \\/ M anipulation | | 7 | \*---------------------------------------------------------------------------*/ 8 | 9 | type sets; 10 | libs ("libsampling.so"); 11 | 12 | executeControl writeTime; 13 | writeControl writeTime; 14 | 15 | // ************************************************************************* // 16 | -------------------------------------------------------------------------------- /etc/caseDicts/postProcessing/probes/probes: -------------------------------------------------------------------------------- 1 | /*--------------------------------*- C++ -*----------------------------------*\ 2 | ========= | 3 | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox 4 | \\ / O peration | 5 | \\ / A nd | Web: www.OpenFOAM.org 6 | \\/ M anipulation | 7 | ------------------------------------------------------------------------------- 8 | Description 9 | Writes out values of fields from cells nearest to specified locations. 10 | 11 | \*---------------------------------------------------------------------------*/ 12 | 13 | #includeEtc "caseDicts/postProcessing/probes/probes.cfg" 14 | 15 | fields (p U); 16 | probeLocations 17 | ( 18 | (0 0 0) 19 | ); 20 | 21 | // ************************************************************************* // 22 | --------------------------------------------------------------------------------