correcting the injectivity with polymer injection.

opm/autodiff/StandardWell.hpp

@@ -62,6 +62,7 @@ namespace Opm
         using typename WellInterface<TypeTag>::Mat;
         using typename WellInterface<TypeTag>::BVector;
         using typename WellInterface<TypeTag>::Eval;
+        using typename WellInterface<TypeTag>::PolymerModule;
 
         using WellInterface<TypeTag>::numEq;
         static const int numWellEq = GET_PROP_VALUE(TypeTag, EnablePolymer)? numEq-1 : numEq; // //numEq; //number of wellEq is only numEq for polymer

opm/autodiff/StandardWell_impl.hpp

@@ -797,6 +797,50 @@ namespace Opm
                 OPM_THROW(std::runtime_error, "individual mobility for wells does not work in combination with solvent");
             }
         }
+
+        // modify the water mobility if polymer is present
+        if (has_polymer) {
+            // assume fully mixture for wells.
+            EvalWell polymerConcentration = extendEval(intQuants.polymerConcentration());
+
+            if (wellType() == INJECTOR) {
+                const auto& viscosityMultiplier = PolymerModule::plyviscViscosityMultiplierTable(intQuants.pvtRegionIndex());
+                mob[ Water ] /= (extendEval(intQuants.waterViscosityCorrection()) * viscosityMultiplier.eval(polymerConcentration, /*extrapolate=*/true) );
+            }
+
+            /* if (PolymerModule::hasPlyshlog()) {
+                // compute the well water velocity with out shear effects.
+                const int numComp = numComponents();
+                const bool allow_cf = crossFlowAllowed(ebosSimulator);
+                const EvalWell& bhp = getBhp();
+                std::vector<EvalWell> cq_s(numComp,0.0);
+                computePerfRate(intQuants, mob, wellIndex()[perf], bhp, perfPressureDiffs()[perf], allow_cf, cq_s);
+                double area = 2 * M_PI * wells_rep_radius_[perf] * wells_perf_length_[perf];
+                const auto& materialLawManager = ebosSimulator.problem().materialLawManager();
+                const auto& scaledDrainageInfo =
+                        materialLawManager->oilWaterScaledEpsInfoDrainage(cell_idx);
+                const Scalar& Swcr = scaledDrainageInfo.Swcr;
+                const EvalWell poro = extendEval(intQuants.porosity());
+                const EvalWell Sw = extendEval(intQuants.fluidState().saturation(flowPhaseToEbosPhaseIdx(Water)));
+                // guard against zero porosity and no water
+                const EvalWell denom = Opm::max( (area * poro * (Sw - Swcr)), 1e-12);
+                EvalWell waterVelocity = cq_s[ Water ] / denom * extendEval(intQuants.fluidState().invB(flowPhaseToEbosPhaseIdx(Water)));
+
+                if (PolymerModule::hasShrate()) {
+                    // TODO Use the same conversion as for the reservoar equations.
+                    // Need the "permeability" of the well?
+                    // For now use the same formula as in legacy.
+                    waterVelocity *= PolymerModule::shrate( intQuants.pvtRegionIndex() ) / wells_bore_diameter_[perf];
+                }
+                EvalWell polymerConcentration = extendEval(intQuants.polymerConcentration());
+                EvalWell shearFactor = PolymerModule::computeShearFactor(polymerConcentration,
+                                                                         intQuants.pvtRegionIndex(),
+                                                                         waterVelocity);
+
+                // modify the mobility with the shear factor and recompute the well fluxes.
+                mob[ Water ] /= shearFactor;
+            } */
+        }
     }
 
 

opm/autodiff/WellInterface.hpp

@@ -78,6 +78,8 @@ namespace Opm
         typedef Dune::BlockVector<VectorBlockType> BVector;
         typedef DenseAd::Evaluation<double, /*size=*/numEq> Eval;
 
+        typedef Ewoms::BlackOilPolymerModule<TypeTag> PolymerModule;
+
         static const bool has_solvent = GET_PROP_VALUE(TypeTag, EnableSolvent);
         static const bool has_polymer = GET_PROP_VALUE(TypeTag, EnablePolymer);