static Evaluation krg(const Params &params, const FluidState &fluidState)
    {
        typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
        typedef MathToolbox<Evaluation> Toolbox;

        const Evaluation& Sg =
            FsToolbox::template toLhs<Evaluation>(fluidState.saturation(gasPhaseIdx));
        const Evaluation& Se = Toolbox::min(((1-Sg) - params.Sgr()) / (1 - params.Sgr()), 1.);

        // regularization
        if(Se > 1.0)
            return 0.0;
        if(Se < 0.0)
            return 1.0;

        Evaluation scaleFactor = 1.;
        if (Sg<=0.1) {
            scaleFactor = (Sg - params.Sgr())/(0.1 - params.Sgr());
            if (scaleFactor < 0.)
                return 0.0;
        }

        return scaleFactor
            * Toolbox::pow(1 - Se, 1.0/3.)
            * Toolbox::pow(1 - Toolbox::pow(Se, 1/params.vgM()), 2*params.vgM());
    }
    static Evaluation pcgn(const Params &params, const FluidState &fluidState)
    {
        typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
        typedef MathToolbox<Evaluation> Toolbox;

        Scalar PC_VG_REG = 0.01;

        // sum of liquid saturations
        const auto& St =
            FsToolbox::template toLhs<Evaluation>(fluidState.saturation(wettingPhaseIdx))
            + FsToolbox::template toLhs<Evaluation>(fluidState.saturation(nonWettingPhaseIdx));

        Evaluation Se = (St - params.Swrx())/(1. - params.Swrx());

        // regularization
        if (Se < 0.0)
            Se=0.0;
        if (Se > 1.0)
            Se=1.0;

        if (Se>PC_VG_REG && Se<1-PC_VG_REG)
        {
            const Evaluation& x = Toolbox::pow(Se,-1/params.vgM()) - 1;
            return Toolbox::pow(x, 1.0 - params.vgM())/params.vgAlpha();
        }

        // value and derivative at regularization point
        Scalar Se_regu;
        if (Se<=PC_VG_REG)
            Se_regu = PC_VG_REG;
        else
            Se_regu = 1-PC_VG_REG;
        const Evaluation& x = std::pow(Se_regu,-1/params.vgM())-1;
        const Evaluation& pc = Toolbox::pow(x, 1.0/params.vgN())/params.vgAlpha();
        const Evaluation& pc_prime =
            Toolbox::pow(x, 1/params.vgN()-1)
            * std::pow(Se_regu,-1/params.vgM()-1)
            / (-params.vgM())
            / params.vgAlpha()
            / (1 - params.Sgr() - params.Swrx())
            / params.vgN();

        // evaluate tangential
        return ((Se-Se_regu)*pc_prime + pc)/params.betaGN();
    }