├── .clang-format ├── .github └── workflows │ ├── dispatch_opm_simulators.yml │ └── manual_label_checker.yml ├── .gitignore ├── CHANGELOG.md ├── CMakeLists.txt ├── CMakeLists_files.cmake ├── CTestConfig.cmake ├── LICENSE ├── README.md ├── bin └── hipify_file.sh ├── cmake └── test │ └── testFloatFromChars.cpp ├── compareECLFiles.cmake ├── doc ├── doxygen │ └── Doxylocal ├── handbook │ ├── EPS │ │ ├── Ex2_Boundary.eps │ │ ├── Ex2_Domain.eps │ │ ├── box_disc.eps │ │ ├── car-hierarchy.eps │ │ ├── car-propertynames.eps │ │ ├── dunedesign.eps │ │ ├── ewoms_structure.eps │ │ ├── exercise1_c.eps │ │ ├── masstransfer.eps │ │ └── tutorial-problemconfiguration.eps │ ├── ModelDescriptions │ │ ├── blackoilmodel.tex │ │ ├── flashmodel.tex │ │ ├── immisciblemodel.tex │ │ ├── ncpmodel.tex │ │ ├── pvsmodel.tex │ │ ├── richardsmodel.tex │ │ └── stokesmodel.tex │ ├── SVG │ │ ├── box_disc.svg │ │ ├── car-hierarchy.svg │ │ ├── car-propertynames.svg │ │ └── ewoms_structure.svg │ ├── XFIG │ │ ├── Ex2_Boundary.fig │ │ ├── Ex2_Domain.fig │ │ ├── exercise1_c.fig │ │ └── exercise_1a.fig │ ├── box.tex │ ├── build-handbook.sh │ ├── designpatterns.tex │ ├── ewoms-handbook.bib │ ├── ewoms-handbook.tex │ ├── fluidframework.tex │ ├── getting-started.tex │ ├── guidelines.tex │ ├── install.tex │ ├── intro.tex │ ├── models.tex │ ├── newton-in-a-nutshell.tex │ ├── parameters.tex │ ├── propertysystem.tex │ ├── quick-install.tex │ ├── quickstart-guide.tex │ ├── structure.tex │ ├── tutorial-newmodel.tex │ ├── tutorial.tex │ └── tutorial1.tex ├── logo │ └── dumux_logo_hires_whitebg.eps └── man1 │ └── flow.1 ├── dune.module ├── examples ├── art2dgf.cpp ├── co2_ptflash_ecfv.cpp ├── co2injection_flash_ecfv.cpp ├── co2injection_flash_ni_ecfv.cpp ├── co2injection_flash_ni_vcfv.cpp ├── co2injection_flash_vcfv.cpp ├── co2injection_immiscible_ecfv.cpp ├── co2injection_immiscible_ni_ecfv.cpp ├── co2injection_immiscible_ni_vcfv.cpp ├── co2injection_immiscible_vcfv.cpp ├── co2injection_ncp_ecfv.cpp ├── co2injection_ncp_ni_ecfv.cpp ├── co2injection_ncp_ni_vcfv.cpp ├── co2injection_ncp_vcfv.cpp ├── co2injection_pvs_ecfv.cpp ├── co2injection_pvs_ni_ecfv.cpp ├── co2injection_pvs_ni_vcfv.cpp ├── co2injection_pvs_vcfv.cpp ├── cuvette_pvs.cpp ├── diffusion_flash.cpp ├── diffusion_ncp.cpp ├── diffusion_pvs.cpp ├── finger_immiscible_ecfv.cpp ├── finger_immiscible_vcfv.cpp ├── fracture_discretefracture.cpp ├── groundwater_immiscible.cpp ├── infiltration_pvs.cpp ├── lens_immiscible_ecfv_ad.cpp ├── lens_immiscible_ecfv_ad.hh ├── lens_immiscible_ecfv_ad_23.cpp ├── lens_immiscible_ecfv_ad_cu1.cpp ├── lens_immiscible_ecfv_ad_cu2.cpp ├── lens_immiscible_ecfv_ad_main.cpp ├── lens_immiscible_ecfv_ad_trans.cpp ├── lens_immiscible_vcfv_ad.cpp ├── lens_immiscible_vcfv_fd.cpp ├── lens_richards_ecfv.cpp ├── lens_richards_vcfv.cpp ├── mrst │ └── sim_simple.m ├── obstacle_immiscible.cpp ├── obstacle_ncp.cpp ├── obstacle_pvs.cpp ├── opmrst_inspect.cpp ├── outflow_pvs.cpp ├── powerinjection_darcy_ad.cpp ├── powerinjection_darcy_fd.cpp ├── powerinjection_forchheimer_ad.cpp ├── powerinjection_forchheimer_fd.cpp ├── printvfp.cpp ├── problems │ ├── co2injectionflash.hh │ ├── co2injectionproblem.hh │ ├── co2ptflashproblem.hh │ ├── cuvetteproblem.hh │ ├── diffusionproblem.hh │ ├── fingerproblem.hh │ ├── fractureproblem.hh │ ├── groundwaterproblem.hh │ ├── infiltrationproblem.hh │ ├── lensproblem.hh │ ├── obstacleproblem.hh │ ├── outflowproblem.hh │ ├── powerinjectionproblem.hh │ ├── reservoirproblem.hh │ ├── richardslensproblem.hh │ └── waterairproblem.hh ├── reservoir_blackoil_ecfv.cpp ├── reservoir_blackoil_vcfv.cpp ├── reservoir_ncp_ecfv.cpp ├── reservoir_ncp_vcfv.cpp ├── tutorial1.cpp ├── tutorial1problem.hh └── waterair_pvs_ni.cpp ├── flow ├── flow.cpp ├── flow_blackoil.cpp ├── flow_blackoil.hpp ├── flow_blackoil_alugrid.cpp ├── flow_blackoil_float_main.cpp ├── flow_blackoil_legacyassembly.cpp ├── flow_blackoil_legacyassembly.hpp ├── flow_blackoil_legacyassembly_main.cpp ├── flow_blackoil_main.cpp ├── flow_blackoil_polyhedralgrid.cpp ├── flow_brine.cpp ├── flow_brine.hpp ├── flow_brine_energy.cpp ├── flow_brine_energy.hpp ├── flow_brine_energy_main.cpp ├── flow_brine_main.cpp ├── flow_brine_precsalt_vapwat.cpp ├── flow_brine_precsalt_vapwat.hpp ├── flow_brine_precsalt_vapwat_main.cpp ├── flow_brine_saltprecipitation.cpp ├── flow_brine_saltprecipitation.hpp ├── flow_brine_saltprecipitation_main.cpp ├── flow_distribute_z.cpp ├── flow_energy.cpp ├── flow_energy.hpp ├── flow_energy_main.cpp ├── flow_extbo.cpp ├── flow_extbo.hpp ├── flow_extbo_main.cpp ├── flow_foam.cpp ├── flow_foam.hpp ├── flow_foam_main.cpp ├── flow_gasoil.cpp ├── flow_gasoil.hpp ├── flow_gasoil_energy.cpp ├── flow_gasoil_energy.hpp ├── flow_gasoil_energy_main.cpp ├── flow_gasoil_main.cpp ├── flow_gasoildiffuse.cpp ├── flow_gasoildiffuse.hpp ├── flow_gasoildiffuse_main.cpp ├── flow_gaswater.cpp ├── flow_gaswater.hpp ├── flow_gaswater_brine.cpp ├── flow_gaswater_brine.hpp ├── flow_gaswater_brine_main.cpp ├── flow_gaswater_dissolution.cpp ├── flow_gaswater_dissolution.hpp ├── flow_gaswater_dissolution_diffuse.cpp ├── flow_gaswater_dissolution_diffuse.hpp ├── flow_gaswater_dissolution_diffuse_main.cpp ├── flow_gaswater_dissolution_main.cpp ├── flow_gaswater_energy.cpp ├── flow_gaswater_energy.hpp ├── flow_gaswater_energy_main.cpp ├── flow_gaswater_main.cpp ├── flow_gaswater_saltprec_energy.cpp ├── flow_gaswater_saltprec_energy.hpp ├── flow_gaswater_saltprec_energy_main.cpp ├── flow_gaswater_saltprec_vapwat.cpp ├── flow_gaswater_saltprec_vapwat.hpp ├── flow_gaswater_saltprec_vapwat_main.cpp ├── flow_gaswater_solvent.cpp ├── flow_gaswater_solvent.hpp ├── flow_gaswater_solvent_main.cpp ├── flow_micp.cpp ├── flow_micp.hpp ├── flow_micp_main.cpp ├── flow_oilwater.cpp ├── flow_oilwater.hpp ├── flow_oilwater_brine.cpp ├── flow_oilwater_brine.hpp ├── flow_oilwater_brine_main.cpp ├── flow_oilwater_main.cpp ├── flow_oilwater_polymer.cpp ├── flow_oilwater_polymer.hpp ├── flow_oilwater_polymer_injectivity.cpp ├── flow_oilwater_polymer_injectivity.hpp ├── flow_oilwater_polymer_injectivity_main.cpp ├── flow_oilwater_polymer_main.cpp ├── flow_onephase.cpp ├── flow_onephase.hpp ├── flow_onephase_energy.cpp ├── flow_onephase_energy.hpp ├── flow_onephase_energy_main.cpp ├── flow_onephase_main.cpp ├── flow_polymer.cpp ├── flow_polymer.hpp ├── flow_polymer_main.cpp ├── flow_solvent.cpp ├── flow_solvent.hpp ├── flow_solvent_foam.cpp ├── flow_solvent_foam.hpp ├── flow_solvent_foam_main.cpp └── flow_solvent_main.cpp ├── flowexperimental ├── BlackOilEnergyIntensiveQuantitiesGlobalIndex.hpp ├── BlackOilIntensiveQuantitiesGlobalIndex.hpp ├── FIBlackOilModelNoCache.hpp ├── FlowExpNewtonMethod.hpp ├── comp │ ├── EmptyModel.hpp │ ├── flowexp_comp.cpp │ ├── flowexp_comp.hpp │ ├── flowexp_comp2.cpp │ ├── flowexp_comp2_2p.cpp │ ├── flowexp_comp3.cpp │ ├── flowexp_comp3_2p.cpp │ ├── flowexp_comp4.cpp │ ├── flowexp_comp4_2p.cpp │ ├── flowexp_comp5.cpp │ ├── flowexp_comp5_2p.cpp │ ├── flowexp_comp6.cpp │ ├── flowexp_comp6_2p.cpp │ ├── flowexp_comp7.cpp │ ├── flowexp_comp7_2p.cpp │ └── wells │ │ ├── CompWell.hpp │ │ ├── CompWellEquations.hpp │ │ ├── CompWellEquations_impl.hpp │ │ ├── CompWellInterface.hpp │ │ ├── CompWellInterface_impl.hpp │ │ ├── CompWellModel.hpp │ │ ├── CompWellModel_impl.hpp │ │ ├── CompWellPrimaryVariables.hpp │ │ ├── CompWellPrimaryVariables_impl.hpp │ │ ├── CompWellState.hpp │ │ ├── CompWellState_impl.hpp │ │ ├── CompWell_impl.hpp │ │ ├── SingleCompWellState.hpp │ │ └── SingleCompWellState_impl.hpp ├── flowexp.hpp └── flowexp_blackoil.cpp ├── jenkins ├── README.md ├── build.sh ├── run-norne.sh └── run-spe.sh ├── modelTests.cmake ├── opencl-source-provider.cmake ├── opm-simulators-prereqs.cmake ├── opm ├── models │ ├── blackoil │ │ ├── blackoilboundaryratevector.hh │ │ ├── blackoilbrinemodules.hh │ │ ├── blackoilbrineparams.cpp │ │ ├── blackoilbrineparams.hpp │ │ ├── blackoilconvectivemixingmodule.hh │ │ ├── blackoildarcyfluxmodule.hh │ │ ├── blackoildiffusionmodule.hh │ │ ├── blackoildispersionmodule.hh │ │ ├── blackoilenergymodules.hh │ │ ├── blackoilextbomodules.hh │ │ ├── blackoilextboparams.cpp │ │ ├── blackoilextboparams.hpp │ │ ├── blackoilextensivequantities.hh │ │ ├── blackoilfoammodules.hh │ │ ├── blackoilfoamparams.cpp │ │ ├── blackoilfoamparams.hpp │ │ ├── blackoilintensivequantities.hh │ │ ├── blackoillocalresidual.hh │ │ ├── blackoillocalresidualtpfa.hh │ │ ├── blackoilmicpmodules.hh │ │ ├── blackoilmicpparams.cpp │ │ ├── blackoilmicpparams.hpp │ │ ├── blackoilmodel.hh │ │ ├── blackoilnewtonmethod.hpp │ │ ├── blackoilnewtonmethodparams.cpp │ │ ├── blackoilnewtonmethodparams.hpp │ │ ├── blackoilonephaseindices.hh │ │ ├── blackoilpolymermodules.hh │ │ ├── blackoilpolymerparams.cpp │ │ ├── blackoilpolymerparams.hpp │ │ ├── blackoilprimaryvariables.hh │ │ ├── blackoilproblem.hh │ │ ├── blackoilproperties.hh │ │ ├── blackoilratevector.hh │ │ ├── blackoilsolventmodules.hh │ │ ├── blackoilsolventparams.cpp │ │ ├── blackoilsolventparams.hpp │ │ ├── blackoiltwophaseindices.hh │ │ └── blackoilvariableandequationindices.hh │ ├── common │ │ ├── darcyfluxmodule.hh │ │ ├── diffusionmodule.hh │ │ ├── directionalmobility.hh │ │ ├── energymodule.hh │ │ ├── flux.hh │ │ ├── forchheimerfluxmodule.hh │ │ ├── multiphasebaseextensivequantities.hh │ │ ├── multiphasebasemodel.hh │ │ ├── multiphasebaseparameters.hh │ │ ├── multiphasebaseproblem.hh │ │ ├── multiphasebaseproperties.hh │ │ ├── quantitycallbacks.hh │ │ └── transfluxmodule.hh │ ├── discretefracture │ │ ├── discretefractureextensivequantities.hh │ │ ├── discretefractureintensivequantities.hh │ │ ├── discretefracturelocalresidual.hh │ │ ├── discretefracturemodel.hh │ │ ├── discretefractureprimaryvariables.hh │ │ ├── discretefractureproblem.hh │ │ ├── discretefractureproperties.hh │ │ └── fracturemapper.hh │ ├── discretization │ │ ├── common │ │ │ ├── baseauxiliarymodule.hh │ │ │ ├── fvbaseadlocallinearizer.hh │ │ │ ├── fvbaseboundarycontext.hh │ │ │ ├── fvbaseconstraints.hh │ │ │ ├── fvbaseconstraintscontext.hh │ │ │ ├── fvbasediscretization.hh │ │ │ ├── fvbasediscretizationfemadapt.hh │ │ │ ├── fvbaseelementcontext.hh │ │ │ ├── fvbaseextensivequantities.hh │ │ │ ├── fvbasefdlocallinearizer.hh │ │ │ ├── fvbasegradientcalculator.hh │ │ │ ├── fvbaseintensivequantities.hh │ │ │ ├── fvbaselinearizer.hh │ │ │ ├── fvbaselocalresidual.hh │ │ │ ├── fvbasenewtonconvergencewriter.hh │ │ │ ├── fvbasenewtonmethod.hh │ │ │ ├── fvbaseparameters.hh │ │ │ ├── fvbaseprimaryvariables.hh │ │ │ ├── fvbaseproblem.hh │ │ │ ├── fvbaseproperties.hh │ │ │ ├── linearizationtype.hh │ │ │ ├── restrictprolong.hh │ │ │ └── tpfalinearizer.hh │ │ ├── ecfv │ │ │ ├── ecfvbaseoutputmodule.hh │ │ │ ├── ecfvdiscretization.hh │ │ │ ├── ecfvgridcommhandlefactory.hh │ │ │ ├── ecfvproperties.hh │ │ │ └── ecfvstencil.hh │ │ └── vcfv │ │ │ ├── p1fegradientcalculator.hh │ │ │ ├── vcfvbaseoutputmodule.hh │ │ │ ├── vcfvdiscretization.hh │ │ │ ├── vcfvgridcommhandlefactory.hh │ │ │ ├── vcfvproperties.hh │ │ │ └── vcfvstencil.hh │ ├── flash │ │ ├── flashboundaryratevector.hh │ │ ├── flashextensivequantities.hh │ │ ├── flashindices.hh │ │ ├── flashintensivequantities.hh │ │ ├── flashlocalresidual.hh │ │ ├── flashmodel.hh │ │ ├── flashparameters.hh │ │ ├── flashprimaryvariables.hh │ │ ├── flashproperties.hh │ │ └── flashratevector.hh │ ├── immiscible │ │ ├── immiscibleboundaryratevector.hh │ │ ├── immiscibleextensivequantities.hh │ │ ├── immiscibleindices.hh │ │ ├── immiscibleintensivequantities.hh │ │ ├── immisciblelocalresidual.hh │ │ ├── immisciblemodel.hh │ │ ├── immiscibleprimaryvariables.hh │ │ ├── immiscibleproperties.hh │ │ └── immiscibleratevector.hh │ ├── io │ │ ├── baseoutputmodule.hh │ │ ├── baseoutputwriter.hh │ │ ├── basevanguard.hh │ │ ├── cubegridvanguard.hh │ │ ├── dgfvanguard.hh │ │ ├── restart.cpp │ │ ├── restart.hpp │ │ ├── simplexvanguard.hh │ │ ├── structuredgridvanguard.hh │ │ ├── unstructuredgridvanguard.hh │ │ ├── vtkblackoilenergymodule.hpp │ │ ├── vtkblackoilenergyparams.cpp │ │ ├── vtkblackoilenergyparams.hpp │ │ ├── vtkblackoilmicpmodule.hpp │ │ ├── vtkblackoilmicpparams.cpp │ │ ├── vtkblackoilmicpparams.hpp │ │ ├── vtkblackoilmodule.hpp │ │ ├── vtkblackoilparams.cpp │ │ ├── vtkblackoilparams.hpp │ │ ├── vtkblackoilpolymermodule.hpp │ │ ├── vtkblackoilpolymerparams.cpp │ │ ├── vtkblackoilpolymerparams.hpp │ │ ├── vtkblackoilsolventmodule.hpp │ │ ├── vtkblackoilsolventparams.cpp │ │ ├── vtkblackoilsolventparams.hpp │ │ ├── vtkcompositionmodule.hpp │ │ ├── vtkcompositionparams.cpp │ │ ├── vtkcompositionparams.hpp │ │ ├── vtkdiffusionmodule.hpp │ │ ├── vtkdiffusionparams.cpp │ │ ├── vtkdiffusionparams.hpp │ │ ├── vtkdiscretefracturemodule.hpp │ │ ├── vtkdiscretefractureparams.cpp │ │ ├── vtkdiscretefractureparams.hpp │ │ ├── vtkenergymodule.hpp │ │ ├── vtkenergyparams.cpp │ │ ├── vtkenergyparams.hpp │ │ ├── vtkmultiphasemodule.hpp │ │ ├── vtkmultiphaseparams.cpp │ │ ├── vtkmultiphaseparams.hpp │ │ ├── vtkmultiwriter.hh │ │ ├── vtkphasepresencemodule.hpp │ │ ├── vtkphasepresenceparams.cpp │ │ ├── vtkphasepresenceparams.hpp │ │ ├── vtkprimaryvarsmodule.hpp │ │ ├── vtkprimaryvarsparams.cpp │ │ ├── vtkprimaryvarsparams.hpp │ │ ├── vtkptflashmodule.hpp │ │ ├── vtkptflashparams.cpp │ │ ├── vtkptflashparams.hpp │ │ ├── vtkscalarfunction.hh │ │ ├── vtktemperaturemodule.hpp │ │ ├── vtktemperatureparams.cpp │ │ ├── vtktemperatureparams.hpp │ │ ├── vtktensorfunction.hh │ │ └── vtkvectorfunction.hh │ ├── ncp │ │ ├── ncpboundaryratevector.hh │ │ ├── ncpextensivequantities.hh │ │ ├── ncpindices.hh │ │ ├── ncpintensivequantities.hh │ │ ├── ncplocalresidual.hh │ │ ├── ncpmodel.hh │ │ ├── ncpnewtonmethod.hh │ │ ├── ncpprimaryvariables.hh │ │ ├── ncpproperties.hh │ │ └── ncpratevector.hh │ ├── nonlinear │ │ ├── newtonmethod.hh │ │ ├── newtonmethodparams.cpp │ │ ├── newtonmethodparams.hpp │ │ ├── newtonmethodproperties.hh │ │ └── nullconvergencewriter.hh │ ├── parallel │ │ ├── gridcommhandles.hh │ │ ├── mpibuffer.hh │ │ ├── tasklets.cpp │ │ ├── tasklets.hpp │ │ ├── threadedentityiterator.hh │ │ ├── threadmanager.cpp │ │ └── threadmanager.hpp │ ├── ptflash │ │ ├── flashindices.hh │ │ ├── flashintensivequantities.hh │ │ ├── flashlocalresidual.hh │ │ ├── flashmodel.hh │ │ ├── flashnewtonmethod.hh │ │ ├── flashparameters.hh │ │ └── flashprimaryvariables.hh │ ├── pvs │ │ ├── pvsboundaryratevector.hh │ │ ├── pvsextensivequantities.hh │ │ ├── pvsindices.hh │ │ ├── pvsintensivequantities.hh │ │ ├── pvslocalresidual.hh │ │ ├── pvsmodel.hh │ │ ├── pvsnewtonmethod.hh │ │ ├── pvsprimaryvariables.hh │ │ ├── pvsproperties.hh │ │ └── pvsratevector.hh │ ├── richards │ │ ├── richardsboundaryratevector.hh │ │ ├── richardsextensivequantities.hh │ │ ├── richardsindices.hh │ │ ├── richardsintensivequantities.hh │ │ ├── richardslocalresidual.hh │ │ ├── richardsmodel.hh │ │ ├── richardsnewtonmethod.hh │ │ ├── richardsprimaryvariables.hh │ │ ├── richardsproperties.hh │ │ └── richardsratevector.hh │ └── utils │ │ ├── alignedallocator.hh │ │ ├── basicparameters.hh │ │ ├── basicproperties.hh │ │ ├── genericguard.hh │ │ ├── parametersystem.cpp │ │ ├── parametersystem.hpp │ │ ├── pffgridvector.hh │ │ ├── prefetch.hh │ │ ├── propertysystem.hh │ │ ├── quadraturegeometries.hh │ │ ├── signum.hh │ │ ├── simulator.hh │ │ ├── simulatorutils.cpp │ │ ├── simulatorutils.hpp │ │ ├── start.hh │ │ ├── terminal.cpp │ │ ├── terminal.hpp │ │ ├── timer.cpp │ │ ├── timer.hpp │ │ └── timerguard.hh └── simulators │ ├── aquifers │ ├── AquiferAnalytical.hpp │ ├── AquiferCarterTracy.hpp │ ├── AquiferConstantFlux.hpp │ ├── AquiferFetkovich.hpp │ ├── AquiferGridUtils.hpp │ ├── AquiferInterface.hpp │ ├── AquiferNumerical.hpp │ ├── BlackoilAquiferModel.hpp │ ├── BlackoilAquiferModel_impl.hpp │ └── SupportsFaceTag.hpp │ ├── flow │ ├── ActionHandler.cpp │ ├── ActionHandler.hpp │ ├── AluGridCartesianIndexMapper.hpp │ ├── AluGridLevelCartesianIndexMapper.hpp │ ├── AluGridVanguard.hpp │ ├── Banners.cpp │ ├── Banners.hpp │ ├── BaseAquiferModel.hpp │ ├── BlackoilModel.hpp │ ├── BlackoilModelConvergenceMonitor.cpp │ ├── BlackoilModelConvergenceMonitor.hpp │ ├── BlackoilModelNldd.hpp │ ├── BlackoilModelParameters.cpp │ ├── BlackoilModelParameters.hpp │ ├── BlackoilModelProperties.hpp │ ├── BlackoilModel_impl.hpp │ ├── CollectDataOnIORank.cpp │ ├── CollectDataOnIORank.hpp │ ├── CollectDataOnIORank_impl.hpp │ ├── CompositionalContainer.cpp │ ├── CompositionalContainer.hpp │ ├── ConvergenceOutputConfiguration.cpp │ ├── ConvergenceOutputConfiguration.hpp │ ├── CpGridVanguard.hpp │ ├── DamarisParameters.cpp │ ├── DamarisParameters.hpp │ ├── DamarisWriter.cpp │ ├── DamarisWriter.hpp │ ├── DummyGradientCalculator.hpp │ ├── EclGenericWriter.cpp │ ├── EclGenericWriter.hpp │ ├── EclGenericWriter_impl.hpp │ ├── EclWriter.hpp │ ├── EquilInitializer.hpp │ ├── ExtboContainer.cpp │ ├── ExtboContainer.hpp │ ├── ExtraConvergenceOutputThread.cpp │ ├── ExtraConvergenceOutputThread.hpp │ ├── FIBlackoilModel.hpp │ ├── FIPContainer.cpp │ ├── FIPContainer.hpp │ ├── FemCpGridCompat.hpp │ ├── FlowBaseProblemProperties.hpp │ ├── FlowBaseVanguard.hpp │ ├── FlowGenericProblem.cpp │ ├── FlowGenericProblem.hpp │ ├── FlowGenericProblem_impl.hpp │ ├── FlowGenericVanguard.cpp │ ├── FlowGenericVanguard.hpp │ ├── FlowMain.hpp │ ├── FlowProblem.hpp │ ├── FlowProblemBlackoil.hpp │ ├── FlowProblemBlackoilProperties.hpp │ ├── FlowProblemComp.hpp │ ├── FlowProblemCompProperties.hpp │ ├── FlowProblemParameters.cpp │ ├── FlowProblemParameters.hpp │ ├── FlowThresholdPressure.hpp │ ├── FlowUtils.cpp │ ├── FlowUtils.hpp │ ├── FlowsContainer.cpp │ ├── FlowsContainer.hpp │ ├── FlowsData.hpp │ ├── GenericCpGridVanguard.cpp │ ├── GenericCpGridVanguard.hpp │ ├── GenericOutputBlackoilModule.cpp │ ├── GenericOutputBlackoilModule.hpp │ ├── GenericThresholdPressure.cpp │ ├── GenericThresholdPressure.hpp │ ├── GenericThresholdPressure_impl.hpp │ ├── GenericTracerModel.cpp │ ├── GenericTracerModel.hpp │ ├── GenericTracerModel_impl.hpp │ ├── InterRegFlows.cpp │ ├── InterRegFlows.hpp │ ├── KeywordValidation.cpp │ ├── KeywordValidation.hpp │ ├── LogOutputHelper.cpp │ ├── LogOutputHelper.hpp │ ├── MICPContainer.cpp │ ├── MICPContainer.hpp │ ├── Main.cpp │ ├── Main.hpp │ ├── MainDispatchDynamic.cpp │ ├── MechContainer.cpp │ ├── MechContainer.hpp │ ├── MixingRateControls.cpp │ ├── MixingRateControls.hpp │ ├── NewTranFluxModule.hpp │ ├── NlddReporting.cpp │ ├── NlddReporting.hpp │ ├── NonlinearSolver.cpp │ ├── NonlinearSolver.hpp │ ├── OutputBlackoilModule.hpp │ ├── OutputCompositionalModule.hpp │ ├── OutputExtractor.hpp │ ├── PolyhedralGridVanguard.hpp │ ├── RFTContainer.cpp │ ├── RFTContainer.hpp │ ├── RSTConv.cpp │ ├── RSTConv.hpp │ ├── RegionPhasePVAverage.cpp │ ├── RegionPhasePVAverage.hpp │ ├── ReservoirCoupling.cpp │ ├── ReservoirCoupling.hpp │ ├── ReservoirCouplingMaster.cpp │ ├── ReservoirCouplingMaster.hpp │ ├── ReservoirCouplingSlave.cpp │ ├── ReservoirCouplingSlave.hpp │ ├── ReservoirCouplingSpawnSlaves.cpp │ ├── ReservoirCouplingSpawnSlaves.hpp │ ├── SimulatorConvergenceOutput.cpp │ ├── SimulatorConvergenceOutput.hpp │ ├── SimulatorFullyImplicitBlackoil.cpp │ ├── SimulatorFullyImplicitBlackoil.hpp │ ├── SimulatorReportBanners.cpp │ ├── SimulatorReportBanners.hpp │ ├── SimulatorSerializer.cpp │ ├── SimulatorSerializer.hpp │ ├── SolutionContainers.cpp │ ├── SolutionContainers.hpp │ ├── SubDomain.hpp │ ├── TTagFlowProblemTPFA.hpp │ ├── TracerContainer.cpp │ ├── TracerContainer.hpp │ ├── TracerModel.hpp │ ├── Transmissibility.cpp │ ├── Transmissibility.hpp │ ├── Transmissibility_impl.hpp │ ├── ValidationFunctions.cpp │ ├── ValidationFunctions.hpp │ ├── VtkTracerModule.hpp │ ├── countGlobalCells.hpp │ ├── equil │ │ ├── EquilibrationHelpers.cpp │ │ ├── EquilibrationHelpers.hpp │ │ ├── EquilibrationHelpers_impl.hpp │ │ ├── InitStateEquil.cpp │ │ ├── InitStateEquil.hpp │ │ └── InitStateEquil_impl.hpp │ ├── partitionCells.cpp │ ├── partitionCells.hpp │ ├── priVarsPacking.hpp │ └── python │ │ ├── PyBlackOilSimulator.hpp │ │ ├── PyFluidState.hpp │ │ ├── PyFluidState_impl.hpp │ │ ├── PyMaterialState.hpp │ │ ├── PyMaterialState_impl.hpp │ │ └── Pybind11Exporter.hpp │ ├── linalg │ ├── AmgxPreconditioner.hpp │ ├── DILU.hpp │ ├── ExtraSmoothers.hpp │ ├── ExtractParallelGridInformationToISTL.cpp │ ├── ExtractParallelGridInformationToISTL.hpp │ ├── FlexibleSolver.hpp │ ├── FlexibleSolver1.cpp │ ├── FlexibleSolver2.cpp │ ├── FlexibleSolver3.cpp │ ├── FlexibleSolver4.cpp │ ├── FlexibleSolver5.cpp │ ├── FlexibleSolver6.cpp │ ├── FlexibleSolver_impl.hpp │ ├── FlowLinearSolverParameters.cpp │ ├── FlowLinearSolverParameters.hpp │ ├── GraphColoring.hpp │ ├── HyprePreconditioner.hpp │ ├── ISTLSolver.cpp │ ├── ISTLSolver.hpp │ ├── ISTLSolverGpuBridge.cpp │ ├── ISTLSolverGpuBridge.hpp │ ├── MILU.cpp │ ├── MILU.hpp │ ├── MatrixMarketSpecializations.hpp │ ├── OwningBlockPreconditioner.hpp │ ├── OwningTwoLevelPreconditioner.hpp │ ├── ParallelIstlInformation.cpp │ ├── ParallelIstlInformation.hpp │ ├── ParallelOverlappingILU0.cpp │ ├── ParallelOverlappingILU0.hpp │ ├── ParallelOverlappingILU0_impl.hpp │ ├── ParallelRestrictedAdditiveSchwarz.hpp │ ├── PreconditionerFactory.hpp │ ├── PreconditionerFactory1.cpp │ ├── PreconditionerFactory2.cpp │ ├── PreconditionerFactory3.cpp │ ├── PreconditionerFactory4.cpp │ ├── PreconditionerFactory5.cpp │ ├── PreconditionerFactory6.cpp │ ├── PreconditionerFactoryGPUIncludeWrapper.hpp │ ├── PreconditionerFactory_impl.hpp │ ├── PreconditionerWithUpdate.hpp │ ├── PressureBhpTransferPolicy.hpp │ ├── PressureSolverPolicy.hpp │ ├── PressureTransferPolicy.hpp │ ├── PropertyTree.cpp │ ├── PropertyTree.hpp │ ├── SmallDenseMatrixUtils.hpp │ ├── StandardPreconditioners.hpp │ ├── StandardPreconditioners_gpu_mpi.hpp │ ├── StandardPreconditioners_gpu_serial.hpp │ ├── StandardPreconditioners_mpi.hpp │ ├── StandardPreconditioners_serial.hpp │ ├── WellOperators.hpp │ ├── WriteSystemMatrixHelper.hpp │ ├── amgcpr.hh │ ├── bicgstabsolver.hh │ ├── blacklist.hh │ ├── combinedcriterion.hh │ ├── convergencecriterion.hh │ ├── domesticoverlapfrombcrsmatrix.hh │ ├── elementborderlistfromgrid.hh │ ├── extractMatrix.hpp │ ├── findOverlapRowsAndColumns.hpp │ ├── fixpointcriterion.hh │ ├── foreignoverlapfrombcrsmatrix.hh │ ├── getQuasiImpesWeights.hpp │ ├── globalindices.hh │ ├── gpubridge │ │ ├── BlockedMatrix.cpp │ │ ├── BlockedMatrix.hpp │ │ ├── CprCreation.cpp │ │ ├── CprCreation.hpp │ │ ├── GpuBridge.cpp │ │ ├── GpuBridge.hpp │ │ ├── GpuResult.hpp │ │ ├── GpuSolver.hpp │ │ ├── Matrix.hpp │ │ ├── Misc.cpp │ │ ├── Misc.hpp │ │ ├── MultisegmentWellContribution.cpp │ │ ├── MultisegmentWellContribution.hpp │ │ ├── Preconditioner.hpp │ │ ├── Reorder.cpp │ │ ├── Reorder.hpp │ │ ├── WellContributions.cpp │ │ ├── WellContributions.hpp │ │ ├── amgclSolverBackend.cpp │ │ ├── amgclSolverBackend.hpp │ │ ├── cuda │ │ │ ├── amgclSolverBackend.cu │ │ │ ├── cuWellContributions.cu │ │ │ ├── cuWellContributions.hpp │ │ │ ├── cuda_header.hpp │ │ │ ├── cusparseSolverBackend.cu │ │ │ └── cusparseSolverBackend.hpp │ │ ├── opencl │ │ │ ├── ChowPatelIlu.cpp │ │ │ ├── ChowPatelIlu.hpp │ │ │ ├── OpenclMatrix.cpp │ │ │ ├── OpenclMatrix.hpp │ │ │ ├── kernels │ │ │ │ ├── ILU_apply1.cl │ │ │ │ ├── ILU_apply1_fm.cl │ │ │ │ ├── ILU_apply2.cl │ │ │ │ ├── ILU_apply2_fm.cl │ │ │ │ ├── ILU_decomp.cl │ │ │ │ ├── add_coarse_pressure_correction.cl │ │ │ │ ├── axpy.cl │ │ │ │ ├── custom.cl │ │ │ │ ├── dot_1.cl │ │ │ │ ├── full_to_pressure_restriction.cl │ │ │ │ ├── isaiL.cl │ │ │ │ ├── isaiU.cl │ │ │ │ ├── norm.cl │ │ │ │ ├── prolongate_vector.cl │ │ │ │ ├── residual.cl │ │ │ │ ├── residual_blocked.cl │ │ │ │ ├── scale.cl │ │ │ │ ├── spmv.cl │ │ │ │ ├── spmv_blocked.cl │ │ │ │ ├── spmv_blocked_add.cl │ │ │ │ ├── spmv_noreset.cl │ │ │ │ ├── stdwell_apply.cl │ │ │ │ └── vmul.cl │ │ │ ├── opencl.cpp │ │ │ ├── opencl.hpp │ │ │ ├── openclBILU0.cpp │ │ │ ├── openclBILU0.hpp │ │ │ ├── openclBISAI.cpp │ │ │ ├── openclBISAI.hpp │ │ │ ├── openclCPR.cpp │ │ │ ├── openclCPR.hpp │ │ │ ├── openclKernels.cpp │ │ │ ├── openclKernels.hpp │ │ │ ├── openclPreconditioner.cpp │ │ │ ├── openclPreconditioner.hpp │ │ │ ├── openclSolverBackend.cpp │ │ │ ├── openclSolverBackend.hpp │ │ │ ├── openclWellContributions.cpp │ │ │ └── openclWellContributions.hpp │ │ └── rocm │ │ │ ├── hipKernels.cpp │ │ │ ├── hipKernels.hpp │ │ │ ├── rocalutionSolverBackend.cpp │ │ │ ├── rocalutionSolverBackend.hpp │ │ │ ├── rocsparseBILU0.cpp │ │ │ ├── rocsparseBILU0.hpp │ │ │ ├── rocsparseCPR.cpp │ │ │ ├── rocsparseCPR.hpp │ │ │ ├── rocsparseMatrix.cpp │ │ │ ├── rocsparseMatrix.hpp │ │ │ ├── rocsparsePreconditioner.cpp │ │ │ ├── rocsparsePreconditioner.hpp │ │ │ ├── rocsparseSolverBackend.cpp │ │ │ ├── rocsparseSolverBackend.hpp │ │ │ ├── rocsparseWellContributions.cpp │ │ │ └── rocsparseWellContributions.hpp │ ├── gpuistl │ │ ├── GpuBlockPreconditioner.hpp │ │ ├── GpuBuffer.cpp │ │ ├── GpuBuffer.hpp │ │ ├── GpuDILU.cpp │ │ ├── GpuDILU.hpp │ │ ├── GpuJac.cpp │ │ ├── GpuJac.hpp │ │ ├── GpuOwnerOverlapCopy.hpp │ │ ├── GpuSeqILU0.cpp │ │ ├── GpuSeqILU0.hpp │ │ ├── GpuSparseMatrix.cpp │ │ ├── GpuSparseMatrix.hpp │ │ ├── GpuVector.cpp │ │ ├── GpuVector.hpp │ │ ├── GpuView.cpp │ │ ├── GpuView.hpp │ │ ├── OpmGpuILU0.cpp │ │ ├── OpmGpuILU0.hpp │ │ ├── PreconditionerAdapter.hpp │ │ ├── PreconditionerCPUMatrixToGPUMatrix.hpp │ │ ├── PreconditionerConvertFieldTypeAdapter.hpp │ │ ├── PreconditionerHolder.hpp │ │ ├── SolverAdapter.hpp │ │ ├── detail │ │ │ ├── CuBlasHandle.cpp │ │ │ ├── CuBlasHandle.hpp │ │ │ ├── CuMatrixDescription.hpp │ │ │ ├── CuSparseHandle.cpp │ │ │ ├── CuSparseHandle.hpp │ │ │ ├── CuSparseResource.hpp │ │ │ ├── CuSparseResource_impl.hpp │ │ │ ├── autotuner.hpp │ │ │ ├── coloringAndReorderingUtils.hpp │ │ │ ├── cublas_safe_call.hpp │ │ │ ├── cublas_wrapper.hpp │ │ │ ├── cuda_check_last_error.hpp │ │ │ ├── cusparse_constants.hpp │ │ │ ├── cusparse_safe_call.hpp │ │ │ ├── cusparse_wrapper.hpp │ │ │ ├── deviceBlockOperations.hpp │ │ │ ├── fix_zero_diagonal.hpp │ │ │ ├── gpuThreadUtils.hpp │ │ │ ├── gpu_safe_call.hpp │ │ │ ├── gpusparse_matrix_operations.cu │ │ │ ├── gpusparse_matrix_operations.hpp │ │ │ ├── has_function.hpp │ │ │ ├── is_gpu_pointer.hpp │ │ │ ├── kernel_enums.hpp │ │ │ ├── preconditionerKernels │ │ │ │ ├── DILUKernels.cu │ │ │ │ ├── DILUKernels.hpp │ │ │ │ ├── ILU0Kernels.cu │ │ │ │ ├── ILU0Kernels.hpp │ │ │ │ ├── JacKernels.cu │ │ │ │ └── JacKernels.hpp │ │ │ ├── preconditioner_should_call_post_pre.hpp │ │ │ ├── safe_conversion.hpp │ │ │ ├── vector_operations.cu │ │ │ └── vector_operations.hpp │ │ ├── device_management.cpp │ │ ├── device_management.hpp │ │ ├── gpu_resources.hpp │ │ ├── gpu_smart_pointer.hpp │ │ ├── set_device.cpp │ │ └── set_device.hpp │ ├── ilufirstelement.hh │ ├── is_gpu_operator.hpp │ ├── istlpreconditionerwrappers.hh │ ├── istlsolverwrappers.hh │ ├── istlsparsematrixadapter.hh │ ├── linalgparameters.hh │ ├── linalgproperties.hh │ ├── linearsolverreport.hh │ ├── matrixblock.hh │ ├── nullborderlistmanager.hh │ ├── overlappingbcrsmatrix.hh │ ├── overlappingblockvector.hh │ ├── overlappingoperator.hh │ ├── overlappingpreconditioner.hh │ ├── overlappingscalarproduct.hh │ ├── overlaptypes.hh │ ├── parallelamgbackend.hh │ ├── parallelbasebackend.hh │ ├── parallelbicgstabbackend.hh │ ├── parallelistlbackend.hh │ ├── residreductioncriterion.hh │ ├── setupPropertyTree.cpp │ ├── setupPropertyTree.hpp │ ├── superlubackend.hh │ ├── twolevelmethodcpr.hh │ ├── vertexborderlistfromgrid.hh │ └── weightedresidreductioncriterion.hh │ ├── opm-simulators_doxygen_main.hpp │ ├── timestepping │ ├── AdaptiveSimulatorTimer.cpp │ ├── AdaptiveSimulatorTimer.hpp │ ├── AdaptiveTimeStepping.cpp │ ├── AdaptiveTimeStepping.hpp │ ├── AdaptiveTimeStepping_impl.hpp │ ├── ConvergenceReport.cpp │ ├── ConvergenceReport.hpp │ ├── EclTimeSteppingParams.cpp │ ├── EclTimeSteppingParams.hpp │ ├── SimulatorReport.cpp │ ├── SimulatorReport.hpp │ ├── SimulatorTimer.cpp │ ├── SimulatorTimer.hpp │ ├── SimulatorTimerInterface.cpp │ ├── SimulatorTimerInterface.hpp │ ├── TimeStepControl.cpp │ ├── TimeStepControl.hpp │ ├── TimeStepControlInterface.hpp │ ├── gatherConvergenceReport.cpp │ └── gatherConvergenceReport.hpp │ ├── utils │ ├── BlackoilPhases.cpp │ ├── BlackoilPhases.hpp │ ├── ComponentName.cpp │ ├── ComponentName.hpp │ ├── DamarisKeywords.cpp │ ├── DamarisKeywords.hpp │ ├── DamarisOutputModule.cpp │ ├── DamarisOutputModule.hpp │ ├── DamarisVar.cpp │ ├── DamarisVar.hpp │ ├── DeferredLogger.cpp │ ├── DeferredLogger.hpp │ ├── DeferredLoggingErrorHelpers.hpp │ ├── FullySupportedFlowKeywords.cpp │ ├── FullySupportedFlowKeywords.hpp │ ├── GridDataOutput.cpp │ ├── GridDataOutput.hpp │ ├── GridDataOutput_impl.hpp │ ├── HDF5File.cpp │ ├── HDF5File.hpp │ ├── HDF5Serializer.cpp │ ├── HDF5Serializer.hpp │ ├── InstantiationIndicesMacros.hpp │ ├── MPIPacker.cpp │ ├── MPIPacker.hpp │ ├── MPISerializer.hpp │ ├── ParallelCommunication.hpp │ ├── ParallelEclipseState.cpp │ ├── ParallelEclipseState.hpp │ ├── ParallelFileMerger.cpp │ ├── ParallelFileMerger.hpp │ ├── ParallelNLDDPartitioningZoltan.cpp │ ├── ParallelNLDDPartitioningZoltan.hpp │ ├── ParallelRestart.cpp │ ├── ParallelRestart.hpp │ ├── ParallelSerialization.cpp │ ├── ParallelSerialization.hpp │ ├── PartiallySupportedFlowKeywords.cpp │ ├── PartiallySupportedFlowKeywords.hpp │ ├── PressureAverage.cpp │ ├── PressureAverage.hpp │ ├── PropsDataHandle.hpp │ ├── SerializationPackers.cpp │ ├── SerializationPackers.hpp │ ├── SetupPartitioningParams.cpp │ ├── SetupPartitioningParams.hpp │ ├── SymmTensor.cpp │ ├── SymmTensor.hpp │ ├── UnsupportedFlowKeywords.cpp │ ├── UnsupportedFlowKeywords.hpp │ ├── VectorVectorDataHandle.hpp │ ├── VoigtArray.cpp │ ├── VoigtArray.hpp │ ├── compressPartition.cpp │ ├── compressPartition.hpp │ ├── gatherDeferredLogger.cpp │ ├── gatherDeferredLogger.hpp │ ├── initDamarisXmlFile.cpp │ ├── moduleVersion.cpp │ ├── moduleVersion.hpp │ ├── phaseUsageFromDeck.cpp │ ├── phaseUsageFromDeck.hpp │ ├── readDeck.cpp │ ├── readDeck.hpp │ └── satfunc │ │ ├── GasPhaseConsistencyChecks.cpp │ │ ├── GasPhaseConsistencyChecks.hpp │ │ ├── OilPhaseConsistencyChecks.cpp │ │ ├── OilPhaseConsistencyChecks.hpp │ │ ├── PhaseCheckBase.cpp │ │ ├── PhaseCheckBase.hpp │ │ ├── RelpermDiagnostics.cpp │ │ ├── RelpermDiagnostics.hpp │ │ ├── SatfuncCheckPointInterface.hpp │ │ ├── SatfuncConsistencyCheckManager.cpp │ │ ├── SatfuncConsistencyCheckManager.hpp │ │ ├── SatfuncConsistencyChecks.cpp │ │ ├── SatfuncConsistencyChecks.hpp │ │ ├── ScaledSatfuncCheckPoint.cpp │ │ ├── ScaledSatfuncCheckPoint.hpp │ │ ├── ThreePointHorizontalConsistencyChecks.cpp │ │ ├── ThreePointHorizontalConsistencyChecks.hpp │ │ ├── UnscaledSatfuncCheckPoint.cpp │ │ ├── UnscaledSatfuncCheckPoint.hpp │ │ ├── WaterPhaseConsistencyChecks.cpp │ │ └── WaterPhaseConsistencyChecks.hpp │ └── wells │ ├── ALQState.cpp │ ├── ALQState.hpp │ ├── BlackoilWellModel.hpp │ ├── BlackoilWellModelConstraints.cpp │ ├── BlackoilWellModelConstraints.hpp │ ├── BlackoilWellModelGasLift.cpp │ ├── BlackoilWellModelGasLift.hpp │ ├── BlackoilWellModelGasLift_impl.hpp │ ├── BlackoilWellModelGeneric.cpp │ ├── BlackoilWellModelGeneric.hpp │ ├── BlackoilWellModelGuideRates.cpp │ ├── BlackoilWellModelGuideRates.hpp │ ├── BlackoilWellModelNldd.cpp │ ├── BlackoilWellModelNldd.hpp │ ├── BlackoilWellModelNldd_impl.hpp │ ├── BlackoilWellModelRestart.cpp │ ├── BlackoilWellModelRestart.hpp │ ├── BlackoilWellModelWBP.cpp │ ├── BlackoilWellModelWBP.hpp │ ├── BlackoilWellModel_impl.hpp │ ├── ConnFiltrateData.cpp │ ├── ConnFiltrateData.hpp │ ├── ConnFracStatistics.hpp │ ├── ConnectionIndexMap.hpp │ ├── FractionCalculator.cpp │ ├── FractionCalculator.hpp │ ├── GasLiftCommon.cpp │ ├── GasLiftCommon.hpp │ ├── GasLiftGroupInfo.cpp │ ├── GasLiftGroupInfo.hpp │ ├── GasLiftSingleWell.hpp │ ├── GasLiftSingleWellGeneric.cpp │ ├── GasLiftSingleWellGeneric.hpp │ ├── GasLiftSingleWell_impl.hpp │ ├── GasLiftStage2.cpp │ ├── GasLiftStage2.hpp │ ├── GasLiftWellState.hpp │ ├── GlobalWellInfo.cpp │ ├── GlobalWellInfo.hpp │ ├── GroupEconomicLimitsChecker.cpp │ ├── GroupEconomicLimitsChecker.hpp │ ├── GroupState.cpp │ ├── GroupState.hpp │ ├── MSWellHelpers.cpp │ ├── MSWellHelpers.hpp │ ├── MultisegmentWell.hpp │ ├── MultisegmentWellAssemble.cpp │ ├── MultisegmentWellAssemble.hpp │ ├── MultisegmentWellEquations.cpp │ ├── MultisegmentWellEquations.hpp │ ├── MultisegmentWellEval.cpp │ ├── MultisegmentWellEval.hpp │ ├── MultisegmentWellGeneric.cpp │ ├── MultisegmentWellGeneric.hpp │ ├── MultisegmentWellPrimaryVariables.cpp │ ├── MultisegmentWellPrimaryVariables.hpp │ ├── MultisegmentWellSegments.cpp │ ├── MultisegmentWellSegments.hpp │ ├── MultisegmentWell_impl.hpp │ ├── ParallelPAvgCalculator.cpp │ ├── ParallelPAvgCalculator.hpp │ ├── ParallelPAvgDynamicSourceData.cpp │ ├── ParallelPAvgDynamicSourceData.hpp │ ├── ParallelWBPCalculation.cpp │ ├── ParallelWBPCalculation.hpp │ ├── ParallelWellInfo.cpp │ ├── ParallelWellInfo.hpp │ ├── PerfData.cpp │ ├── PerfData.hpp │ ├── PerforationData.hpp │ ├── RateConverter.cpp │ ├── RateConverter.hpp │ ├── RatioCalculator.cpp │ ├── RatioCalculator.hpp │ ├── RegionAttributeHelpers.hpp │ ├── RegionAverageCalculator.hpp │ ├── RunningStatistics.hpp │ ├── RuntimePerforation.hpp │ ├── SegmentState.cpp │ ├── SegmentState.hpp │ ├── SingleWellState.cpp │ ├── SingleWellState.hpp │ ├── StandardWell.hpp │ ├── StandardWellAssemble.cpp │ ├── StandardWellAssemble.hpp │ ├── StandardWellConnections.cpp │ ├── StandardWellConnections.hpp │ ├── StandardWellEquations.cpp │ ├── StandardWellEquations.hpp │ ├── StandardWellEval.cpp │ ├── StandardWellEval.hpp │ ├── StandardWellPrimaryVariables.cpp │ ├── StandardWellPrimaryVariables.hpp │ ├── StandardWell_impl.hpp │ ├── TargetCalculator.cpp │ ├── TargetCalculator.hpp │ ├── VFPHelpers.cpp │ ├── VFPHelpers.hpp │ ├── VFPInjProperties.cpp │ ├── VFPInjProperties.hpp │ ├── VFPProdProperties.cpp │ ├── VFPProdProperties.hpp │ ├── VFPProperties.hpp │ ├── WGState.cpp │ ├── WGState.hpp │ ├── WellAssemble.cpp │ ├── WellAssemble.hpp │ ├── WellBhpThpCalculator.cpp │ ├── WellBhpThpCalculator.hpp │ ├── WellConnectionAuxiliaryModule.hpp │ ├── WellConstraints.cpp │ ├── WellConstraints.hpp │ ├── WellContainer.hpp │ ├── WellConvergence.cpp │ ├── WellConvergence.hpp │ ├── WellFilterCake.cpp │ ├── WellFilterCake.hpp │ ├── WellGroupConstraints.cpp │ ├── WellGroupConstraints.hpp │ ├── WellGroupControls.cpp │ ├── WellGroupControls.hpp │ ├── WellGroupHelpers.cpp │ ├── WellGroupHelpers.hpp │ ├── WellHelpers.cpp │ ├── WellHelpers.hpp │ ├── WellInterface.hpp │ ├── WellInterfaceFluidSystem.cpp │ ├── WellInterfaceFluidSystem.hpp │ ├── WellInterfaceGeneric.cpp │ ├── WellInterfaceGeneric.hpp │ ├── WellInterfaceIndices.cpp │ ├── WellInterfaceIndices.hpp │ ├── WellInterface_impl.hpp │ ├── WellProdIndexCalculator.cpp │ ├── WellProdIndexCalculator.hpp │ ├── WellState.cpp │ ├── WellState.hpp │ ├── WellTest.cpp │ ├── WellTest.hpp │ └── WellTracerRate.hpp ├── parallelRestartTests.cmake ├── parallelTests.cmake ├── parallelUnitTests.cmake ├── pyactionActionXComparisons.cmake ├── python ├── CMakeLists.txt ├── Dockerfile ├── MANIFEST.in ├── README.md ├── build-deps.sh ├── docstrings_simulators.json ├── generate-pypi-package.sh ├── opm │ ├── CMakeLists.txt │ └── simulators │ │ └── __init__.py ├── pyproject.toml ├── requirements.txt ├── setup-docker-image.sh ├── setup.py.in ├── simulators │ ├── CMakeLists.txt │ ├── PyBlackOilSimulator.cpp │ ├── PyMain.hpp │ └── Pybind11Exporter.cpp ├── test │ ├── __init__.py │ ├── pytest_common.py │ ├── test_basic.py │ ├── test_fluidstate_variables.py │ ├── test_mpi.py │ ├── test_primary_variables.py │ ├── test_schedule.py │ └── test_throw.py └── test_data │ ├── SPE1CASE1a │ └── SPE1CASE1.DATA │ └── SPE1CASE1b │ └── SPE1CASE1.DATA ├── regressionTests.cmake ├── restartTests.cmake └── tests ├── AmgxPreconditionerTestHelper.hpp ├── DuneIstlTestHelpers.hpp ├── GLIFT1.DATA ├── HyprePreconditionerTestHelper.hpp ├── MpiFixture.hpp ├── RC-01_MAST_PRED.DATA ├── TESTTIMER.DATA ├── TESTWELLMODEL.DATA ├── TestTypeTag.hpp ├── VFPPROD1 ├── VFPPROD2 ├── build-simulators.sh ├── capillary.DATA ├── capillarySwatinit.DATA ├── capillary_overlap.DATA ├── data ├── co2injection.dgf ├── cuvette_11x4.dgf ├── cuvette_44x24.dgf ├── fracture-raw.art ├── fracture.art.dgf ├── groundwater_1d.dgf ├── groundwater_2d.dgf ├── groundwater_3d.dgf ├── infiltration_250x20.dgf ├── infiltration_50x3.dgf ├── obstacle_24x16.dgf ├── obstacle_48x32.dgf ├── outflow.dgf ├── reservoir.dgf ├── richardslens_24x16.dgf ├── richardslens_48x32.dgf ├── richardslens_96x64.dgf ├── test_stokes.dgf ├── test_stokes2c.dgf ├── test_stokes2cni.dgf └── waterair.dgf ├── deadfluids.DATA ├── equil_base.DATA ├── equil_capillary.DATA ├── equil_capillary_overlap.DATA ├── equil_capillary_swatinit.DATA ├── equil_co2store_go.DATA ├── equil_co2store_gw.DATA ├── equil_deadfluids.DATA ├── equil_humidwetgas.DATA ├── equil_liveoil.DATA ├── equil_liveoil_grid.DATA ├── equil_pbvd_and_pdvd.DATA ├── equil_rsvd_and_rvvd.DATA ├── equil_rsvd_and_rvvd_and_rvwvd.DATA ├── equil_wetgas.DATA ├── getprop.awk ├── gpuistl ├── test_GpuBuffer.cu ├── test_GpuDILU.cpp ├── test_GpuJac.cpp ├── test_GpuOwnerOverlapCopy.cpp ├── test_GpuSeqILU0.cpp ├── test_GpuSparseMatrix.cpp ├── test_GpuVector.cpp ├── test_GpuView.cu ├── test_converttofloatadapter.cpp ├── test_cuSparse_matrix_operations.cpp ├── test_cuVector_operations.cpp ├── test_cublas_handle.cpp ├── test_cublas_safe_call.cpp ├── test_cuda_check_last_error.cpp ├── test_cusparse_handle.cpp ├── test_cusparse_safe_call.cpp ├── test_gpuPvt.cu ├── test_gpu_ad.cu ├── test_gpu_linear_two_phase_material.cu ├── test_gpu_resources.cu ├── test_gpu_safe_call.cpp ├── test_gpu_smart_pointers.cu ├── test_is_gpu_pointer.cpp ├── test_preconditioner_factory_gpu.cpp ├── test_safe_conversion.cpp ├── test_solver_adapter.cpp └── test_throw_macros_on_gpu.cu ├── include ├── PVT-WET-GAS.INC ├── b1_vfp_flowline.inc ├── d1_vfp_flowline.inc ├── edit_nnc.inc ├── flowl_b_vfp.ecl ├── flowl_c_vfp.ecl ├── flowline_e1_vfp.inc ├── permx_model5.grdecl ├── pvt_live_oil_dgas.ecl ├── relperm.inc ├── rock.inc ├── scal_mod2.inc ├── summary.inc ├── summary_rc.inc ├── test1_20x30x10.grdecl └── well_vfp.ecl ├── liveoil.DATA ├── make_failure_report.sh ├── matr33.txt ├── matr33rep.txt ├── models ├── test_propertysystem.cpp ├── test_quadrature.cpp ├── test_tasklets.cpp └── test_tasklets_failure.cpp ├── msw.data ├── norne_pvt.data ├── not-unit └── test_ad.cpp ├── offset_map_matrix.txt ├── offset_map_matrix_transposed.txt ├── options_flexiblesolver.json ├── options_flexiblesolver_simple.json ├── parametersystem.ini ├── plot_well_comparison.py ├── relpermDiagnostics.DATA ├── rescoup └── test_chopstep.cpp ├── rhs3.txt ├── rhs3rep.txt ├── run-comparison.sh ├── run-damaris-regressionTest.sh ├── run-init-regressionTest.sh ├── run-parallel-regressionTest.sh ├── run-parallel-restart-regressionTest.sh ├── run-parallel-unitTest.sh ├── run-porv-acceptanceTest.sh ├── run-regressionTest.sh ├── run-restart-regressionTest.sh ├── run-serialization-regressionTest.sh ├── run-split-comm-test.sh ├── run-summary-restart-regressionTest.sh ├── run-test.sh ├── run-vtu-test.sh ├── satfuncEPS_B.DATA ├── test10.partition ├── testBlackoilState3.DATA ├── testFluid.DATA ├── test_ALQState.cpp ├── test_AmgxPreconditioner.cpp ├── test_GasSatfuncConsistencyChecks.cpp ├── test_GroupState.cpp ├── test_HDF5File.cpp ├── test_HDF5File_Parallel.cpp ├── test_HDF5Serializer.cpp ├── test_HDF5Serializer_Parallel.cpp ├── test_HyprePreconditionerCPU.cpp ├── test_HyprePreconditionerGPU.cpp ├── test_LogOutputHelper.cpp ├── test_OilSatfuncConsistencyChecks.cpp ├── test_ParallelSerialization.cpp ├── test_RestartSerialization.cpp ├── test_RunningStatistics.cpp ├── test_SatfuncCheckPoint.cpp ├── test_SatfuncConsistencyCheckManager.cpp ├── test_SatfuncConsistencyChecks.cpp ├── test_SatfuncConsistencyChecks_parallel.cpp ├── test_SymmTensor.cpp ├── test_ThreePointHorizontalSatfuncConsistencyChecks.cpp ├── test_VoigtArray.cpp ├── test_WaterSatfuncConsistencyChecks.cpp ├── test_aquifergridutils.cpp ├── test_blackoil_amg.cpp ├── test_broadcast.cpp ├── test_convergenceoutputconfiguration.cpp ├── test_convergencereport.cpp ├── test_csrToCscOffsetMap.cpp ├── test_cusparseSolver.cpp ├── test_deferredlogger.cpp ├── test_dilu.cpp ├── test_equil.cpp ├── test_extractMatrix.cpp ├── test_flexiblesolver.cpp ├── test_gatherconvergencereport.cpp ├── test_gatherdeferredlogger.cpp ├── test_ghostlastmatrixadapter.cpp ├── test_glift1.cpp ├── test_graphcoloring.cpp ├── test_interregflows.cpp ├── test_invert.cpp ├── test_keyword_validator.cpp ├── test_milu.cpp ├── test_multmatrixtransposed.cpp ├── test_nonnc.cpp ├── test_norne_pvt.cpp ├── test_openclSolver.cpp ├── test_outputdir.cpp ├── test_parallel_wbp_calculation.cpp ├── test_parallel_wbp_sourcevalues.cpp ├── test_parallelistlinformation.cpp ├── test_parallelwellinfo.cpp ├── test_parametersystem.cpp ├── test_partitionCells.cpp ├── test_preconditionerfactory.cpp ├── test_privarspacking.cpp ├── test_propertytree.cpp ├── test_region_phase_pvaverage.cpp ├── test_relpermdiagnostics.cpp ├── test_rocalutionSolver.cpp ├── test_rocsparseSolver.cpp ├── test_rstconv.cpp ├── test_solvetransposed3x3.cpp ├── test_stoppedwells.cpp ├── test_thresholdpressure.cpp ├── test_timer.cpp ├── test_tuning_TSINIT_NEXTSTEP.cpp ├── test_tuning_XXXMBE.cpp ├── test_vfpproperties.cpp ├── test_wellmodel.cpp ├── test_wellprodindexcalculator.cpp ├── test_wellstate.cpp ├── update_reference_data.sh ├── wells_group.data ├── wells_manager_data.data ├── wells_manager_data_expanded.data ├── wells_manager_data_wellSTOP.data ├── wells_no_perforation.data ├── wells_stopped.data └── wetgas.DATA /.clang-format: -------------------------------------------------------------------------------- 1 | { 2 | BasedOnStyle: WebKit, 3 | AlignConsecutiveAssignments: false, 4 | AlignConsecutiveDeclarations: false, 5 | AlignAfterOpenBracket: Align, 6 | AllowShortBlocksOnASingleLine: false, 7 | AllowShortFunctionsOnASingleLine: None, 8 | AlwaysBreakAfterReturnType: TopLevelDefinitions, 9 | AlwaysBreakTemplateDeclarations: Yes, 10 | BinPackArguments: false, 11 | BinPackParameters: false, 12 | BreakBeforeBraces: Linux, 13 | BreakConstructorInitializers: BeforeComma, 14 | ColumnLimit: 120, 15 | Cpp11BracedListStyle: true, 16 | FixNamespaceComments: true, 17 | InsertNewlineAtEOF: true, 18 | MaxEmptyLinesToKeep: 5, 19 | NamespaceIndentation: Inner, 20 | } 21 | -------------------------------------------------------------------------------- /.github/workflows/dispatch_opm_simulators.yml: -------------------------------------------------------------------------------- 1 | name: Dispatch to opm-python-documentation 2 | 3 | on: 4 | push: 5 | branches: master 6 | paths: 7 | - 'python/docstrings_simulators.json' 8 | 9 | jobs: 10 | dispatch: 11 | runs-on: ubuntu-latest 12 | 13 | steps: 14 | - name: Send dispatch to opm-simulators 15 | env: 16 | PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }} 17 | run: | 18 | curl -X POST \ 19 | -H "Accept: application/vnd.github+json" \ 20 | -H "Authorization: token ${{ secrets.PERSONAL_ACCESS_TOKEN }}" \ 21 | https://api.github.com/repos/${{ github.repository_owner }}/opm-python-documentation/dispatches \ 22 | -d '{"event_type":"docstrings_simulators_updated"}' 23 | -------------------------------------------------------------------------------- /.github/workflows/manual_label_checker.yml: -------------------------------------------------------------------------------- 1 | name: Verify manual labels 2 | 3 | on: 4 | pull_request_target: 5 | types: [opened, labeled, unlabeled, synchronize] 6 | 7 | jobs: 8 | dispatch: 9 | runs-on: ubuntu-latest 10 | steps: 11 | - name: Verify labels 12 | uses: jesusvasquez333/verify-pr-label-action@v1.4.0 13 | with: 14 | github-token: '${{ secrets.GITHUB_TOKEN }}' 15 | valid-labels: 'manual:bugfix, manual:enhancement, manual:new-feature, manual:irrelevant' 16 | disable-reviews: 'true' 17 | pull-request-number: '${{ github.event.pull_request.number }}' 18 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Editor autosave files 2 | *~ 3 | *.swp 4 | 5 | # Compiled Object files 6 | *.slo 7 | *.lo 8 | *.o 9 | 10 | # Compiled Dynamic libraries 11 | *.so 12 | *.dylib 13 | 14 | # Compiled Static libraries 15 | *.lai 16 | *.la 17 | *.a 18 | 19 | # Compiled executables 20 | a.out 21 | find_zero 22 | sim_2p_incomp_adfi 23 | sim_simple 24 | test_ad 25 | test_block 26 | test_impestpfa_ad 27 | test_syntax 28 | test_vec 29 | 30 | # Build directory in source 31 | build/ 32 | 33 | # Mac OS X debug info 34 | *.dSYM 35 | 36 | # emacs directory setting: 37 | .dir-locals.el 38 | 39 | # Python sphinx build 40 | python/sphinx_docs/docs/_build/ 41 | 42 | # Python cache directories 43 | **/__pycache__/ 44 | 45 | -------------------------------------------------------------------------------- /CTestConfig.cmake: -------------------------------------------------------------------------------- 1 | # this is included after opm-core_NAME is set 2 | set(CTEST_PROJECT_NAME "${${project}_NAME}") 3 | set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC") 4 | set(CTEST_DROP_METHOD "http") 5 | set(CTEST_DROP_SITE "cdash.opm-project.org") 6 | set(CTEST_DROP_LOCATION "/submit.php?project=${${project}_NAME}") 7 | set(CTEST_DROP_SITE_CDASH TRUE) 8 | -------------------------------------------------------------------------------- /bin/hipify_file.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e # Make sure the script fails if a command fails 3 | 4 | # the script is intended to be run like this: bash hipify_file.sh ${PROJECT_BUILD_DIR} ${PROJECT_BINARY_DIR} 5 | # it should be run automatically on the correct files through cmake 6 | input_file=$1 7 | output_file=$2 8 | 9 | # make sure the output folder exists 10 | mkdir -p $(dirname $output_file) 11 | 12 | # hipify out-of-place 13 | hipify-perl $input_file > $output_file 14 | 15 | # expand includes so we only need include_directories (path to hip) 16 | sed -i 's/^#include /#include /g' $output_file 17 | sed -i 's/^#include /#include /g' $output_file 18 | # make sure includes refer to hipistl/ files (the ones that are also hipified) 19 | sed -i 's/gpuistl\//gpuistl_hip\//g' $output_file 20 | 21 | echo "$output_file hipified" 22 | -------------------------------------------------------------------------------- /cmake/test/testFloatFromChars.cpp: -------------------------------------------------------------------------------- 1 | // CMake feature test for floating-point std::from_chars() support 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | const auto s = std::string_view { "2.71828" }; 9 | auto e = 0.0; 10 | std::from_chars(s.data(), s.data() + s.size(), e); 11 | } 12 | -------------------------------------------------------------------------------- /doc/doxygen/Doxylocal: -------------------------------------------------------------------------------- 1 | # This file contains local changes to the doxygen configuration 2 | # please us '+=' to add file/directories to the lists 3 | 4 | # The INPUT tag can be used to specify the files and/or directories that contain 5 | # documented source files. You may enter file names like "myfile.cpp" or 6 | # directories like "/usr/src/myproject". Separate the files or directories 7 | # with spaces. 8 | 9 | INPUT += @abs_top_srcdir@/opm/ 10 | 11 | # see e.g. dune-grid for the examples of mainpage and modules 12 | # INPUT += @abs_top_srcdir@/doc/doxygen/mainpage 13 | # @srcdir@/modules 14 | 15 | # The EXCLUDE tag can be used to specify files and/or directories that should 16 | # excluded from the INPUT source files. This way you can easily exclude a 17 | # subdirectory from a directory tree whose root is specified with the INPUT tag. 18 | 19 | # EXCLUDE += @abs_top_srcdir@/tests/ 20 | 21 | # The EXAMPLE_PATH tag can be used to specify one or more files or 22 | # directories that contain example code fragments that are included (see 23 | # the \include command). 24 | 25 | # EXAMPLE_PATH += @abs_top_srcdir@/examples/ 26 | 27 | -------------------------------------------------------------------------------- /doc/handbook/EPS/masstransfer.eps: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/OPM/opm-simulators/ee7b9ed80c61800889c01a054cb56d291dfdd763/doc/handbook/EPS/masstransfer.eps -------------------------------------------------------------------------------- /doc/handbook/XFIG/Ex2_Boundary.fig: -------------------------------------------------------------------------------- 1 | #FIG 3.2 Produced by xfig version 3.2.5 2 | Landscape 3 | Center 4 | Metric 5 | A4 6 | 100.00 7 | Single 8 | -2 9 | 1200 2 10 | 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 11 | 3015 3870 8775 3870 8775 6615 3015 6615 3015 3870 12 | 2 2 0 1 0 31 50 -1 20 0.000 0 0 -1 0 0 5 13 | 4095 4770 7650 4770 7650 5760 4095 5760 4095 4770 14 | 2 2 2 1 0 7 50 -1 41 3.000 0 0 -1 0 0 5 15 | 3015 6615 8775 6615 8775 6795 3015 6795 3015 6615 16 | 2 2 2 1 0 7 50 -1 41 3.000 0 0 -1 0 0 5 17 | 3015 3690 8775 3690 8775 3870 3015 3870 3015 3690 18 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 19 | 0 0 1.00 105.00 120.00 20 | 9000 4410 9450 4410 21 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 22 | 0 0 1.00 105.00 120.00 23 | 9000 4815 9450 4815 24 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 25 | 0 0 1.00 105.00 120.00 26 | 9000 5220 9450 5220 27 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 28 | 0 0 1.00 105.00 120.00 29 | 9045 5670 9450 5670 30 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 31 | 0 0 1.00 105.00 120.00 32 | 9045 6075 9450 6075 33 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 34 | 0 0 1.00 105.00 120.00 35 | 9045 6480 9450 6480 36 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 37 | 0 0 1.00 105.00 120.00 38 | 9000 4005 9450 4005 39 | 4 0 0 50 -1 0 12 0.0000 4 135 615 5535 7245 no flow\001 40 | 4 0 0 50 -1 0 12 0.0000 4 135 615 5535 3420 no flow\001 41 | 4 0 0 50 -1 0 12 0.0000 4 135 240 9720 4995 qw\001 42 | 4 0 0 50 -1 0 12 0.0000 4 135 210 9765 5490 qo\001 43 | 4 0 0 50 -1 0 12 0.0000 4 135 240 1170 4815 pw\001 44 | 4 0 0 50 -1 0 12 0.0000 4 135 105 1170 5310 S\001 45 | -------------------------------------------------------------------------------- /doc/handbook/XFIG/exercise1_c.fig: -------------------------------------------------------------------------------- 1 | #FIG 3.2 Produced by xfig version 3.2.5 2 | Landscape 3 | Center 4 | Metric 5 | A4 6 | 100.00 7 | Single 8 | -2 9 | 1200 2 10 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 11 | 3285 5310 3285 5535 12 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 13 | 3285 5445 4905 5445 14 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 15 | 5715 5445 7155 5445 16 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 17 | 7155 5310 7155 5535 18 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 19 | 3060 4725 3060 5040 20 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 21 | 2970 5130 3150 5130 22 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 23 | 3060 4680 3060 5130 24 | 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 25 | 3240 3870 7155 3870 7155 5130 3240 5130 3240 3870 26 | 2 2 0 1 0 15 50 -1 20 0.000 0 0 -1 0 0 5 27 | 5265 3870 7155 3870 7155 5130 5265 5130 5265 3870 28 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 29 | 3060 3870 3060 4320 30 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 31 | 2970 3870 3150 3870 32 | 4 0 0 50 -1 0 12 0.0000 4 135 390 3870 4365 K1 =\001 33 | 4 0 0 50 -1 0 12 0.0000 4 180 525 3870 4590 phi1 =\001 34 | 4 0 7 50 -1 0 12 0.0000 4 135 390 5760 4365 K2 =\001 35 | 4 0 7 50 -1 0 12 0.0000 4 180 525 5760 4545 phi2 =\001 36 | 4 0 0 50 -1 0 12 0.0000 4 135 510 2700 4590 300 m\001 37 | 4 0 0 50 -1 0 12 0.0000 4 135 510 5085 5490 600 m\001 38 | -------------------------------------------------------------------------------- /doc/handbook/XFIG/exercise_1a.fig: -------------------------------------------------------------------------------- 1 | #FIG 3.2 Produced by xfig version 3.2.5 2 | Landscape 3 | Center 4 | Metric 5 | A4 6 | 100.00 7 | Single 8 | -2 9 | 1200 2 10 | 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 11 | 1980 2205 3780 2205 3780 3915 1980 3915 1980 2205 12 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 13 | 1890 3915 1755 3915 14 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 15 | 1800 3915 1800 3240 16 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 17 | 1800 2880 1800 2205 18 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 19 | 1845 2205 1710 2205 20 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 21 | 1845 3915 1710 3915 22 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 23 | 3195 4095 3780 4095 24 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 25 | 3780 4005 3780 4140 26 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 27 | 1980 4005 1980 4140 28 | 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 29 | 1980 4095 2565 4095 30 | 4 0 0 50 -1 0 12 0.0000 4 135 105 1575 3105 y\001 31 | 4 0 0 50 -1 0 12 0.0000 4 90 105 2655 4140 x\001 32 | -------------------------------------------------------------------------------- /doc/handbook/build-handbook.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | # this script builds the eWoms handbook from its LaTeX sources. The 4 | # result file is called "ewoms-handbook.pdf" 5 | 6 | latex ewoms-handbook || exit $? 7 | bibtex ewoms-handbook || exit $? 8 | latex ewoms-handbook || exit $? 9 | latex ewoms-handbook || exit $? 10 | dvipdf ewoms-handbook || exit $? 11 | rm ewoms-handbook.dvi 12 | -------------------------------------------------------------------------------- /doc/handbook/getting-started.tex: -------------------------------------------------------------------------------- 1 | \chapter{Set-up and basic workflows} 2 | 3 | This chapter is aimed at setting up a development environment for 4 | \eWoms and to equip you with a rough understanding of the basic 5 | workflows used for developing the software. We will first have a 6 | brief look at the installation procedure; After that, we will run a 7 | sample simulation and briefly discuss how to visualize its results. 8 | 9 | Be aware, that this is only a very streamlined version of the \eWoms 10 | development workflow, so make yourself confident with the tools 11 | introduced in this section before you delve into the \Cplusplus code 12 | in the next chapter. 13 | 14 | \input{quick-install} 15 | \input{quickstart-guide} 16 | \input{parameters} 17 | 18 | %%% Local Variables: 19 | %%% mode: latex 20 | %%% TeX-master: "ewoms-handbook" 21 | %%% End: 22 | -------------------------------------------------------------------------------- /doc/handbook/parameters.tex: -------------------------------------------------------------------------------- 1 | \section{Specifying Parameters} 2 | \label{sec:inputFiles} 3 | 4 | As already mentioned in the previous section, \eWoms allows to specify 5 | a number of parameters at run time. A description of these parameters 6 | can usually be obtained by passing the \texttt{--help} parameter to the 7 | executable. The values used for these parameters are printed to the 8 | terminal during the start-up of the simulation, e.g. the if the \texttt{lens\_immiscible} 9 | simulation is run with the parameters \texttt{--end-time=30e3 --foo-param=123}, it will print an output similar to 10 | \begin{lstlisting}[style=Bash] 11 | ########### 12 | # Parameters specified at run-time 13 | ########### 14 | EndTime="30e3" 15 | ########### 16 | # Parameters with use compile-time fallback values 17 | ########### 18 | AmgCoarsenTarget="5000" 19 | ... 20 | VtkWriteSaturations="1" 21 | VtkWriteTemperature="1" 22 | VtkWriteViscosities="0" 23 | ########### 24 | # Parameters unknown to the simulation 25 | ########### 26 | FooParam="123" 27 | \end{lstlisting} 28 | 29 | This can be directly copy-and-pasted into a file 30 | (e.g. \texttt{myparams.ini}). The simulation can be instructed to use 31 | these parameters by passing the \texttt{--parameter-file=myparams.ini} 32 | parameter the next time it is run. Of course, this file can also be 33 | adapted. 34 | 35 | An additional hint: Always watch out for parameters which are unknown 36 | to the simulation, as this is \emph{very} useful for spotting typos. 37 | 38 | %%% Local Variables: 39 | %%% mode: latex 40 | %%% TeX-master: "ewoms-handbook" 41 | %%% End: 42 | -------------------------------------------------------------------------------- /doc/handbook/tutorial-newmodel.tex: -------------------------------------------------------------------------------- 1 | \section[New model]{How to implement a new model} 2 | 3 | TODO: describe how to impelment a new model -------------------------------------------------------------------------------- /doc/handbook/tutorial.tex: -------------------------------------------------------------------------------- 1 | \chapter[Tutorial]{Tutorial}\label{chp:tutorial} 2 | 3 | \eWoms provides two sorts of models: Models which use a fully-implicit 4 | discretization in space and time and models that use a 5 | semi-implicit space and an explicit time discretization. 6 | 7 | Fully-implicit models as implemented by \eWoms describe the 8 | conservation quantities of a flow system as a system of strongly 9 | coupled partial differential equations which is directly using a 10 | non-linear solver. Physically, these conservation quantities are mass, 11 | momentum and energy; Although the momentum is usually not explicitly 12 | conserved in the context of flow models for porous media. 13 | 14 | In section \ref{box} a short introduction to the vertex centered 15 | finite volume scheme (VCFV or box method) used by \eWoms as the 16 | primary spatial discretization is given. 17 | 18 | The purpose of this chapter is to introduce how flow problems can be 19 | solved in \eWoms. Being a simple but representative case, an 20 | isothermal two-phase problem (i.e. two fluid phases, one solid phase) 21 | will be considered. The source code of these tutorials is shipped with 22 | the \eWoms source package and can be found in the \texttt{tutorial} 23 | directory. 24 | 25 | \input{tutorial1} 26 | 27 | %%% Local Variables: 28 | %%% mode: latex 29 | %%% TeX-master: "ewoms-handbook" 30 | %%% End: 31 | -------------------------------------------------------------------------------- /dune.module: -------------------------------------------------------------------------------- 1 | #################################################################### 2 | # Dune module information file: This file gets parsed by dunecontrol 3 | # and by the CMake build scripts. 4 | #################################################################### 5 | 6 | Module: opm-simulators 7 | Description: Simulators and utilities for automatic differentiation 8 | Version: 2025.10-pre 9 | Label: 2025.10-pre 10 | Maintainer: atgeirr@sintef.no 11 | MaintainerName: Atgeirr F. Rasmussen 12 | Url: http://opm-project.org 13 | Depends: dune-istl (>= 2.9) opm-common opm-grid 14 | -------------------------------------------------------------------------------- /examples/fracture_discretefracture.cpp: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * 26 | * \brief Two-phase problem test with fractures. 27 | */ 28 | #include "config.h" 29 | 30 | #include 31 | #include 32 | 33 | #include "problems/fractureproblem.hh" 34 | 35 | int main(int argc, char **argv) 36 | { 37 | using ProblemTypeTag = Opm::Properties::TTag::FractureProblem; 38 | return Opm::start(argc, argv, true); 39 | } 40 | -------------------------------------------------------------------------------- /examples/lens_immiscible_ecfv_ad.cpp: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * 26 | * \brief Two-phase test for the immiscible model which uses the element-centered finite 27 | * volume discretization in conjunction with automatic differentiation 28 | */ 29 | #include "config.h" 30 | 31 | #include "lens_immiscible_ecfv_ad.hh" 32 | 33 | #include 34 | #include 35 | 36 | int main(int argc, char **argv) 37 | { 38 | using ProblemTypeTag = Opm::Properties::TTag::LensProblemEcfvAd; 39 | return Opm::start(argc, argv, true); 40 | } 41 | -------------------------------------------------------------------------------- /examples/mrst/sim_simple.m: -------------------------------------------------------------------------------- 1 | function x = sim_simple(cartDims, physDims, tf, verb) 2 | g = computeGeometry(cartGrid(cartDims, physDims)); 3 | 4 | rock = struct('perm', repmat(1, [g.cells.num, 1]), ... 5 | 'poro', repmat(1, [g.cells.num, 1])); 6 | 7 | T = computeTrans(g, rock); 8 | 9 | fluid = initSimpleFluid('n' , [ 1, 1], ... 10 | 'mu' , [ 1, 30], ... 11 | 'rho', [1000, 800]); 12 | 13 | gravity reset off 14 | 15 | src = addSource([], [1, g.cells.num], [1, -1], 'sat', [ 1, 0 ; 0, 1]); 16 | 17 | s0 = [0, 1]; 18 | state = incompTPFA(initState(g, [], 0, s0), ... 19 | g, T, fluid, 'src', src, 'matrixoutput', true); 20 | 21 | if nargin < 4, verb = false; end 22 | state = implicitTransport(state, g, tf, rock, fluid, ... 23 | 'src', src, 'verbose', verb, ... 24 | 'nltol', 1e-12); 25 | 26 | x = struct('g', g, 'rock', rock, 'T', T, 'fluid', fluid, ... 27 | 'src', src, 'state', state); 28 | end 29 | -------------------------------------------------------------------------------- /flow/flow.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2015, 2017 IRIS AS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | 22 | #include "config.h" 23 | 24 | #include 25 | 26 | int main(int argc, char** argv) 27 | { 28 | auto mainObject = std::make_unique(argc, argv); 29 | auto ret = mainObject->runDynamic(); 30 | // Destruct mainObject as the destructor calls MPI_Finalize! 31 | mainObject.reset(); 32 | return ret; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /flow/flow_blackoil.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_BLACKOIL_TPFA_HPP 18 | #define FLOW_BLACKOIL_TPFA_HPP 19 | 20 | #include 21 | 22 | #include 23 | 24 | namespace Opm { 25 | 26 | //! \brief Main function used in flow binary. 27 | int flowBlackoilTpfaMain(int argc, char** argv, bool outputCout, bool outputFiles); 28 | 29 | template class FlowMain; 30 | 31 | //! \brief Initialization function used in flow binary and python simulator. 32 | std::unique_ptr> 33 | flowBlackoilTpfaMainInit(int argc, char** argv, bool outputCout, bool outputFiles); 34 | 35 | //! \brief Main function used in flow_brine binary. 36 | int flowBlackoilTpfaMainStandalone(int argc, char** argv); 37 | 38 | } 39 | 40 | #endif // FLOW_BLACKOIL_TPFA_HPP 41 | -------------------------------------------------------------------------------- /flow/flow_blackoil_float_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2020, NORCE AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include 20 | 21 | #include 22 | #include 23 | 24 | namespace Opm::Properties { 25 | 26 | template 27 | struct Scalar 28 | { 29 | using type = float; 30 | }; 31 | 32 | } 33 | 34 | int main(int argc, char** argv) 35 | { 36 | using TypeTag = Opm::Properties::TTag::FlowProblemTPFA; 37 | auto mainObject = Opm::Main(argc, argv); 38 | return mainObject.runStatic(); 39 | } 40 | -------------------------------------------------------------------------------- /flow/flow_blackoil_legacyassembly.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_EBOS_BLACKOIL_HPP 18 | #define FLOW_EBOS_BLACKOIL_HPP 19 | 20 | #include 21 | 22 | namespace Opm { 23 | 24 | template class FlowMain; 25 | 26 | namespace Action { 27 | class State; 28 | } 29 | namespace Properties { namespace TTag { struct FlowProblem; } } 30 | 31 | //! \brief Main function used in flow binary. 32 | int flowBlackoilMain(int argc, char** argv, bool outputCout, bool outputFiles); 33 | 34 | //! \brief Initialization function used in flow binary and python simulator. 35 | std::unique_ptr> 36 | flowBlackoilMainInit(int argc, char** argv, bool outputCout, bool outputFiles); 37 | 38 | //! \brief Main function used in flow_blackoil binary. 39 | int flowBlackoilMainStandalone(int argc, char** argv); 40 | 41 | } 42 | 43 | #endif // FLOW_EBOS_BLACKOIL_HPP 44 | -------------------------------------------------------------------------------- /flow/flow_blackoil_legacyassembly_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowBlackoilMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_blackoil_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | 18 | #include "config.h" 19 | 20 | #include 21 | 22 | int main(int argc, char** argv) 23 | { 24 | return Opm::flowBlackoilTpfaMainStandalone(argc, argv); 25 | } 26 | -------------------------------------------------------------------------------- /flow/flow_brine.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_BRINE_HPP 18 | #define FLOW_BRINE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowBrineMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_brine binary. 26 | int flowBrineMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_EBOS_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_brine_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | 18 | #ifndef FLOW_BRINE_ENERGY_HPP 19 | #define FLOW_BRINE_ENERGY_HPP 20 | 21 | namespace Opm { 22 | int flowBrineEnergyMain(int argc, char** argv); 23 | } 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /flow/flow_brine_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | int main(int argc, char** argv) 21 | { 22 | return Opm::flowBrineEnergyMain(argc, argv); 23 | } 24 | -------------------------------------------------------------------------------- /flow/flow_brine_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowBrineMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_brine_precsalt_vapwat.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_BRINE_PRECSALT_VAPWAT_HPP 18 | #define FLOW_BRINE_PRECSALT_VAPWAT_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowBrinePrecsaltVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_brine binary. 26 | int flowBrinePrecsaltVapwatMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_BRINE_PRECSALT_VAPWAT_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_brine_precsalt_vapwat_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowBrinePrecsaltVapwatMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_brine_saltprecipitation.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_BRINE_SALTPRECIPITATION_HPP 18 | #define FLOW_BRINE_SALTPRECIPITATION_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowBrineSaltPrecipitationMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_brine binary. 26 | int flowBrineSaltPrecipitationMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_BRINE_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_brine_saltprecipitation_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowBrineSaltPrecipitationMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_ENERGY_HPP 18 | #define FLOW_ENERGY_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_energy binary. 26 | int flowEnergyMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_ENERGY_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowEnergyMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_extbo.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_EXTBO_HPP 18 | #define FLOW_EXTBO_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowExtboMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_extbo binary. 26 | int flowExtboMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_EXTBO_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_extbo_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowExtboMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_foam.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_FOAM_HPP 18 | #define FLOW_FOAM_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowFoamMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_foam binary. 26 | int flowFoamMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_FOAM_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_foam_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowFoamMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gasoil.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASOIL_HPP 18 | #define FLOW_GASOIL_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasOilMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gasoil binary. 26 | int flowGasOilMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASOIL_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gasoil_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASOIL_ENERGY_HPP 18 | #define FLOW_GASOIL_ENERGY_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasOilEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gasoil_energy binary. 26 | int flowGasOilEnergyMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASOIL_ENERGY_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gasoil_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasOilEnergyMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gasoil_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasOilMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gasoildiffuse.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASOILDIFFUSE_HPP 18 | #define FLOW_GASOILDIFFUSE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasOilDiffuseMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gasoil binary. 26 | int flowGasOilDiffuseMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASOILDIFFUSE_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gasoildiffuse_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasOilDiffuseMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_HPP 18 | #define FLOW_GASWATER_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater binary. 26 | int flowGasWaterMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_brine.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_BRINE_HPP 18 | #define FLOW_GASWATER_BRINE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_brine binary. 26 | int flowGasWaterBrineMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_BRINE_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_brine_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterBrineMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_dissolution.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_DISSOLUTION_HPP 18 | #define FLOW_GASWATER_DISSOLUTION_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterDissolutionMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_dissolution binary. 26 | int flowGasWaterDissolutionMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_DISSOLUTION_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_dissolution_diffuse.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_DISSOLUTION_DIFFUSE_HPP 18 | #define FLOW_GASWATER_DISSOLUTION_DIFFUSE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterDissolutionDiffuseMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_dissolution binary. 26 | int flowGasWaterDissolutionDiffuseMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_DISSOLUTION_DIFFUSE_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_dissolution_diffuse_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterDissolutionDiffuseMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_dissolution_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterDissolutionMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_ENERGY_HPP 18 | #define FLOW_GASWATER_ENERGY_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater binary. 26 | int flowGasWaterEnergyMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_ENERGY_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterEnergyMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_saltprec_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_SALTPREC_ENERGY_HPP 18 | #define FLOW_GASWATER_SALTPREC_ENERGY_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterSaltprecEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_saltprec_energy binary. 26 | int flowGasWaterSaltprecEnergyMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_SALTPREC_ENERGY_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_saltprec_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterSaltprecEnergyMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_saltprec_vapwat.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATERSALTPRECVAPWAT_BRINE_HPP 18 | #define FLOW_GASWATERSALTPRECVAPWAT_BRINE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterSaltprecVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_brine binary. 26 | int flowGasWaterSaltprecVapwatMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATERSALTPRECVAPWAT_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_saltprec_vapwat_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterSaltprecVapwatMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_gaswater_solvent.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_GASWATER_SOLVENT_HPP 18 | #define FLOW_GASWATER_SOLVENT_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowGasWaterSolventMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_gaswater_solvent binary. 26 | int flowGasWaterSolventMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_GASWATER_SOLVENT_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_gaswater_solvent_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowGasWaterSolventMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_micp.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_MICP_HPP 18 | #define FLOW_MICP_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowMICPMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_micp binary. 26 | int flowMICPMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_MICP_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_micp_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowMICPMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_oilwater.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_OILWATER_HPP 18 | #define FLOW_OILWATER_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main functon used in main flow binary. 23 | int flowOilWaterMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_oilwater binary. 26 | int flowOilWaterMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_OILWATER_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_oilwater_brine.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_OILWATER_BRINE_HPP 18 | #define FLOW_OILWATER_BRINE_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowOilWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_oilwater_brine binary. 26 | int flowOilWaterBrineMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_OILWATER_BRINE_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_oilwater_brine_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowOilWaterBrineMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_oilwater_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowOilWaterMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_oilwater_polymer.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_OILWATER_POLYMER_HPP 18 | #define FLOW_OILWATER_POLYMER_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main functon used in main flow binary. 23 | int flowOilWaterPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_oilwater_polymer binary. 26 | int flowOilWaterPolymerMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_OILWATER_POLYMER_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_oilwater_polymer_injectivity.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_OILWATER_POLYMER_INJECTIVITY_HPP 18 | #define FLOW_OILWATER_POLYMER_INJECTIVITY_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowOilWaterPolymerInjectivityMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_oilwater_polymer_injectivity binary. 26 | int flowOilWaterPolymerInjectivityMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_OILWATER_POLYMER_INJECTIVITY_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_oilwater_polymer_injectivity_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowOilWaterPolymerInjectivityMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_oilwater_polymer_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowOilWaterPolymerMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_onephase.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2015, 2017 IRIS AS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | 22 | #ifndef FLOW_ONEPHASE_HPP 23 | #define FLOW_ONEPHASE_HPP 24 | 25 | namespace Opm { 26 | 27 | //! \brief Main functon used in main flow binary. 28 | int flowWaterOnlyMain(int argc, char** argv, bool outputCout, bool outputFiles); 29 | 30 | //! \brief Main function used in flow_onephase binary. 31 | int flowWaterOnlyMainStandalone(int argc, char** argv); 32 | } 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /flow/flow_onephase_energy.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2015, 2017 IRIS AS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | 22 | #ifndef FLOW_ONEPHASE_ENERGY_HPP 23 | #define FLOW_ONEPHASE_ENERGY_HPP 24 | 25 | namespace Opm { 26 | 27 | //! \brief Main functon used in main flow binary. 28 | int flowWaterOnlyEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles); 29 | 30 | //! \brief Main function used in flow_onephase_energy binary. 31 | int flowWaterOnlyEnergyMainStandalone(int argc, char** argv); 32 | 33 | } 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /flow/flow_onephase_energy_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2015, 2017 IRIS AS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | #include "config.h" 22 | #include 23 | 24 | int main(int argc, char** argv) 25 | { 26 | return Opm::flowWaterOnlyEnergyMainStandalone(argc,argv); 27 | } 28 | -------------------------------------------------------------------------------- /flow/flow_onephase_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2015, 2017 IRIS AS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | #include "config.h" 22 | #include 23 | 24 | 25 | int main(int argc, char** argv) 26 | { 27 | return Opm::flowWaterOnlyMainStandalone(argc, argv); 28 | } 29 | -------------------------------------------------------------------------------- /flow/flow_polymer.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_POLYMER_HPP 18 | #define FLOW_POLYMER_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_polymer binary. 26 | int flowPolymerMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_POLYMER_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_polymer_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowPolymerMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_solvent.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_SOLVENT_HPP 18 | #define FLOW_SOLVENT_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowSolventMain(int argc, char** argv, bool outoutCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_solvent binary. 26 | int flowSolventMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_SOLVENT_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_solvent_foam.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #ifndef FLOW_SOLVENT_FOAM_HPP 18 | #define FLOW_SOLVENT_FOAM_HPP 19 | 20 | namespace Opm { 21 | 22 | //! \brief Main function used in flow binary. 23 | int flowSolventFoamMain(int argc, char** argv, bool outoutCout, bool outputFiles); 24 | 25 | //! \brief Main function used in flow_solvent_foam binary. 26 | int flowSolventFoamMainStandalone(int argc, char** argv); 27 | 28 | } 29 | 30 | #endif // FLOW_SOLVENT_FOAM_HPP 31 | -------------------------------------------------------------------------------- /flow/flow_solvent_foam_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowSolventFoamMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flow/flow_solvent_main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Open Porous Media project (OPM). 3 | 4 | OPM is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with OPM. If not, see . 16 | */ 17 | #include "config.h" 18 | #include 19 | 20 | 21 | int main(int argc, char** argv) 22 | { 23 | return Opm::flowSolventMainStandalone(argc, argv); 24 | } 25 | -------------------------------------------------------------------------------- /flowexperimental/FIBlackOilModelNoCache.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OPM_FI_BLACK_OIL_MODEL_NOCACHE_HPP 2 | #define OPM_FI_BLACK_OIL_MODEL_NOCACHE_HPP 3 | 4 | #include 5 | 6 | namespace Opm { 7 | 8 | template 9 | class FIBlackOilModelNoCache: public FIBlackOilModel 10 | { 11 | using Simulator = GetPropType; 12 | using IntensiveQuantities = GetPropType; 13 | 14 | public: 15 | explicit FIBlackOilModelNoCache(Simulator& simulator) 16 | : FIBlackOilModel(simulator) 17 | {} 18 | 19 | IntensiveQuantities intensiveQuantities(unsigned globalIdx, unsigned timeIdx) const 20 | { 21 | OPM_TIMEBLOCK_LOCAL(intensiveQuantitiesNoCache); 22 | const auto& primaryVar = this->solution(timeIdx)[globalIdx]; 23 | const auto& problem = this->simulator_.problem(); 24 | if (!(this->enableIntensiveQuantityCache_) || 25 | !(this->intensiveQuantityCacheUpToDate_[timeIdx][globalIdx])) { 26 | IntensiveQuantities intQuants; 27 | intQuants.update(problem,primaryVar, globalIdx, timeIdx); 28 | return intQuants;// reqiored for updating extrution factor 29 | } else { 30 | IntensiveQuantities intQuants = (this->intensiveQuantityCache_[timeIdx][globalIdx]); 31 | return intQuants; 32 | } 33 | } 34 | }; 35 | 36 | } // namespace Opm 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<2, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp2_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<2, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<3, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp3_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<3, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp4.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<4, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp4_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<4, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp5.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<5, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp5_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<5, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp6.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<6, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp6_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<6, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp7.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<7, true>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /flowexperimental/comp/flowexp_comp7_2p.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024, SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | #include 25 | 26 | #include "flowexp_comp.hpp" 27 | 28 | namespace Opm { 29 | 30 | template<> 31 | int dispatchFlowExpComp<7, false>(int argc, char** argv) 32 | { 33 | return start>(argc, argv, false); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /jenkins/README.md: -------------------------------------------------------------------------------- 1 | # opm-simulators jenkins build scripts: 2 | 3 | **build.sh**: 4 | This script will build dependencies, then build opm-simulators and execute its tests. 5 | It also inspects the $ghbPrBuildComment environmental variable and builds 6 | downstreams if requested. It inspects the $ghbPrBuildComment 7 | environmental variable to obtain a pull request to use for the modules. 8 | 9 | It is intended for pre-merge builds of pull requests. 10 | 11 | To specify a given pull request to use for upstreams and downstreams, 12 | trigger line needs to contain <module-name>=<pull request number>. 13 | 14 | To build with downstreams the trigger line needs to contain 'with downstreams'. 15 | 16 | **run-spe.sh**: 17 | This script will execute the SPE1, SPE3 and SPE9 cases, then compare against 18 | OPM and Eclipse reference results. It is meant to be executed after a build. 19 | The binary used used is from the build identified by the configuration 20 | environment variable. 21 | 22 | **run-norne.sh**: 23 | This script will execute the Norne case, and generate a document with 24 | plots of the results. It is meant to be executed after a build. 25 | The binary used used is from the build identified by the configuration 26 | environment variable. 27 | 28 | **run-polymer.sh**: 29 | This script will execute the simple2D polymer case, then compare against 30 | Eclipse reference results. It is meant to be executed after a build. 31 | The binary used used is from the build identified by the configuration 32 | environment variable. 33 | -------------------------------------------------------------------------------- /jenkins/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | #Print commands as they execute 4 | #set -x 5 | 6 | declare -a upstreams 7 | upstreams=(opm-common 8 | opm-grid) 9 | 10 | declare -A upstreamRev 11 | upstreamRev[opm-common]=master 12 | upstreamRev[opm-grid]=master 13 | 14 | if grep -q "opm-common=" <<< $ghprbCommentBody 15 | then 16 | upstreamRev[opm-common]=pull/`echo $ghprbCommentBody | sed -r 's/.*opm-common=([0-9]+).*/\1/g'`/merge 17 | fi 18 | 19 | # No downstreams currently 20 | declare -a downstreams 21 | declare -A downstreamRev 22 | 23 | # Clone opm-common 24 | pushd . 25 | mkdir -p $WORKSPACE/deps/opm-common 26 | cd $WORKSPACE/deps/opm-common 27 | git init . 28 | git remote add origin https://github.com/OPM/opm-common 29 | git fetch --depth 1 origin ${upstreamRev[opm-common]}:branch_to_build 30 | test $? -eq 0 || exit 1 31 | git checkout branch_to_build 32 | popd 33 | 34 | source $WORKSPACE/deps/opm-common/jenkins/build-opm-module.sh 35 | 36 | parseRevisions 37 | printHeader opm-simulators 38 | 39 | # Setup opm-data 40 | source $WORKSPACE/deps/opm-common/jenkins/setup-opm-tests.sh 41 | 42 | build_module_full opm-simulators 43 | -------------------------------------------------------------------------------- /jenkins/run-norne.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | pushd . 4 | cd deps/opm-tests 5 | test -z $SIM && SIM=flow 6 | 7 | # Run the norne case 8 | cd norne 9 | if test -n "$1" 10 | then 11 | mpirun -np $1 $WORKSPACE/$configuration/build-opm-simulators/bin/$SIM --output-dir=${SIM}_${1}_proc NORNE_ATW2013.DATA 12 | else 13 | $WORKSPACE/$configuration/build-opm-simulators/bin/$SIM --output-dir=$SIM NORNE_ATW2013.DATA 14 | fi 15 | test $? -eq 0 || exit 1 16 | ./plotwells.sh $WORKSPACE/$configuration/install/bin "ECL.2014.2 opm-simulation-reference/flow_legacy" norne-wells 17 | ./plotwells.sh $WORKSPACE/$configuration/install/bin "opm-simulation-reference/flow_legacy" norne-wells-noecl 18 | 19 | popd 20 | -------------------------------------------------------------------------------- /opm/models/common/flux.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * 26 | * \brief This file contains the necessary classes to calculate the 27 | * velocity out of a pressure potential gradient. 28 | */ 29 | #ifndef EWOMS_VELOCITY_MODULES_HH 30 | #define EWOMS_VELOCITY_MODULES_HH 31 | 32 | #include 33 | #include 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /opm/models/common/multiphasebaseparameters.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * \ingroup MultiPhaseBaseModel 26 | * 27 | * \brief Defines the common parameters for the porous medium 28 | * multi-phase models. 29 | */ 30 | #ifndef EWOMS_MULTI_PHASE_BASE_PARAMETERS_HH 31 | #define EWOMS_MULTI_PHASE_BASE_PARAMETERS_HH 32 | 33 | namespace Opm::Parameters { 34 | 35 | //! Returns whether gravity is considered in the problem. 36 | struct EnableGravity { static constexpr bool value = false; }; 37 | 38 | } // namespace Opm::Parameters 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /opm/models/discretefracture/discretefractureproperties.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * \ingroup DiscreteFractureModel 26 | * 27 | * \brief Defines the properties required for the immiscible 28 | * multi-phase model which considers discrete fractures. 29 | */ 30 | #ifndef EWOMS_DISCRETE_FRACTURE_PROPERTIES_HH 31 | #define EWOMS_DISCRETE_FRACTURE_PROPERTIES_HH 32 | 33 | #include 34 | 35 | namespace Opm::Properties { 36 | 37 | template 38 | struct UseTwoPointGradients { using type = UndefinedProperty; }; 39 | 40 | } // namespace Opm::Properties 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /opm/models/discretization/common/linearizationtype.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * 26 | * \copydoc Opm::FvBaseLinearizer 27 | */ 28 | #ifndef EWOMS_FV_BASE_LINEARIZATIONTYPE_HH 29 | #define EWOMS_FV_BASE_LINEARIZATIONTYPE_HH 30 | 31 | namespace Opm { 32 | 33 | struct LinearizationType 34 | { 35 | enum VarType { implicit, pressure, seqtransport }; 36 | VarType type = implicit; 37 | unsigned int time = 0; 38 | }; 39 | 40 | } // namespace Opm 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /opm/models/flash/flashparameters.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * \ingroup FlashModel 26 | * 27 | * \brief Declares the parameters for the compositional 28 | * multi-phase model based on flash calculations. 29 | */ 30 | #ifndef EWOMS_FLASH_PARAMETERS_HH 31 | #define EWOMS_FLASH_PARAMETERS_HH 32 | 33 | namespace Opm::Parameters { 34 | 35 | //! The maximum accepted error of the flash solver 36 | //! Let the flash solver choose its tolerance by default 37 | template 38 | struct FlashTolerance { static constexpr Scalar value = -1.0; }; 39 | 40 | } // namespace Opm::Parameters 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /opm/models/flash/flashproperties.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | /*! 24 | * \file 25 | * \ingroup FlashModel 26 | * 27 | * \brief Declares the properties required by the compositional 28 | * multi-phase model based on flash calculations. 29 | */ 30 | #ifndef EWOMS_FLASH_PROPERTIES_HH 31 | #define EWOMS_FLASH_PROPERTIES_HH 32 | 33 | #include 34 | 35 | namespace Opm::Properties { 36 | 37 | //! The type of the flash constraint solver 38 | template 39 | struct FlashSolver { using type = UndefinedProperty; }; 40 | 41 | } // namespace Opm::Properties 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /opm/models/io/vtkphasepresenceparams.cpp: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | 24 | #include 25 | #include 26 | 27 | #include 28 | 29 | namespace Opm { 30 | 31 | void VtkPhasePresenceParams::registerParameters() 32 | { 33 | Parameters::Register 34 | ("Include the phase presence pseudo primary " 35 | "variable in the VTK output files"); 36 | } 37 | 38 | void VtkPhasePresenceParams::read() 39 | { 40 | phasePresenceOutput_ = Parameters::Get(); 41 | } 42 | 43 | } // namespace Opm 44 | -------------------------------------------------------------------------------- /opm/models/io/vtktemperatureparams.cpp: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | 24 | #include 25 | #include 26 | 27 | #include 28 | 29 | namespace Opm { 30 | 31 | void VtkTemperatureParams::registerParameters() 32 | { 33 | Parameters::Register 34 | ("Include the temperature in the VTK output files"); 35 | } 36 | 37 | void VtkTemperatureParams::read() 38 | { 39 | temperatureOutput_ = Parameters::Get(); 40 | } 41 | 42 | } // namespace Opm 43 | -------------------------------------------------------------------------------- /opm/simulators/aquifers/SupportsFaceTag.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | File adapted from BlackoilWellModel.hpp 3 | 4 | Copyright 2017 TNO - Heat Transfer & Fluid Dynamics, Modelling & Optimization of the Subsurface 5 | Copyright 2017 Statoil ASA. 6 | 7 | This file is part of the Open Porous Media project (OPM). 8 | 9 | OPM is free software: you can redistribute it and/or modify 10 | it under the terms of the GNU General Public License as published by 11 | the Free Software Foundation, either version 3 of the License, or 12 | (at your option) any later version. 13 | 14 | OPM is distributed in the hope that it will be useful, 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 | GNU General Public License for more details. 18 | 19 | You should have received a copy of the GNU General Public License 20 | along with OPM. If not, see . 21 | */ 22 | 23 | 24 | #ifndef OPM_SUPPORTS_FACETAG_HEADER_INCLUDED 25 | #define OPM_SUPPORTS_FACETAG_HEADER_INCLUDED 26 | 27 | namespace Dune { class CpGrid; } 28 | 29 | namespace Opm { 30 | 31 | template 32 | class SupportsFaceTag 33 | : public std::bool_constant 34 | {}; 35 | 36 | 37 | template<> 38 | class SupportsFaceTag 39 | : public std::bool_constant 40 | {}; 41 | 42 | 43 | } // namespace Opm 44 | 45 | #endif // OPM_SUPPORT_FACETAG_HEADER_INCLUDED 46 | -------------------------------------------------------------------------------- /opm/simulators/flow/FlowsData.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2023 SINTEF Digital 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_FLOWS_DATA_HEADER_INCLUDED 21 | #define OPM_FLOWS_DATA_HEADER_INCLUDED 22 | 23 | #include 24 | #include 25 | #include 26 | 27 | namespace Opm { 28 | 29 | //! \brief Simple container for FLOWS data. 30 | template 31 | struct FlowsData 32 | { 33 | //! \brief Resize data vectors. 34 | void resize(const std::size_t size) 35 | { 36 | indices.resize(size); 37 | values.resize(size); 38 | } 39 | 40 | std::string name; //!< Associated name 41 | std::vector indices; //!< Cell indices for values 42 | std::vector values; //!< Values 43 | }; 44 | 45 | } // namespace Opm 46 | 47 | #endif // OPM_FLOWS_DATA_HEADER_INCLUDED 48 | -------------------------------------------------------------------------------- /opm/simulators/flow/SimulatorReportBanners.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2015, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | Copyright 2015 Andreas Lauser 4 | Copyright 2017 IRIS 5 | 6 | This file is part of the Open Porous Media project (OPM). 7 | 8 | OPM is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | OPM is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with OPM. If not, see . 20 | */ 21 | 22 | #ifndef OPM_SIMULATOR_REPORT_BANNERS_HEADER_INCLUDED 23 | #define OPM_SIMULATOR_REPORT_BANNERS_HEADER_INCLUDED 24 | 25 | namespace Opm { class SimulatorTimer; } 26 | 27 | namespace Opm::details { 28 | 29 | void outputReportStep(const SimulatorTimer& timer); 30 | 31 | } // namespace Opm::details 32 | 33 | #endif // OPM_SIMULATOR_REPORT_BANNERS_HEADER_INCLUDED 34 | -------------------------------------------------------------------------------- /opm/simulators/flow/TTagFlowProblemTPFA.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2025 Equinor ASA. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef TTAG_FLOW_PROBLEM_TPFA_HPP 21 | #define TTAG_FLOW_PROBLEM_TPFA_HPP 22 | 23 | #include 24 | 25 | namespace Opm::Properties::TTag { 26 | 27 | struct FlowProblem; 28 | 29 | /// Specialised type tag for simulations that can use the customised 30 | /// assembly process for TPFA discretisation schemes. 31 | /// 32 | /// All properties are otherwise the same as for the regular 33 | /// FlowProblem. 34 | struct FlowProblemTPFA { 35 | using InheritsFrom = std::tuple; 36 | }; 37 | 38 | } // namespace Opm::Properties::TTag 39 | 40 | #endif // TTAG_FLOW_PROBLEM_TPFA_HPP 41 | -------------------------------------------------------------------------------- /opm/simulators/flow/ValidationFunctions.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2021 Equinor. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef VALIDATION_FUNCTIONS_HPP 21 | #define VALIDATION_FUNCTIONS_HPP 22 | 23 | #include 24 | #include 25 | #include 26 | #include 27 | 28 | namespace Opm { 29 | class DeckKeyword; 30 | } 31 | 32 | namespace Opm::KeywordValidation { 33 | 34 | struct ValidationError; 35 | 36 | using ValidationFunction = std::function&)>; 38 | 39 | // This is a mapping between keyword names and small functions 40 | // for validation of special keywords. 41 | std::unordered_map 42 | specialValidation(); 43 | 44 | } // namespace Opm::KeywordValidation 45 | 46 | #endif // VALIDATION_FUNCTIONS_HPP 47 | -------------------------------------------------------------------------------- /opm/simulators/flow/python/Pybind11Exporter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OPM_PYBIND11_EXPORTER_HEADER_INCLUDED 2 | #define OPM_PYBIND11_EXPORTER_HEADER_INCLUDED 3 | 4 | #include 5 | #include 6 | #include 7 | //#include 8 | 9 | namespace py = pybind11; 10 | 11 | namespace Opm::Pybind { 12 | void export_all(py::module& m); 13 | void export_PyBlackOilSimulator(py::module& m); 14 | } 15 | 16 | #endif //OPM_PYBIND11_EXPORTER_HEADER_INCLUDED 17 | -------------------------------------------------------------------------------- /opm/simulators/linalg/ExtraSmoothers.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OPM_EXTRASMOOTHERS_HPP 2 | #define OPM_EXTRASMOOTHERS_HPP 3 | 4 | #include "DILU.hpp" 5 | 6 | namespace Dune 7 | { 8 | template 9 | class MultithreadDILU; 10 | 11 | namespace Amg 12 | { 13 | /** 14 | * @brief Policy for the construction of the MultithreadDILU smoother 15 | */ 16 | template 17 | struct ConstructionTraits> { 18 | using Arguments = DefaultConstructionArgs>; 19 | 20 | static inline std::shared_ptr> construct(Arguments& args) { 21 | return std::make_shared>(args.getMatrix()); 22 | } 23 | }; 24 | 25 | } // namespace Amg 26 | } // namespace Dune 27 | #endif // OPM_EXTRASMOOTHERS_HPP 28 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,1) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,1) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,2) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,2) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,3) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,3) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver4.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,4) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,4) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver5.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,5) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,5) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/FlexibleSolver6.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019, 2020 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #include "config.h" 21 | 22 | #include 23 | 24 | INSTANTIATE_FLEXIBLESOLVER(double,6) 25 | 26 | #if FLOW_INSTANTIATE_FLOAT 27 | INSTANTIATE_FLEXIBLESOLVER(float,6) 28 | #endif 29 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,1) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,1) 11 | #endif 12 | 13 | } 14 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,2) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,2) 11 | #endif 12 | 13 | } 14 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,3) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,3) 11 | #endif 12 | 13 | } 14 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,4) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,4) 11 | #endif 12 | 13 | } 14 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,5) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,5) 11 | #endif 12 | 13 | } 14 | -------------------------------------------------------------------------------- /opm/simulators/linalg/PreconditionerFactory6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace Opm { 6 | 7 | INSTANTIATE_PF(double,6) 8 | 9 | #if FLOW_INSTANTIATE_FLOAT 10 | INSTANTIATE_PF(float,6) 11 | #endif 12 | 13 | 14 | } 15 | -------------------------------------------------------------------------------- /opm/simulators/linalg/StandardPreconditioners_gpu_mpi.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2025 Equinor ASA 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | OPM is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU General Public License as published by 7 | the Free Software Foundation, either version 3 of the License, or 8 | (at your option) any later version. 9 | OPM is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | You should have received a copy of the GNU General Public License 14 | along with OPM. If not, see . 15 | */ 16 | 17 | #ifndef OPM_STANDARDPRECONDITIONERS_GPU_MPI_HEADER 18 | #define OPM_STANDARDPRECONDITIONERS_GPU_MPI_HEADER 19 | 20 | 21 | namespace Opm { 22 | 23 | 24 | template 25 | struct StandardPreconditioners>> 26 | { 27 | static void add() 28 | { 29 | // No standard preconditioners for this type of operator. 30 | } 31 | }; 32 | 33 | 34 | }// namespace Opm 35 | 36 | 37 | #endif // OPM_STANDARDPRECONDITIONERS_GPU_MPI_HEADER 38 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/add_coarse_pressure_correction.cl: -------------------------------------------------------------------------------- 1 | /// add the coarse pressure solution back to the finer, complete solution 2 | /// every workitem handles one blockrow 3 | __kernel void add_coarse_pressure_correction( 4 | __global const double *coarse_x, 5 | __global double *fine_x, 6 | const unsigned int pressure_idx, 7 | const unsigned int Nb) 8 | { 9 | const unsigned int NUM_THREADS = get_global_size(0); 10 | const unsigned int block_size = 3; 11 | unsigned int target_block_row = get_global_id(0); 12 | 13 | while(target_block_row < Nb){ 14 | fine_x[target_block_row * block_size + pressure_idx] += coarse_x[target_block_row]; 15 | target_block_row += NUM_THREADS; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/axpy.cl: -------------------------------------------------------------------------------- 1 | /// axpy kernel: a = a + alpha * b 2 | __kernel void axpy( 3 | __global double *in, 4 | const double a, 5 | __global double *out, 6 | const int N) 7 | { 8 | unsigned int NUM_THREADS = get_global_size(0); 9 | int idx = get_global_id(0); 10 | 11 | while(idx < N){ 12 | out[idx] += a * in[idx]; 13 | idx += NUM_THREADS; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/custom.cl: -------------------------------------------------------------------------------- 1 | /// Custom kernel: combines some bicgstab vector operations into 1 2 | /// p = (p - omega * v) * beta + r 3 | __kernel void custom( 4 | __global double *p, 5 | __global double *v, 6 | __global double *r, 7 | const double omega, 8 | const double beta, 9 | const int N) 10 | { 11 | const unsigned int NUM_THREADS = get_global_size(0); 12 | unsigned int idx = get_global_id(0); 13 | 14 | while(idx < N){ 15 | double res = p[idx]; 16 | res -= omega * v[idx]; 17 | res *= beta; 18 | res += r[idx]; 19 | p[idx] = res; 20 | idx += NUM_THREADS; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/dot_1.cl: -------------------------------------------------------------------------------- 1 | /// returns partial sums, instead of the final dot product 2 | /// partial sums are added on CPU 3 | __kernel void dot_1( 4 | __global double *in1, 5 | __global double *in2, 6 | __global double *out, 7 | const unsigned int N, 8 | __local double *tmp) 9 | { 10 | unsigned int tid = get_local_id(0); 11 | unsigned int bsize = get_local_size(0); 12 | unsigned int bid = get_global_id(0) / bsize; 13 | unsigned int i = get_global_id(0); 14 | unsigned int NUM_THREADS = get_global_size(0); 15 | 16 | double sum = 0.0; 17 | while(i < N){ 18 | sum += in1[i] * in2[i]; 19 | i += NUM_THREADS; 20 | } 21 | tmp[tid] = sum; 22 | 23 | barrier(CLK_LOCAL_MEM_FENCE); 24 | 25 | // do reduction in shared mem 26 | for(unsigned int s = get_local_size(0) / 2; s > 0; s >>= 1) 27 | { 28 | if (tid < s) 29 | { 30 | tmp[tid] += tmp[tid + s]; 31 | } 32 | barrier(CLK_LOCAL_MEM_FENCE); 33 | } 34 | 35 | // write result for this block to global mem 36 | if (tid == 0) out[get_group_id(0)] = tmp[0]; 37 | } 38 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/full_to_pressure_restriction.cl: -------------------------------------------------------------------------------- 1 | /// transform blocked vector to scalar vector using pressure-weights 2 | /// every workitem handles one blockrow 3 | __kernel void full_to_pressure_restriction( 4 | __global const double *fine_y, 5 | __global const double *weights, 6 | __global double *coarse_y, 7 | const unsigned int Nb) 8 | { 9 | const unsigned int NUM_THREADS = get_global_size(0); 10 | const unsigned int block_size = 3; 11 | unsigned int target_block_row = get_global_id(0); 12 | 13 | while(target_block_row < Nb){ 14 | double sum = 0.0; 15 | unsigned int idx = block_size * target_block_row; 16 | for (unsigned int i = 0; i < block_size; ++i) { 17 | sum += fine_y[idx + i] * weights[idx + i]; 18 | } 19 | coarse_y[target_block_row] = sum; 20 | target_block_row += NUM_THREADS; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/norm.cl: -------------------------------------------------------------------------------- 1 | /// returns partial sums, instead of the final norm 2 | /// the square root must be computed on CPU 3 | __kernel void norm( 4 | __global double *in, 5 | __global double *out, 6 | const unsigned int N, 7 | __local double *tmp) 8 | { 9 | unsigned int tid = get_local_id(0); 10 | unsigned int bsize = get_local_size(0); 11 | unsigned int bid = get_global_id(0) / bsize; 12 | unsigned int i = get_global_id(0); 13 | unsigned int NUM_THREADS = get_global_size(0); 14 | 15 | double local_sum = 0.0; 16 | while(i < N){ 17 | local_sum += in[i] * in[i]; 18 | i += NUM_THREADS; 19 | } 20 | tmp[tid] = local_sum; 21 | 22 | barrier(CLK_LOCAL_MEM_FENCE); 23 | 24 | // do reduction in shared mem 25 | for(unsigned int s = get_local_size(0) / 2; s > 0; s >>= 1) 26 | { 27 | if (tid < s) 28 | { 29 | tmp[tid] += tmp[tid + s]; 30 | } 31 | barrier(CLK_LOCAL_MEM_FENCE); 32 | } 33 | 34 | // write result for this block to global mem 35 | if (tid == 0) out[get_group_id(0)] = tmp[0]; 36 | } 37 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/prolongate_vector.cl: -------------------------------------------------------------------------------- 1 | /// prolongate vector during amg cycle 2 | /// every workitem handles one row 3 | __kernel void prolongate_vector( 4 | __global const double *in, 5 | __global double *out, 6 | __global const int *cols, 7 | const unsigned int N) 8 | { 9 | const unsigned int NUM_THREADS = get_global_size(0); 10 | unsigned int row = get_global_id(0); 11 | 12 | while(row < N){ 13 | out[row] += in[cols[row]]; 14 | row += NUM_THREADS; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/scale.cl: -------------------------------------------------------------------------------- 1 | /// scale vector with scalar: a = a * alpha 2 | __kernel void scale( 3 | __global double *vec, 4 | const double a, 5 | const int N) 6 | { 7 | unsigned int NUM_THREADS = get_global_size(0); 8 | int idx = get_global_id(0); 9 | 10 | while(idx < N){ 11 | vec[idx] *= a; 12 | idx += NUM_THREADS; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/spmv.cl: -------------------------------------------------------------------------------- 1 | /// b = mat * x 2 | /// algorithm based on: 3 | /// Optimization of Block Sparse Matrix-Vector Multiplication on Shared-MemoryParallel Architectures, 4 | /// Ryan Eberhardt, Mark Hoemmen, 2016, https://doi.org/10.1109/IPDPSW.2016.42 5 | __kernel void spmv( 6 | __global const double *vals, 7 | __global const int *cols, 8 | __global const int *rows, 9 | const int N, 10 | __global const double *x, 11 | __global double *out, 12 | __local double *tmp) 13 | { 14 | const unsigned int bsize = get_local_size(0); 15 | const unsigned int idx_b = get_global_id(0) / bsize; 16 | const unsigned int idx_t = get_local_id(0); 17 | const unsigned int num_workgroups = get_num_groups(0); 18 | 19 | int row = idx_b; 20 | 21 | while (row < N) { 22 | int rowStart = rows[row]; 23 | int rowEnd = rows[row+1]; 24 | int rowLength = rowEnd - rowStart; 25 | double local_sum = 0.0; 26 | for (int j = rowStart + idx_t; j < rowEnd; j += bsize) { 27 | int col = cols[j]; 28 | local_sum += vals[j] * x[col]; 29 | } 30 | 31 | tmp[idx_t] = local_sum; 32 | barrier(CLK_LOCAL_MEM_FENCE); 33 | 34 | int offset = bsize / 2; 35 | while(offset > 0) { 36 | if (idx_t < offset) { 37 | tmp[idx_t] += tmp[idx_t + offset]; 38 | } 39 | barrier(CLK_LOCAL_MEM_FENCE); 40 | offset = offset / 2; 41 | } 42 | 43 | if (idx_t == 0) { 44 | out[row] = tmp[idx_t]; 45 | } 46 | 47 | row += num_workgroups; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/spmv_noreset.cl: -------------------------------------------------------------------------------- 1 | /// algorithm based on: 2 | /// Optimization of Block Sparse Matrix-Vector Multiplication on Shared-MemoryParallel Architectures, 3 | /// Ryan Eberhardt, Mark Hoemmen, 2016, https://doi.org/10.1109/IPDPSW.2016.42 4 | __kernel void spmv_noreset( 5 | __global const double *vals, 6 | __global const int *cols, 7 | __global const int *rows, 8 | const int N, 9 | __global const double *x, 10 | __global double *out, 11 | __local double *tmp) 12 | { 13 | const unsigned int bsize = get_local_size(0); 14 | const unsigned int idx_b = get_global_id(0) / bsize; 15 | const unsigned int idx_t = get_local_id(0); 16 | const unsigned int num_workgroups = get_num_groups(0); 17 | 18 | int row = idx_b; 19 | 20 | while (row < N) { 21 | int rowStart = rows[row]; 22 | int rowEnd = rows[row+1]; 23 | int rowLength = rowEnd - rowStart; 24 | double local_sum = 0.0; 25 | for (int j = rowStart + idx_t; j < rowEnd; j += bsize) { 26 | int col = cols[j]; 27 | local_sum += vals[j] * x[col]; 28 | } 29 | 30 | tmp[idx_t] = local_sum; 31 | barrier(CLK_LOCAL_MEM_FENCE); 32 | 33 | int offset = bsize / 2; 34 | while(offset > 0) { 35 | if (idx_t < offset) { 36 | tmp[idx_t] += tmp[idx_t + offset]; 37 | } 38 | barrier(CLK_LOCAL_MEM_FENCE); 39 | offset = offset / 2; 40 | } 41 | 42 | if (idx_t == 0) { 43 | out[row] += tmp[idx_t]; 44 | } 45 | 46 | row += num_workgroups; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpubridge/opencl/kernels/vmul.cl: -------------------------------------------------------------------------------- 1 | /// multiply vector with another vector and a scalar, element-wise 2 | /// add result to a third vector 3 | __kernel void vmul( 4 | const double alpha, 5 | __global double const *in1, 6 | __global double const *in2, 7 | __global double *out, 8 | const int N) 9 | { 10 | unsigned int NUM_THREADS = get_global_size(0); 11 | int idx = get_global_id(0); 12 | 13 | while(idx < N){ 14 | out[idx] += alpha * in1[idx] * in2[idx]; 15 | idx += NUM_THREADS; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpuistl/detail/CuBlasHandle.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include 20 | #include 21 | #include 22 | namespace Opm::gpuistl::detail 23 | { 24 | 25 | 26 | CuBlasHandle::CuBlasHandle() 27 | { 28 | OPM_CUBLAS_SAFE_CALL(cublasCreate(&m_handle)); 29 | } 30 | 31 | CuBlasHandle::~CuBlasHandle() 32 | { 33 | OPM_CUBLAS_WARN_IF_ERROR(cublasDestroy(m_handle)); 34 | } 35 | 36 | cublasHandle_t 37 | CuBlasHandle::get() 38 | { 39 | return m_handle; 40 | } 41 | 42 | CuBlasHandle& 43 | CuBlasHandle::getInstance() 44 | { 45 | static CuBlasHandle instance; 46 | return instance; 47 | } 48 | 49 | } // namespace Opm::gpuistl::detail 50 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpuistl/detail/CuSparseHandle.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include 20 | #include 21 | namespace Opm::gpuistl::detail 22 | { 23 | 24 | 25 | CuSparseHandle::CuSparseHandle() 26 | { 27 | OPM_CUSPARSE_SAFE_CALL(cusparseCreate(&m_handle)); 28 | OPM_CUSPARSE_SAFE_CALL(cusparseSetStream(m_handle, 0)); 29 | } 30 | 31 | CuSparseHandle::~CuSparseHandle() 32 | { 33 | OPM_CUSPARSE_WARN_IF_ERROR(cusparseDestroy(m_handle)); 34 | } 35 | 36 | cusparseHandle_t 37 | CuSparseHandle::get() 38 | { 39 | return m_handle; 40 | } 41 | 42 | CuSparseHandle& 43 | CuSparseHandle::getInstance() 44 | { 45 | static CuSparseHandle instance; 46 | return instance; 47 | } 48 | 49 | } // namespace Opm::gpuistl::detail 50 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpuistl/detail/cusparse_constants.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #ifndef CUSPARSE_CONSTANTS_HPP 20 | #define CUSPARSE_CONSTANTS_HPP 21 | #include 22 | namespace Opm::gpuistl::detail 23 | { 24 | const constexpr auto CUSPARSE_MATRIX_ORDER = CUSPARSE_DIRECTION_ROW; 25 | } 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpuistl/device_management.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2024 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_GPUISTL_DEVICE_MANAGEMENT 21 | #define OPM_GPUISTL_DEVICE_MANAGEMENT 22 | 23 | /* 24 | This file should not be hipified, and serves as a layer between main and gpuistl/set_device 25 | that does not depend on the library such that the simulatorobjects to not depend 26 | on the library and can be built in parallel. 27 | */ 28 | 29 | namespace Opm::gpuistl { 30 | void printDevice(); 31 | void setDevice(); 32 | } 33 | 34 | #endif // namespace Opm::gpuistl 35 | -------------------------------------------------------------------------------- /opm/simulators/linalg/gpuistl/set_device.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_GPUISTL_SET_DEVICE_HEADER 21 | #define OPM_GPUISTL_SET_DEVICE_HEADER 22 | 23 | namespace Opm::gpuistl 24 | { 25 | //! @brief Sets the correct CUDA device in the setting of MPI 26 | //! 27 | //! @note This assumes that every node has equally many GPUs, all of the same caliber 28 | //! 29 | //! @note This probably needs to be called *before* MPI_Init if one uses GPUDirect transfers (see eg. 30 | //! https://devtalk.nvidia.com/default/topic/752046/teaching-and-curriculum-support/multi-gpu-system-running-mpi-cuda-/ 31 | //! ) 32 | //! 33 | //! @note If no CUDA device is present, this does nothing. 34 | void setDevice(int mpiRank, int numberOfMpiRanks); 35 | 36 | void printDevice(int mpiRank, int numberOfMpiRanks); 37 | } // namespace Opm::gpuistl 38 | #endif 39 | -------------------------------------------------------------------------------- /opm/simulators/linalg/ilufirstelement.hh: -------------------------------------------------------------------------------- 1 | // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- 2 | // vi: set et ts=4 sw=4 sts=4: 3 | /* 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 2 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | 19 | Consult the COPYING file in the top-level source directory of this 20 | module for the precise wording of the license and the list of 21 | copyright holders. 22 | */ 23 | 24 | #ifndef EWOMS_ILU_FIRSTELEMENT_HH 25 | #define EWOMS_ILU_FIRSTELEMENT_HH 26 | #include 27 | #include 28 | 29 | namespace Opm 30 | { 31 | template 32 | K& firstMatrixElement(MatrixBlock& A) 33 | { return A[0][0]; } 34 | } 35 | #endif // EWOMS_ILU_FIRSTELEMENT_HH 36 | 37 | 38 | -------------------------------------------------------------------------------- /opm/simulators/opm-simulators_doxygen_main.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2016 SINTEF ICT, Applied Mathematics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_OPM-SIMULATORS_DOXYGEN_MAIN_HEADER_INCLUDED 21 | #define OPM_OPM-SIMULATORS_DOXYGEN_MAIN_HEADER_INCLUDED 22 | 23 | 24 | /** \mainpage Documentation for the opm-simulators library. 25 | 26 | 27 |

Solvers and simulators

28 | 29 | The opm-simulators module is the home for the Flow reservoir 30 | simulators and library functionality on which they depend. 31 | 32 | */ 33 | 34 | #endif // OPM_OPM-SIMULATORS_DOXYGEN_MAIN_HEADER_INCLUDED 35 | -------------------------------------------------------------------------------- /opm/simulators/timestepping/gatherConvergenceReport.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2018 SINTEF Digital, Mathematics and Cybernetics. 3 | Copyright 2018 Equinor. 4 | 5 | This file is part of the Open Porous Media project (OPM). 6 | 7 | OPM is free software: you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation, either version 3 of the License, or 10 | (at your option) any later version. 11 | 12 | OPM is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with OPM. If not, see . 19 | */ 20 | 21 | #ifndef OPM_GATHERCONVERGENCEREPORT_HEADER_INCLUDED 22 | #define OPM_GATHERCONVERGENCEREPORT_HEADER_INCLUDED 23 | 24 | #include 25 | 26 | #include 27 | 28 | namespace Opm 29 | { 30 | 31 | /// Create a global convergence report combining local 32 | /// (per-process) reports. 33 | ConvergenceReport 34 | gatherConvergenceReport(const ConvergenceReport& local_report, 35 | Parallel::Communication communicator); 36 | 37 | } // namespace Opm 38 | 39 | #endif // OPM_GATHERCONVERGENCEREPORT_HEADER_INCLUDED 40 | -------------------------------------------------------------------------------- /opm/simulators/utils/ComponentName.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2013, 2015 SINTEF ICT, Applied Mathematics. 3 | Copyright 2014, 2015 Dr. Blatt - HPC-Simulation-Software & Services 4 | Copyright 2014, 2015 Statoil ASA. 5 | Copyright 2015 NTNU 6 | Copyright 2015, 2016, 2017 IRIS AS 7 | 8 | This file is part of the Open Porous Media project (OPM). 9 | 10 | OPM is free software: you can redistribute it and/or modify 11 | it under the terms of the GNU General Public License as published by 12 | the Free Software Foundation, either version 3 of the License, or 13 | (at your option) any later version. 14 | 15 | OPM is distributed in the hope that it will be useful, 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 | GNU General Public License for more details. 19 | 20 | You should have received a copy of the GNU General Public License 21 | along with OPM. If not, see . 22 | */ 23 | 24 | #ifndef COMPONENT_NAME_HPP 25 | #define COMPONENT_NAME_HPP 26 | 27 | #include 28 | #include 29 | 30 | namespace Opm { 31 | 32 | template 33 | class ComponentName 34 | { 35 | public: 36 | ComponentName(); 37 | 38 | const std::string& name(const int compIdx) const 39 | { 40 | return this->names_[compIdx]; 41 | } 42 | 43 | private: 44 | std::vector names_{}; 45 | }; 46 | 47 | } // namespace Opm 48 | 49 | #endif 50 | 51 | -------------------------------------------------------------------------------- /opm/simulators/utils/ParallelCommunication.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2021 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_PARALLELCOMMUNICATION_HEADER_INCLUDED 21 | #define OPM_PARALLELCOMMUNICATION_HEADER_INCLUDED 22 | 23 | #include 24 | #include 25 | 26 | namespace Opm { 27 | namespace Parallel { 28 | 29 | using MPIComm = typename Dune::MPIHelper::MPICommunicator; 30 | using Communication = Dune::Communication; 31 | 32 | } // namespace Parallel 33 | } // end namespace Opm 34 | 35 | #endif // OPM_PARALLELCOMMUNICATION_HEADER_INCLUDED 36 | -------------------------------------------------------------------------------- /opm/simulators/utils/compressPartition.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2023 Equinor ASA 3 | 4 | This file is part of the Open Porous Media Project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_UTIL_COMPRESS_PARTITION_HPP_INCLUDED 21 | #define OPM_UTIL_COMPRESS_PARTITION_HPP_INCLUDED 22 | 23 | #include 24 | #include 25 | 26 | namespace Opm { namespace util { 27 | std::pair, int> 28 | compressAndCountPartitionIDs(std::vector&& parts0); 29 | 30 | std::vector compressPartitionIDs(std::vector&& parts0); 31 | void compressPartitionIDs(std::vector& parts0); 32 | }} // namespace Opm::util 33 | 34 | #endif // OPM_UTIL_COMPRESS_PARTITION_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /opm/simulators/utils/gatherDeferredLogger.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019 SINTEF Digital, Mathematics and Cybernetics. 3 | Copyright 2019 Equinor. 4 | 5 | This file is part of the Open Porous Media project (OPM). 6 | 7 | OPM is free software: you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation, either version 3 of the License, or 10 | (at your option) any later version. 11 | 12 | OPM is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with OPM. If not, see . 19 | */ 20 | 21 | #ifndef OPM_GATHERDEFERREDLOGGER_HEADER_INCLUDED 22 | #define OPM_GATHERDEFERREDLOGGER_HEADER_INCLUDED 23 | 24 | #include 25 | 26 | namespace Opm 27 | { 28 | 29 | /// Create a global log combining local logs 30 | Opm::DeferredLogger gatherDeferredLogger(const Opm::DeferredLogger& local_deferredlogger, Parallel::Communication communicator); 31 | 32 | } // namespace Opm 33 | 34 | 35 | #endif // OPM_GATHERDEFERREDLOGGER_HEADER_INCLUDED 36 | -------------------------------------------------------------------------------- /opm/simulators/utils/phaseUsageFromDeck.hpp: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | Copyright 2012 SINTEF ICT, Applied Mathematics. 4 | 5 | This file is part of the Open Porous Media project (OPM). 6 | 7 | OPM is free software: you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation, either version 3 of the License, or 10 | (at your option) any later version. 11 | 12 | OPM is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with OPM. If not, see . 19 | */ 20 | 21 | #ifndef OPM_PHASEUSAGEFROMDECK_HEADER_INCLUDED 22 | #define OPM_PHASEUSAGEFROMDECK_HEADER_INCLUDED 23 | 24 | #include 25 | 26 | namespace Opm 27 | { 28 | class Deck; 29 | class EclipseState; 30 | class Phases; 31 | 32 | /// Determine the active phases 33 | PhaseUsage phaseUsage(const Phases& phases); 34 | 35 | /// Looks at presence of WATER, OIL and GAS keywords in state object 36 | /// to determine active phases. 37 | PhaseUsage phaseUsageFromDeck(const EclipseState& eclipseState); 38 | 39 | /// Looks at presence of WATER, OIL and GAS keywords in deck 40 | /// to determine active phases. 41 | PhaseUsage phaseUsageFromDeck(const Deck& deck); 42 | } 43 | 44 | #endif // OPM_PHASEUSAGEFROMDECK_HEADER_INCLUDED 45 | -------------------------------------------------------------------------------- /opm/simulators/wells/PerforationData.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019 SINTEF Digital, Mathematics and Cybernetics. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_PERFORATIONDATA_HEADER_INCLUDED 21 | #define OPM_PERFORATIONDATA_HEADER_INCLUDED 22 | 23 | #include 24 | 25 | namespace Opm { 26 | 27 | /// Static data associated with a well perforation. 28 | template 29 | struct PerforationData 30 | { 31 | int cell_index{}; 32 | Scalar connection_transmissibility_factor{}; 33 | Scalar connection_d_factor{}; 34 | int satnum_id{}; 35 | /// \brief The original index of the perforation in ECL Schedule 36 | std::size_t ecl_index{}; 37 | }; 38 | 39 | template 40 | struct PerforationRates 41 | { 42 | Scalar dis_gas = 0.0; 43 | Scalar dis_gas_in_water = 0.0; 44 | Scalar vap_oil = 0.0; 45 | Scalar vap_wat = 0.0; 46 | }; 47 | 48 | } // namespace Opm 49 | 50 | #endif // OPM_PERFORATIONDATA_HEADER_INCLUDED 51 | -------------------------------------------------------------------------------- /opm/simulators/wells/RuntimePerforation.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2025 Equinor ASA. 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | 20 | #ifndef OPM_RUNTIME_PERFORATION_HPP_INCLUDED 21 | #define OPM_RUNTIME_PERFORATION_HPP_INCLUDED 22 | 23 | namespace Opm { 24 | 25 | /// Simple model of a well connection created at runtime, possibly as a 26 | /// result of a geo-mechanical fracturing process. 27 | struct RuntimePerforation 28 | { 29 | /// Active cell index, on current rank, that is dynamically perforated 30 | /// by a well. 31 | int cell{}; 32 | 33 | /// Connection's transmissibility factor. 34 | double ctf{}; 35 | 36 | /// Depth at which the new connection is created. 37 | double depth{}; 38 | }; 39 | 40 | } // namespace Opm 41 | 42 | #endif // OPM_RUNTIME_PERFORATION_HPP_INCLUDED 43 | -------------------------------------------------------------------------------- /python/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | find_package(pybind11 2.2 CONFIG) 2 | 3 | if(NOT pybind11_FOUND) 4 | include(DownloadPyBind11) 5 | elseif(pybind11_VERSION VERSION_GREATER_EQUAL "2.3.0") 6 | if(CMAKE_VERSION VERSION_LESS 3.12) 7 | # SYSTEM is only support for pybind >= 2.3.0 and cmake <= 3.12.0 (Unfortunately querying the 8 | # version does not work. AT least we know the embedded one. 9 | set(PYBIND11_SYSTEM "SYSTEM") 10 | endif() 11 | endif() 12 | add_subdirectory( simulators ) 13 | -------------------------------------------------------------------------------- /python/Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile to generate PyPI packages. Needs to be run from the opm-common root folder 2 | # Example use: 3 | # sudo docker build -t manylinux2014_opm:built . -f python/Dockerfile 4 | 5 | FROM quay.io/pypa/manylinux_2_28_x86_64 AS stage1 6 | ARG version="master" 7 | ARG build_jobs=4 8 | ARG version_tag="" 9 | WORKDIR /tmp/opm 10 | RUN echo "Using version: $version" 11 | RUN echo "Using package version tag: $version_tag" 12 | RUN echo "Number of build jobs: $build_jobs" 13 | ADD . . 14 | RUN /bin/bash setup-docker-image.sh 15 | FROM stage1 AS stage2 16 | RUN /bin/bash build-deps.sh $build_jobs 17 | FROM stage2 AS stage3 18 | RUN /bin/bash generate-pypi-package.sh "$version" "$build_jobs" "$version_tag" 19 | 20 | FROM scratch AS export_stage 21 | COPY --from=stage3 /tmp/opm/wheelhouse . 22 | -------------------------------------------------------------------------------- /python/MANIFEST.in: -------------------------------------------------------------------------------- 1 | include opm/simulators/__init__.py 2 | include opm/simulators/*.so 3 | -------------------------------------------------------------------------------- /python/opm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | project(install_python_binding) 2 | 3 | cmake_minimum_required(VERSION 3.15) 4 | 5 | install(CODE "message(\"Dummy install\")") 6 | -------------------------------------------------------------------------------- /python/opm/simulators/__init__.py: -------------------------------------------------------------------------------- 1 | # Instead of having the pybind11 extension module, e.g. 2 | # simulators.cpython-310-x86_64-linux-gnu.so located 3 | # directly in the opm directory, we create a package (sub 4 | # directory) with the same name and place it there. 5 | # In this way we can do (if needed in the future) 6 | # 7 | # from opm.simulators import BlackOilSimulator, FoamSimulator, PurePythonUtils, ... 8 | # 9 | # where FoamSimulator and PurePythonUtils does not currently exists, 10 | # but could be possible future extensions.. 11 | # 12 | from .simulators import BlackOilSimulator 13 | -------------------------------------------------------------------------------- /python/pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires= [ 3 | "setuptools>=42", 4 | "scikit-build>=0.13", 5 | "cmake>=3.15", 6 | "ninja" 7 | ] 8 | -------------------------------------------------------------------------------- /python/requirements.txt: -------------------------------------------------------------------------------- 1 | six 2 | future 3 | decorator 4 | opm 5 | numpy 6 | -------------------------------------------------------------------------------- /python/setup-docker-image.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Script to be run on a manylinux2014 docker image to complete it for OPM usage. 4 | # i.e. docker run -i -t quay.io/pypa/manylinux2014_x86_64 < setup-docker-image.sh 5 | 6 | # A ready made Docker image is available at Dockerhub: 7 | # docker run -i -t lindkvis/manylinux2014_opm:latest 8 | 9 | dnf install -y almalinux-release-devel 10 | 11 | dnf install -y blas-static lapack-static suitesparse-static ninja-build 12 | -------------------------------------------------------------------------------- /python/setup.py.in: -------------------------------------------------------------------------------- 1 | from skbuild import setup 2 | 3 | import os 4 | 5 | setupdir = os.path.dirname(__file__) 6 | if setupdir != '': 7 | os.chdir( setupdir ) 8 | 9 | with open("README.md", "r") as fh: 10 | long_description = fh.read() 11 | 12 | with open("requirements.txt", "r") as fh: 13 | requires = [line.rstrip() for line in fh] 14 | 15 | setup( 16 | name='opm-simulators', 17 | version = '@opm-simulators_VERSION@' + '@opm-simulators_PYTHON_PACKAGE_VERSION@', 18 | url='http://www.opm-project.org', 19 | author='The Open Porous Media Project', 20 | author_email='opmuser@gmail.com', 21 | description='OPM-Simulators Python bindings', 22 | long_description=long_description, 23 | long_description_content_type="text/markdown", 24 | packages=[ 25 | 'opm', 26 | 'opm.simulators' 27 | ], 28 | package_data={'opm' : ['$']}, 29 | include_package_data=True, 30 | license='Open Source', 31 | test_suite='tests', 32 | setup_requires=["pytest-runner", 'setuptools_scm'], 33 | install_requires=requires, 34 | python_requires='>=3.6', 35 | classifiers=[ 36 | "Programming Language :: Python :: 3", 37 | "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)", 38 | ], 39 | ) 40 | -------------------------------------------------------------------------------- /python/simulators/Pybind11Exporter.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void Opm::Pybind::export_all(py::module& m) { 5 | export_PyBlackOilSimulator(m); 6 | } 7 | 8 | PYBIND11_MODULE(simulators, m) 9 | { 10 | Opm::Pybind::export_all(m); 11 | } 12 | -------------------------------------------------------------------------------- /python/test/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/OPM/opm-simulators/ee7b9ed80c61800889c01a054cb56d291dfdd763/python/test/__init__.py -------------------------------------------------------------------------------- /python/test/pytest_common.py: -------------------------------------------------------------------------------- 1 | import os 2 | from contextlib import contextmanager 3 | 4 | @contextmanager 5 | def pushd(path): 6 | cwd = os.getcwd() 7 | if not os.path.isdir(path): 8 | os.makedirs(path) 9 | os.chdir(path) 10 | yield 11 | os.chdir(cwd) 12 | 13 | -------------------------------------------------------------------------------- /python/test/test_mpi.py: -------------------------------------------------------------------------------- 1 | import os 2 | import unittest 3 | from pathlib import Path 4 | from opm.simulators import BlackOilSimulator 5 | from .pytest_common import pushd 6 | 7 | class TestBasic(unittest.TestCase): 8 | @classmethod 9 | def setUpClass(cls): 10 | # NOTE: See comment in test_basic.py for the reason why we are 11 | # only using a single test_all() function instead of splitting 12 | # it up in multiple test functions 13 | test_dir = Path(os.path.dirname(__file__)) 14 | cls.data_dir = test_dir.parent.joinpath("test_data/SPE1CASE1a") 15 | 16 | # IMPORTANT: Tests are run alphabetically, so we need to make sure that 17 | # the the first test calls MPI_Init(), therefore the name of the tests 18 | # have a numeric label like "01" in test_01_mpi_init to ensure that they 19 | # are run in a given order. 20 | def test_01_mpi_init(self): 21 | with pushd(self.data_dir): 22 | sim = BlackOilSimulator("SPE1CASE1.DATA") 23 | sim.setup_mpi(init=True, finalize=False) 24 | sim.step_init() # This will create the OPM::Main() object which will call MPI_Init() 25 | assert True 26 | 27 | def test_02_mpi_no_init(self): 28 | with pushd(self.data_dir): 29 | sim = BlackOilSimulator("SPE1CASE1.DATA") 30 | sim.setup_mpi(init=False, finalize=True) 31 | sim.step_init() # This will create the OPM::Main() object which will not call MPI_Init() 32 | # That this test runs shows that the simulator does not call 33 | # MPI_Init() a second time 34 | assert True 35 | -------------------------------------------------------------------------------- /python/test/test_throw.py: -------------------------------------------------------------------------------- 1 | import os 2 | import unittest 3 | from pathlib import Path 4 | from opm.simulators import BlackOilSimulator 5 | from .pytest_common import pushd 6 | 7 | class TestBasic(unittest.TestCase): 8 | @classmethod 9 | def setUpClass(cls): 10 | # NOTE: See comment in test_basic.py for the reason why we are 11 | # only using a single test_all() function instead of splitting 12 | # it up in multiple test functions 13 | test_dir = Path(os.path.dirname(__file__)) 14 | cls.data_dir = test_dir.parent.joinpath("test_data/SPE1CASE1a") 15 | 16 | def test_all(self): 17 | with pushd(self.data_dir): 18 | sim = BlackOilSimulator("SPE1CASE1.DATA") 19 | # NOTE: The following call should throw an exception since the simulation 20 | # has not been initialized 21 | with self.assertRaises(RuntimeError): 22 | sim.get_dt() 23 | 24 | -------------------------------------------------------------------------------- /tests/TESTTIMER.DATA: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | RUNSPEC 8 | 9 | START 10 | 26 'MAR' 2014 / 11 | 12 | SCHEDULE 13 | 14 | TSTEP 15 | 1.0 2*5.0 16 | / 17 | 18 | TSTEP 19 | 7*10.0 14*25.0 20 | / 21 | 22 | TSTEP 23 | 19.0 24 | / 25 | 26 | TSTEP 27 | 18*13.0 28 | / 29 | 30 | TSTEP 31 | 17*10.0 32 | / 33 | 34 | TSTEP 35 | 13.0 36 | / 37 | 38 | TSTEP 39 | 18.0 40 | / 41 | 42 | TSTEP 43 | 11.0 44 | / 45 | 46 | TSTEP 47 | 17*5.0 48 | / 49 | 50 | TSTEP 51 | 19*6.0 52 | / 53 | 54 | TSTEP 55 | 21*5.0 / 56 | 57 | TSTEP 58 | 5*365000 / 59 | 60 | END == 61 | -------------------------------------------------------------------------------- /tests/TESTWELLMODEL.DATA: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | RUNSPEC 8 | 9 | DIMENS 10 | 5 5 4 / 11 | OIL 12 | GAS 13 | WATER 14 | 15 | GRID 16 | 17 | DX 18 | 100*100. / 19 | 20 | DY 21 | 100*50. / 22 | 23 | DZ 24 | 100*10. / 25 | 26 | TOPS 27 | 25*2500 / 28 | 29 | PORO 30 | 100*0.3 / 31 | 32 | PERMX 33 | 100*10. / 34 | 35 | PERMY 36 | 100*20. / 37 | 38 | PERMZ 39 | 100*1. / 40 | 41 | SCHEDULE 42 | 43 | WELSPECS 44 | 'PROD1' 'P' 5 5 2525 'OIL' / 45 | 'INJE1' 'I' 1 1 2505 'GAS' / 46 | / 47 | 48 | COMPDAT 49 | 'PROD1' 5 5 3 4 'OPEN' 2* 0.15 / 50 | 'INJE1' 1 1 1 4 'OPEN' 2* 0.15 / 51 | / 52 | 53 | WCONINJE 54 | 'INJE1' 'WATER' 'OPEN' 'RATE' 1000. / 55 | / 56 | 57 | WCONPROD 58 | 'PROD1' 'OPEN' 'GRAT' 2* 50000. / 59 | / 60 | 61 | TSTEP 62 | 10 / 63 | 64 | END 65 | -------------------------------------------------------------------------------- /tests/data/co2injection.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 60 40 % second corner 6 | 24 16 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/cuvette_11x4.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1.5 0.74 % second corner 6 | 11 4 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/cuvette_44x24.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1.5 0.74 % second corner 6 | 44 24 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | #GridParameter 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/groundwater_1d.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 % first corner 5 | 1 % second corner 6 | 10 % cells in x direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | #GridParameter 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/groundwater_2d.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1 1 % second corner 6 | 10 10 % cells in x and y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/groundwater_3d.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 0 % first corner 5 | 1 1 1 % second corner 6 | 20 20 20 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/infiltration_250x20.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 500 10 % second corner 6 | 250 20 % cells in x and y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/infiltration_50x3.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 500 10 % second corner 6 | 50 3 % cells in x and y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/obstacle_24x16.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 60 40 % second corner 6 | 24 16 % 24 cells in x and 16 in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/obstacle_48x32.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 60 40 % second corner 6 | 48 32 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/outflow.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | Interval 3 | 0 0 % first corner 4 | 1 1 % second corner 5 | 20 20 % number of cells in x and y direction 6 | # 7 | 8 | GridParameter 9 | overlap 1 10 | closure green 11 | # 12 | 13 | BOUNDARYDOMAIN 14 | default 1 % all boundaries have id 1 15 | # 16 | 17 | # 18 | -------------------------------------------------------------------------------- /tests/data/reservoir.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 6000 20 % second corner 6 | 100 10 % 100 cells in x and 10 in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/richardslens_24x16.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 6 4 % second corner 6 | 24 16 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/richardslens_48x32.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 6 4 % second corner 6 | 48 32 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | # 18 | -------------------------------------------------------------------------------- /tests/data/richardslens_96x64.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 6 4 % second corner 6 | 96 64 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/test_stokes.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1.0 1.0 % second corner 6 | 32 32 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/test_stokes2c.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1.0 1.0 % second corner 6 | 32 32 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | copies none 13 | heapsize 500 14 | # 15 | 16 | BOUNDARYDOMAIN 17 | default 1 % all boundaries have id 1 18 | # 19 | 20 | # 21 | -------------------------------------------------------------------------------- /tests/data/test_stokes2cni.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 1.0 1.0 % second corner 6 | 18 18 % cells in x and in y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | closure green 12 | # 13 | 14 | BOUNDARYDOMAIN 15 | default 1 % all boundaries have id 1 16 | # 17 | 18 | # 19 | -------------------------------------------------------------------------------- /tests/data/waterair.dgf: -------------------------------------------------------------------------------- 1 | DGF 2 | 3 | Interval 4 | 0 0 % first corner 5 | 40 40 % second corner 6 | 8 8 % cells in x and y direction 7 | # 8 | 9 | GridParameter 10 | overlap 1 11 | periodic 12 | closure green 13 | # 14 | 15 | BOUNDARYDOMAIN 16 | default 1 % all boundaries have id 1 17 | # 18 | 19 | # 20 | -------------------------------------------------------------------------------- /tests/deadfluids.DATA: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | -- Most of the following sections are not actually needed by the test, 8 | -- but it is required by the Eclipse reference manual that they are 9 | -- present. Also, the higher level opm-parser classes 10 | -- (i.e. Opm::EclipseState et al.) assume that they are present. 11 | 12 | ------------------------------------- 13 | RUNSPEC 14 | 15 | WATER 16 | OIL 17 | GAS 18 | 19 | DIMENS 20 | 3 3 3 / 21 | 22 | TABDIMS 23 | 1 1 40 20 1 20 / 24 | 25 | EQLDIMS 26 | -- NTEQUL 27 | 1 / 28 | 29 | ------------------------------------- 30 | GRID 31 | 32 | -- Opm::EclipseState assumes that _some_ grid gets defined, so let's 33 | -- specify a fake one... 34 | 35 | DXV 36 | 1 2 3 / 37 | 38 | DYV 39 | 4 5 6 / 40 | 41 | DZV 42 | 7 8 9 / 43 | 44 | DEPTHZ 45 | 16*123.456 / 46 | 47 | ------------------------------------- 48 | PROPS 49 | 50 | PVDO 51 | 100 1.0 1.0 52 | 200 0.5 1.0 53 | / 54 | 55 | PVDG 56 | 100 0.05 0.1 57 | 200 0.02 0.2 58 | / 59 | 60 | PVTW 61 | 1.0 1.0 4.0E-5 0.96 0.0 62 | / 63 | 64 | SWOF 65 | 0 0 1 0 66 | 1 1 0 0 67 | / 68 | 69 | SGOF 70 | 0 0 1 0 71 | 1 1 0 0 72 | / 73 | 74 | DENSITY 75 | 700 1000 10 76 | / 77 | 78 | ------------------------------------- 79 | SOLUTION 80 | 81 | EQUIL 82 | 5 150 5 0 2 0 1* 1* 0 83 | / 84 | 85 | ------------------------------------- 86 | SCHEDULE 87 | -- empty section 88 | -------------------------------------------------------------------------------- /tests/equil_liveoil_grid.DATA: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | WATER 8 | OIL 9 | GAS 10 | DISGAS 11 | 12 | DIMENS 13 | 1 1 20 14 | / 15 | 16 | DXV 17 | 1.0 18 | / 19 | 20 | DYV 21 | 1.0 22 | / 23 | 24 | DZV 25 | 20*5.0 26 | / 27 | 28 | TOPS 29 | 4*0.0 30 | / 31 | 32 | 33 | PVTO 34 | -- Rs Pbub Bo Vo 35 | 0 1. 1.0000 1.20 / 36 | 100 40. 1.0120 1.17 / 37 | 200 80. 1.0255 1.14 / 38 | 300 120. 1.0380 1.11 / 39 | 400 160. 1.0510 1.08 / 40 | 500 200. 1.0630 1.06 / 41 | 600 240. 1.0750 1.03 / 42 | 700 280. 1.0870 1.00 / 43 | 800 320. 1.0985 .98 / 44 | 900 360. 1.1100 .95 / 45 | 1000 400. 1.1200 .94 46 | 500. 1.1189 .94 / 47 | / 48 | 49 | 50 | PVDG 51 | 100 0.010 0.1 52 | 200 0.005 0.2 53 | / 54 | 55 | SWOF 56 | 0.2 0 1 0.9 57 | 1 1 0 0.1 58 | / 59 | 60 | SGOF 61 | 0 0 1 0.2 62 | 0.8 1 0 0.5 63 | / 64 | 65 | DENSITY 66 | 700 1000 1 67 | / 68 | 69 | EQUIL 70 | 45 150 50 0.25 45 0.35 71 | / 72 | -------------------------------------------------------------------------------- /tests/getprop.awk: -------------------------------------------------------------------------------- 1 | # Extract test property values from CTestTestfile.cmake 2 | # 3 | # User must initialise two awk variables, typically through the "-v" option, 4 | # when invoking this script 5 | # 6 | # search: Search pattern. Typically a string such as 7 | # set_tests_properties($test_name 8 | # 9 | # prop: Property name, for instance DIRNAME or SIMULATOR. 10 | # 11 | # Property value will be printed to the standard output stream. 12 | # 13 | # The script assumes that $1 on candidate lines is suitable for matching 14 | # against 'search', and that $2 of the matching lines is the word 15 | # 'PROPERTIES'. 16 | # 17 | # Example: 18 | # # Get value of SIMULATOR property in test named by shell variable 19 | # # $failed_test and assign this to shell variable 'binary'. 20 | # 21 | # binary=$(awk -v search="set_tests_properties\\\($failed_test" \ 22 | # -v prop="SIMULATOR" \ 23 | # -f getprop.awk \ 24 | # CTestTestfile.cmake) 25 | 26 | $1 ~ search { 27 | for (i = 3; i <= NF; ++i) { 28 | if ($i == prop) { 29 | val = $(i + 1) 30 | gsub(/"/, "", val) 31 | print val 32 | exit 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /tests/gpuistl/test_cublas_handle.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include "opm/simulators/linalg/gpuistl/detail/cublas_safe_call.hpp" 20 | #include 21 | 22 | #define BOOST_TEST_MODULE TestCublasHandle 23 | 24 | #include 25 | #include 26 | #include 27 | 28 | BOOST_AUTO_TEST_CASE(TestGetCublasVersion) 29 | { 30 | #if USE_HIP 31 | // As of April 2024 it does not seem that hip has implemented the function 32 | // that checks the version of blas programatically. Let the test pass for now. 33 | BOOST_CHECK(true); 34 | #else 35 | auto& cublasHandle = ::Opm::gpuistl::detail::CuBlasHandle::getInstance(); 36 | int cuBlasVersion = -1; 37 | OPM_CUBLAS_SAFE_CALL(cublasGetVersion(cublasHandle.get(), &cuBlasVersion)); 38 | 39 | BOOST_CHECK_LT(0, cuBlasVersion); 40 | #endif 41 | } 42 | -------------------------------------------------------------------------------- /tests/gpuistl/test_cuda_check_last_error.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include 20 | 21 | #define BOOST_TEST_MODULE TestCudaCheckLastError 22 | 23 | #include 24 | #include 25 | 26 | 27 | BOOST_AUTO_TEST_CASE(TestNoThrowLastError) 28 | { 29 | BOOST_CHECK_NO_THROW(OPM_CUDA_CHECK_LAST_ERROR;); 30 | BOOST_CHECK_NO_THROW(OPM_CUDA_CHECK_LAST_ERROR_IF_DEBUG;); 31 | } 32 | 33 | 34 | BOOST_AUTO_TEST_CASE(TestNoThrowDeviceSynchronize) 35 | { 36 | BOOST_CHECK_NO_THROW(OPM_CUDA_CHECK_DEVICE_SYNCHRONIZE;); 37 | BOOST_CHECK_NO_THROW(OPM_CUDA_CHECK_DEVICE_SYNCHRONIZE_IF_DEBUG;); 38 | } 39 | -------------------------------------------------------------------------------- /tests/gpuistl/test_cusparse_handle.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2022-2023 SINTEF AS 3 | 4 | This file is part of the Open Porous Media project (OPM). 5 | 6 | OPM is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | OPM is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with OPM. If not, see . 18 | */ 19 | #include 20 | 21 | #define BOOST_TEST_MODULE TestSparseHandle 22 | 23 | #include 24 | #include 25 | #include 26 | 27 | BOOST_AUTO_TEST_CASE(TestGetSparseVersion) 28 | { 29 | auto& cuSparseHandle = ::Opm::gpuistl::detail::CuSparseHandle::getInstance(); 30 | int cuSparseVersion = -1; 31 | OPM_CUSPARSE_SAFE_CALL(cusparseGetVersion(cuSparseHandle.get(), &cuSparseVersion)); 32 | BOOST_CHECK_LT(0, cuSparseVersion); 33 | } 34 | -------------------------------------------------------------------------------- /tests/include/rock.inc: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | -- Copyright (C) 2020 Equinor 7 | 8 | -- This file is one of the include files for model2 9 | 10 | 11 | -- ROCK COMPRESSIBILITY 12 | -- 13 | -- REF.PRES. COMPR. 14 | ROCK 15 | 277.0 4.22425e-05 / 16 | -------------------------------------------------------------------------------- /tests/include/summary_rc.inc: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | -- Copyright (C) 2025 Equinor 7 | 8 | 9 | TCPU 10 | 11 | TIMESTEP 12 | 13 | FOPR 14 | 15 | FGPR 16 | 17 | FGIR 18 | 19 | 20 | FGOR 21 | 22 | FWCT 23 | 24 | GOPR 25 | / 26 | 27 | GGPR 28 | / 29 | 30 | GGIR 31 | / 32 | 33 | GGOR 34 | / 35 | 36 | WGIR 37 | / 38 | 39 | WBHP 40 | / 41 | 42 | WOPR 43 | / 44 | 45 | ROIP 46 | / 47 | 48 | FOIP 49 | 50 | FPR 51 | 52 | FOPT 53 | 54 | GPR 55 | / 56 | 57 | GVPR 58 | / 59 | 60 | GVIR 61 | / 62 | 63 | GWIR 64 | / 65 | 66 | FVIR 67 | / 68 | 69 | GGIR 70 | / 71 | 72 | FGIR 73 | / 74 | 75 | FUGINJT 76 | 77 | FGSR 78 | 79 | GOPGR 80 | / 81 | -------------------------------------------------------------------------------- /tests/make_failure_report.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Generates a summary plot comparison for each failed test case 4 | 5 | OPM_TESTS_ROOT=$1 6 | BUILD_DIR=$2 7 | RESULT_DIR=$3 8 | SOURCE_DIR=`dirname "$0"` 9 | 10 | FAILED_TESTS=`cat $BUILD_DIR/Testing/Temporary/LastTestsFailed*.log` 11 | 12 | mkdir -p $BUILD_DIR/failure_report 13 | cd $BUILD_DIR/failure_report 14 | rm -f * 15 | 16 | for failed_test in $FAILED_TESTS 17 | do 18 | grep -q -E "compareECLFiles" <<< $failed_test 19 | test $? -ne 0 && continue 20 | 21 | failed_test=`echo $failed_test | sed -e 's/.*://g' -e 's/\+/./g'` 22 | # Extract test properties 23 | binary=$(awk -v search="set_tests_properties\\\($failed_test\$" -v prop="SIMULATOR" -f ${SOURCE_DIR}/getprop.awk $RESULT_DIR/CTestTestfile.cmake) 24 | dir_name=$(awk -v search="set_tests_properties\\\($failed_test\$" -v prop="DIRNAME" -f ${SOURCE_DIR}/getprop.awk $RESULT_DIR/CTestTestfile.cmake) 25 | file_name=$(awk -v search="set_tests_properties\\\($failed_test\$" -v prop="FILENAME" -f ${SOURCE_DIR}/getprop.awk $RESULT_DIR/CTestTestfile.cmake) 26 | test_name=$(awk -v search="set_tests_properties\\\($failed_test\$" -v prop="TESTNAME" -f ${SOURCE_DIR}/getprop.awk $RESULT_DIR/CTestTestfile.cmake) 27 | echo "Processing ${test_name}" 28 | $SOURCE_DIR/plot_well_comparison.py -r $OPM_TESTS_ROOT/$dir_name/opm-simulation-reference/$binary/$file_name -s $RESULT_DIR/tests/results/$binary+$test_name/$file_name -c $test_name -o plot 29 | done 30 | 31 | if test -n "$FAILED_TESTS" 32 | then 33 | $SOURCE_DIR/plot_well_comparison.py -o rename 34 | fi 35 | -------------------------------------------------------------------------------- /tests/matr33.txt: -------------------------------------------------------------------------------- 1 | %%MatrixMarket matrix coordinate real general 2 | % ISTL_STRUCT blocked 3 3 3 | 9 9 63 4 | 1 1 1.63148e-07 5 | 1 2 0.126774 6 | 1 3 -6.09774e-05 7 | 2 1 4.64465e-10 8 | 2 2 -0.0987407 9 | 2 3 -5.86038e-05 10 | 3 1 5.66966e-08 11 | 3 2 -12.0531 12 | 3 3 0.0462478 13 | 1 4 -8.84841e-11 14 | 1 5 -5.64705e-05 15 | 1 6 0 16 | 2 4 -3.93176e-10 17 | 2 5 0 18 | 2 6 0 19 | 3 4 -4.79944e-08 20 | 3 5 0 21 | 3 6 0 22 | 4 1 -8.89921e-11 23 | 4 2 -0.00786145 24 | 4 3 0 25 | 5 1 -3.53139e-10 26 | 5 2 0.0283977 27 | 5 3 -3.79289e-05 28 | 6 1 -4.31072e-08 29 | 6 2 3.46646 30 | 6 3 -0.00944335 31 | 4 4 1.20862e-10 32 | 4 5 0.0829656 33 | 4 6 0 34 | 5 4 7.40377e-10 35 | 5 5 -0.0929483 36 | 5 6 -0.0967963 37 | 6 4 4.64141e-07 38 | 6 5 -9.10276 39 | 6 6 16.3772 40 | 4 7 -2.168e-11 41 | 4 8 -1.38362e-05 42 | 4 9 0 43 | 5 7 -7.8331e-10 44 | 5 8 0 45 | 5 9 0 46 | 6 7 -1.20687e-07 47 | 6 8 0 48 | 6 9 0 49 | 7 4 -2.17548e-11 50 | 7 5 -0.00183118 51 | 7 6 0 52 | 8 4 -8.00212e-10 53 | 8 5 0.0276779 54 | 8 6 0.0320899 55 | 9 4 -1.56667e-07 56 | 9 5 2.7106 57 | 9 6 -7.32919 58 | 7 7 4.43266e-09 59 | 7 8 0.0744616 60 | 7 9 0 61 | 8 7 1.59375e-07 62 | 8 8 -0.0899451 63 | 8 9 -0.0940009 64 | 9 7 2.86852e-05 65 | 9 8 -5.63337 66 | 9 9 13.3423 67 | -------------------------------------------------------------------------------- /tests/matr33rep.txt: -------------------------------------------------------------------------------- 1 | %%MatrixMarket matrix coordinate real general 2 | % ISTL_STRUCT blocked 3 3 3 | 9 9 81 4 | 1 1 1 5 | 2 1 -1 6 | 3 1 -1 7 | 4 1 -1 8 | 5 1 -1 9 | 6 1 -1 10 | 7 1 -1 11 | 8 1 -1 12 | 9 1 -1 13 | 1 2 -1 14 | 2 2 1 15 | 3 2 -1 16 | 4 2 -1 17 | 5 2 -1 18 | 6 2 -1 19 | 7 2 -1 20 | 8 2 -1 21 | 9 2 -1 22 | 1 3 -1 23 | 2 3 -1 24 | 3 3 1 25 | 4 3 -1 26 | 5 3 -1 27 | 6 3 -1 28 | 7 3 -1 29 | 8 3 -1 30 | 9 3 -1 31 | 1 4 -1 32 | 2 4 -1 33 | 3 4 -1 34 | 4 4 1 35 | 5 4 -1 36 | 6 4 -1 37 | 7 4 -1 38 | 8 4 -1 39 | 9 4 -1 40 | 1 5 -1 41 | 2 5 -1 42 | 3 5 -1 43 | 4 5 -1 44 | 5 5 1 45 | 6 5 -1 46 | 7 5 -1 47 | 8 5 -1 48 | 9 5 -1 49 | 1 6 -1 50 | 2 6 -1 51 | 3 6 -1 52 | 4 6 -1 53 | 5 6 -1 54 | 6 6 1 55 | 7 6 -1 56 | 8 6 -1 57 | 9 6 -1 58 | 1 7 -1 59 | 2 7 -1 60 | 3 7 -1 61 | 4 7 -1 62 | 5 7 -1 63 | 6 7 -1 64 | 7 7 1 65 | 8 7 -1 66 | 9 7 -1 67 | 1 8 -1 68 | 2 8 -1 69 | 3 8 -1 70 | 4 8 -1 71 | 5 8 -1 72 | 6 8 -1 73 | 7 8 -1 74 | 8 8 1 75 | 9 8 -1 76 | 1 9 -1 77 | 2 9 -1 78 | 3 9 -1 79 | 4 9 -1 80 | 5 9 -1 81 | 6 9 -1 82 | 7 9 -1 83 | 8 9 -1 84 | 9 9 1 85 | -------------------------------------------------------------------------------- /tests/options_flexiblesolver.json: -------------------------------------------------------------------------------- 1 | { 2 | "tol": "0.5", 3 | "maxiter": "20", 4 | "preconditioner": { 5 | "type": "cpr", 6 | "finesmoother": { 7 | "type": "ILU0", 8 | "relaxation": "1.0" 9 | }, 10 | "coarsesolver": { 11 | "tol": "0.5", 12 | "maxiter": "20", 13 | "preconditioner": { 14 | "type": "amg", 15 | "maxlevel": "5", 16 | "coarsenTarget": "1000", 17 | "smoother": "ILU0", 18 | "alpha": "0.2", 19 | "beta": "0.0001", 20 | "verbosity": "0", 21 | "iterations": "1", 22 | "relaxation": "1" 23 | }, 24 | "verbosity": "0", 25 | "solver": "bicgstab" 26 | }, 27 | "verbosity": "11", 28 | "weights_filename" : "weight_cpr.txt" 29 | }, 30 | "verbosity": "10", 31 | "solver": "bicgstab" 32 | } 33 | -------------------------------------------------------------------------------- /tests/options_flexiblesolver_simple.json: -------------------------------------------------------------------------------- 1 | { 2 | "tol": "1e-12", 3 | "maxiter": "200", 4 | "verbosity": "0", 5 | "solver": "bicgstab", 6 | "preconditioner": { 7 | "type": "nothing" 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /tests/parametersystem.ini: -------------------------------------------------------------------------------- 1 | SimpleParamBool=true 2 | SimpleParamFloat=3.0 3 | SimpleParamString=bar 4 | -------------------------------------------------------------------------------- /tests/rhs3.txt: -------------------------------------------------------------------------------- 1 | %%MatrixMarket matrix array real general 2 | % ISTL_STRUCT blocked 3 1 3 | 9 1 4 | -4.48332e-07 5 | 3.53746e-07 6 | 4.31812e-05 7 | 1.48051e-07 8 | -5.76325e-07 9 | -0.000243496 10 | -3.81652e-08 11 | 1.21761e-06 12 | -9.97615e-05 13 | -------------------------------------------------------------------------------- /tests/rhs3rep.txt: -------------------------------------------------------------------------------- 1 | %%MatrixMarket matrix array real general 2 | % ISTL_STRUCT blocked 3 1 3 | 9 1 4 | -1 5 | -1 6 | -1 7 | -3 8 | -3 9 | -3 10 | -3 11 | -3 12 | -3 13 | -------------------------------------------------------------------------------- /tests/run-parallel-unitTest.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # This executes a unit test in parallel. 3 | 4 | if test $# -eq 0 5 | then 6 | echo -e "Usage:\t$0 -- [additional simulator options]" 7 | echo -e "\tMandatory options:" 8 | echo -e "\t\t -n Number of MPI Processes to use" 9 | echo -e "\t\t -b Path to simulator binary" 10 | echo -e "\t\t -e Simulator binary to use" 11 | exit 1 12 | fi 13 | 14 | OPTIND=1 15 | while getopts "n:b:e:" OPT 16 | do 17 | case "${OPT}" in 18 | b) BDIR=${OPTARG} ;; 19 | e) EXE_NAME=${OPTARG} ;; 20 | n) NP=${OPTARG} ;; 21 | esac 22 | done 23 | shift $(($OPTIND-1)) 24 | TEST_ARGS="$@" 25 | 26 | mpirun -np $NP $BDIR/bin/${EXE_NAME} ${TEST_ARGS} 27 | -------------------------------------------------------------------------------- /tests/run-test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # This runs a simulator and optionally a post command in result directory. 4 | 5 | if test $# -eq 0 6 | then 7 | echo -e "Usage:\t$0 -- [additional simulator options]" 8 | echo -e "\tMandatory options:" 9 | echo -e "\t\t -i Path to read deck from" 10 | echo -e "\t\t -r Path to store results in" 11 | echo -e "\t\t -b Path to simulator binary" 12 | echo -e "\t\t -f Deck file name" 13 | echo -e "\t\t -e Simulator binary to use" 14 | echo -e "\tOptional options:" 15 | echo -e "\t\t -n Number of MPI processes to use" 16 | echo -e "\t\t -p Post-command to execute" 17 | exit 1 18 | fi 19 | 20 | OPTIND=1 21 | MPI_PROCS=1 22 | while getopts "i:r:b:f:e:n:p:" OPT 23 | do 24 | case "${OPT}" in 25 | i) INPUT_DATA_PATH=${OPTARG} ;; 26 | r) RESULT_PATH=${OPTARG} ;; 27 | b) BINPATH=${OPTARG} ;; 28 | f) FILENAME=${OPTARG} ;; 29 | e) EXE_NAME=${OPTARG} ;; 30 | n) MPI_PROCS=${OPTARG} ;; 31 | p) POST_COMMAND=${OPTARG} ;; 32 | esac 33 | done 34 | shift $(($OPTIND-1)) 35 | TEST_ARGS="$@" 36 | 37 | mkdir -p ${RESULT_PATH} 38 | if (( ${MPI_PROCS} > 1)) 39 | then 40 | mpirun -np ${MPI_PROCS} ${BINPATH}/${EXE_NAME} ${TEST_ARGS} --output-dir=${RESULT_PATH} "${INPUT_DATA_PATH}/${FILENAME}.DATA" 41 | else 42 | ${BINPATH}/${EXE_NAME} ${TEST_ARGS} --output-dir=${RESULT_PATH} "${INPUT_DATA_PATH}/${FILENAME}.DATA" 43 | fi 44 | test $? -eq 0 || exit 1 45 | 46 | if test -n "${POST_COMMAND}" 47 | then 48 | cd $RESULT_PATH 49 | ${POST_COMMAND} 50 | fi 51 | -------------------------------------------------------------------------------- /tests/test10.partition: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | 1 4 | 1 5 | 2 6 | 2 7 | 1 8 | 1 9 | 0 10 | 0 11 | -------------------------------------------------------------------------------- /tests/testFluid.DATA: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | OIL 8 | WATER 9 | GAS 10 | 11 | FIELD 12 | 13 | PVTO 14 | -- Rs Pbub Bo Vo 15 | .0 14.7 1.0000 1.20 / 16 | .165 400. 1.0120 1.17 / 17 | .335 800. 1.0255 1.14 / 18 | .500 1200. 1.0380 1.11 / 19 | .665 1600. 1.0510 1.08 / 20 | .828 2000. 1.0630 1.06 / 21 | .985 2400. 1.0750 1.03 / 22 | 1.130 2800. 1.0870 1.00 / 23 | 1.270 3200. 1.0985 .98 / 24 | 1.390 3600. 1.1100 .95 / 25 | 1.500 4000. 1.1200 .94 26 | 5000. 1.1189 .94 / 27 | / 28 | 29 | PVDG 30 | -- Pg Bg Vg 31 | 14.7 178.08 .0125 32 | 400. 5.4777 .0130 33 | 800. 2.7392 .0135 34 | 1200. 1.8198 .0140 35 | 1600. 1.3648 .0145 36 | 2000. 1.0957 .0150 37 | 2400. 0.9099 .0155 38 | 2800. 0.7799 .0160 39 | 3200. 0.6871 .0165 40 | 3600. 0.6035 .0170 41 | 4000. 0.5432 .0175 / 42 | 43 | PVTW 44 | --Depth Bw Comp Vw Cv 45 | 3600. 1.0034 1.0E-6 0.96 0.0 / 46 | 47 | 48 | DENSITY 49 | -- Oil Water Gas 50 | 44.98 63.01 0.0702 / 51 | -------------------------------------------------------------------------------- /tests/wells_manager_data_wellSTOP.data: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | RUNSPEC 8 | 9 | OIL 10 | GAS 11 | WATER 12 | 13 | 14 | DIMENS 15 | 10 10 5 / 16 | 17 | GRID 18 | 19 | DXV 20 | 10*1000.0 / 21 | 22 | DYV 23 | 10*1000.0 / 24 | 25 | DZV 26 | 10.0 20.0 30.0 10.0 5.0 / 27 | 28 | TOPS 29 | 100*10 / 30 | 31 | PERMX 32 | 500*0.25 / 33 | 34 | COPY 35 | PERMX PERMY / 36 | PERMX PERMZ / 37 | / 38 | 39 | PORO 40 | 500*0.15 / 41 | 42 | SCHEDULE 43 | 44 | WELSPECS 45 | 'INJ1' 'G' 1 1 8335 'GAS' / 46 | 'PROD1' 'G' 10 10 8400 'OIL' / 47 | 'STOP' 'G' 5 5 8400 'OIL' / 48 | / 49 | 50 | COMPDAT 51 | 'INJ1' 1 1 1 1 'OPEN' 1 10.6092 0.5 / 52 | 'PROD1' 10 3 3 3 'OPEN' 0 10.6092 0.5 / 53 | 'STOP' 5 3 1 3 'OPEN' 0 10.6092 0.5 / 54 | / 55 | 56 | WCONHIST 57 | 'STOP' 'STOP' 'GRAT' 0 0 0 / 58 | / 59 | 60 | WCONPROD 61 | 'PROD1' 'OPEN' 'ORAT' 20000 4* 1000 / 62 | / 63 | 64 | WCONINJE 65 | 'INJ1' 'GAS' 'OPEN' 'RATE' 100 200 400 / 66 | / 67 | 68 | 69 | WELOPEN 70 | 'INJ1' 'STOP' 5* / 71 | / 72 | 73 | TSTEP 74 | 10 / 75 | 76 | END 77 | -------------------------------------------------------------------------------- /tests/wells_stopped.data: -------------------------------------------------------------------------------- 1 | -- This reservoir simulation deck is made available under the Open Database 2 | -- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in 3 | -- individual contents of the database are licensed under the Database Contents 4 | -- License: http://opendatacommons.org/licenses/dbcl/1.0/ 5 | 6 | 7 | RUNSPEC 8 | 9 | OIL 10 | GAS 11 | WATER 12 | 13 | 14 | DIMENS 15 | 10 10 1 / 16 | 17 | GRID 18 | 19 | DXV 20 | 10*1000.0 21 | / 22 | 23 | DYV 24 | 10*1000.0 25 | / 26 | 27 | DZ 28 | 100*20.0 29 | / 30 | 31 | TOPS 32 | 100*10 33 | / 34 | 35 | PERMX 36 | 100*1.0 / 37 | 38 | PORO 39 | 100*0.15 / 40 | 41 | COPY 42 | PERMX PERMY / 43 | PERMX PERMZ / 44 | / 45 | SCHEDULE 46 | 47 | WELSPECS 48 | 'INJ1' 'G' 1 1 8335 'GAS' / 49 | 'PROD1' 'G' 10 10 8400 'OIL' / 50 | / 51 | 52 | COMPDAT 53 | 'INJ1' 1 1 1 1 'OPEN' 1 10.6092 0.5 / 54 | 'PROD1' 10 1 1 1 'OPEN' 0 10.6092 0.5 / 55 | / 56 | 57 | WCONPROD 58 | 'PROD1' 'OPEN' 'ORAT' 20000 4* 1000 / 59 | / 60 | 61 | WCONINJE 62 | 'INJ1' 'GAS' 'OPEN' 'RATE' 100 200 400 / 63 | / 64 | 65 | 66 | TSTEP 67 | 1 / 68 | 69 | WELOPEN 70 | 'INJ1' 'STOP' 5* / 71 | / 72 | 73 | END 74 | --------------------------------------------------------------------------------