C++ ParameterGroup::getDefault方法代码示例

 RockCompressibility::RockCompressibility(const parameter::ParameterGroup& param)
     : pref_(0.0),
       rock_comp_(0.0)
 {
     pref_ = param.getDefault("rock_compressibility_pref", 100.0)*unit::barsa;
     rock_comp_ = param.getDefault("rock_compressibility", 0.0)/unit::barsa;
 }

 /// Construct a system solver.
 NewtonIterationBlackoilInterleaved::NewtonIterationBlackoilInterleaved(const parameter::ParameterGroup& param,
                                                                        const boost::any& parallelInformation)
   : iterations_( 0 ),
     parallelInformation_(parallelInformation),
     newton_use_gmres_( param.getDefault("newton_use_gmres", false ) ),
     linear_solver_reduction_( param.getDefault("linear_solver_reduction", 1e-2 ) ),
     linear_solver_maxiter_( param.getDefault("linear_solver_maxiter", 50 ) ),
     linear_solver_restart_( param.getDefault("linear_solver_restart", 40 ) ),
     linear_solver_verbosity_( param.getDefault("linear_solver_verbosity", 0 ))
 {
 }

        // read values from parameter class
        NewtonIterationBlackoilInterleavedParameters( const parameter::ParameterGroup& param )
        {
            // set default parameters
            reset();

            // read parameters (using previsouly set default values)
            newton_use_gmres_        = param.getDefault("newton_use_gmres", newton_use_gmres_ );
            linear_solver_reduction_ = param.getDefault("linear_solver_reduction", linear_solver_reduction_ );
            linear_solver_maxiter_   = param.getDefault("linear_solver_maxiter", linear_solver_maxiter_);
            linear_solver_restart_   = param.getDefault("linear_solver_restart", linear_solver_restart_);
            linear_solver_verbosity_ = param.getDefault("linear_solver_verbosity", linear_solver_verbosity_);
        }

 /// Construct a system solver.
 NewtonIterationBlackoilCPR::NewtonIterationBlackoilCPR(const parameter::ParameterGroup& param,
                                                        const boost::any& parallelInformation_arg)
   : cpr_param_( param ),
     iterations_( 0 ),
     parallelInformation_(parallelInformation_arg),
     newton_use_gmres_( param.getDefault("newton_use_gmres", false ) ),
     linear_solver_reduction_( param.getDefault("linear_solver_reduction", 1e-2 ) ),
     linear_solver_maxiter_( param.getDefault("linear_solver_maxiter", 50 ) ),
     linear_solver_restart_( param.getDefault("linear_solver_restart", 40 ) ),
     linear_solver_verbosity_( param.getDefault("linear_solver_verbosity", 0 )),
     linear_solver_ignoreconvergencefailure_(param.getDefault("linear_solver_ignoreconvergencefailure", false))
 {
 }

 BlackoilPropertiesBasic::BlackoilPropertiesBasic(const parameter::ParameterGroup& param,
                                                  const int dim,
                                                  const int num_cells)
 {
     double poro = param.getDefault("porosity", 1.0);
     using namespace Opm::unit;
     using namespace Opm::prefix;
     double perm = param.getDefault("permeability", 100.0)*milli*darcy;
     rock_.init(dim, num_cells, poro, perm);
     pvt_.init(param);
     satprops_.init(param);
     if (pvt_.numPhases() != satprops_.numPhases()) {
         OPM_THROW(std::runtime_error, "BlackoilPropertiesBasic::BlackoilPropertiesBasic() - Inconsistent number of phases in pvt data ("
               << pvt_.numPhases() << ") and saturation-dependent function data (" << satprops_.numPhases() << ").");
     }
 }

    BlackoilModelParameters::BlackoilModelParameters( const parameter::ParameterGroup& param )
    {
        // set default values
        reset();

        // overload with given parameters
        dp_max_rel_  = param.getDefault("dp_max_rel", dp_max_rel_);
        ds_max_      = param.getDefault("ds_max", ds_max_);
        dr_max_rel_  = param.getDefault("dr_max_rel", dr_max_rel_);
        max_residual_allowed_ = param.getDefault("max_residual_allowed", max_residual_allowed_);
        tolerance_mb_    = param.getDefault("tolerance_mb", tolerance_mb_);
        tolerance_cnv_   = param.getDefault("tolerance_cnv", tolerance_cnv_);
        tolerance_wells_ = param.getDefault("tolerance_wells", tolerance_wells_ );
        solve_welleq_initially_ = param.getDefault("solve_welleq_initially",solve_welleq_initially_);
        update_equations_scaling_ = param.getDefault("update_equations_scaling", update_equations_scaling_);
        compute_well_potentials_ = param.getDefault("compute_well_potentials", compute_well_potentials_);
    }

 TransportSolverTwophaseImplicit::TransportSolverTwophaseImplicit(
         const UnstructuredGrid& grid,
         const Opm::IncompPropertiesInterface& props,
         const std::vector<double>& porevol,
         const double* gravity,
         const std::vector<double>& half_trans,
         const parameter::ParameterGroup& param)
     : fluid_(props),
       model_(fluid_, grid, porevol, gravity, param.getDefault("guess_old_solution", false)),
       tsolver_(model_),
       grid_(grid),
       props_(props)
 {
     ctrl_.max_it = param.getDefault("max_it", 20);
     ctrl_.verbosity = param.getDefault("verbosity", 0);
     ctrl_.max_it_ls = param.getDefault("max_it_ls", 5);
     model_.initGravityTrans(grid_, half_trans);
     tsrc_ = create_transport_source(2, 2);
     initial_porevolume_cell0_ = porevol[0];
 }

    NewtonSolver<PhysicalModel>::SolverParameters::
    SolverParameters( const parameter::ParameterGroup& param )
    {
        // set default values
        reset();

        // overload with given parameters
        relax_max_   = param.getDefault("relax_max", relax_max_);
        max_iter_    = param.getDefault("max_iter", max_iter_);
        min_iter_    = param.getDefault("min_iter", min_iter_);

        std::string relaxation_type = param.getDefault("relax_type", std::string("dampen"));
        if (relaxation_type == "dampen") {
            relax_type_ = DAMPEN;
        } else if (relaxation_type == "sor") {
            relax_type_ = SOR;
        } else {
            OPM_THROW(std::runtime_error, "Unknown Relaxtion Type " << relaxation_type);
        }
    }

    inline void setupRegionBasedConditions(const parameter::ParameterGroup& param,
                                           const GridInterface& g,
                                           BCs& bcs)
    {
        // Extract region and pressure value for Dirichlet bcs.
        typedef typename GridInterface::Vector Vector;
        Vector low;
        low[0] = param.getDefault("dir_block_low_x", 0.0);
        low[1] = param.getDefault("dir_block_low_y", 0.0);
        low[2] = param.getDefault("dir_block_low_z", 0.0);
        Vector high;
        high[0] = param.getDefault("dir_block_high_x", 1.0);
        high[1] = param.getDefault("dir_block_high_y", 1.0);
        high[2] = param.getDefault("dir_block_high_z", 1.0);
        double dir_block_pressure = param.get<double>("dir_block_pressure");

        // Set flow conditions for that region.
        // For this to work correctly, unique boundary ids should be used,
        // otherwise conditions may spread outside the given region, to all
        // faces with the same bid as faces inside the region.
        typedef typename GridInterface::CellIterator CI;
        typedef typename CI::FaceIterator FI;
        int max_bid = 0;
        std::vector<int> dir_bids;
        for (CI c = g.cellbegin(); c != g.cellend(); ++c) {
            for (FI f = c->facebegin(); f != c->faceend(); ++f) {
                int bid = f->boundaryId();
                max_bid = std::max(bid, max_bid);
                if (bid != 0 && isInside(low, high, f->centroid())) {
                    dir_bids.push_back(bid);
                }
            }
        }
        bcs.resize(max_bid + 1);
        for (std::vector<int>::const_iterator it = dir_bids.begin(); it != dir_bids.end(); ++it) {
            bcs.flowCond(*it) = FlowBC(FlowBC::Dirichlet, dir_block_pressure);
        }

        // Transport BCs are defaulted.
    }

        CPRParameter( const parameter::ParameterGroup& param)
        {
            // reset values to default
            reset();

            cpr_relax_          = param.getDefault("cpr_relax", cpr_relax_);
            cpr_solver_tol_     = param.getDefault("cpr_solver_tol", cpr_solver_tol_);
            cpr_ilu_n_          = param.getDefault("cpr_ilu_n", cpr_ilu_n_);
            cpr_max_ell_iter_   = param.getDefault("cpr_max_elliptic_iter",cpr_max_ell_iter_);
            cpr_use_amg_        = param.getDefault("cpr_use_amg", cpr_use_amg_);
            cpr_use_bicgstab_   = param.getDefault("cpr_use_bicgstab", cpr_use_bicgstab_);
            cpr_solver_verbose_ = param.getDefault("cpr_solver_verbose", cpr_solver_verbose_);
        }

    inline void SteadyStateUpscaler<Traits>::initImpl(const parameter::ParameterGroup& param)
    {
	Super::initImpl(param);
	output_vtk_ = param.getDefault("output_vtk", output_vtk_);
	print_inoutflows_ = param.getDefault("print_inoutflows", print_inoutflows_);
	simulation_steps_ = param.getDefault("simulation_steps", simulation_steps_);
	stepsize_ = Dune::unit::convert::from(param.getDefault("stepsize", stepsize_),
					      Dune::unit::day);
	relperm_threshold_ = param.getDefault("relperm_threshold", relperm_threshold_);
        sat_change_threshold_ = param.getDefault("sat_change_threshold", sat_change_threshold_);

	transport_solver_.init(param);
        // Set viscosities and densities if given.
        double v1_default = this->res_prop_.viscosityFirstPhase();
        double v2_default = this->res_prop_.viscositySecondPhase();
        this->res_prop_.setViscosities(param.getDefault("viscosity1", v1_default), param.getDefault("viscosity2", v2_default));
        double d1_default = this->res_prop_.densityFirstPhase();
        double d2_default = this->res_prop_.densitySecondPhase();
        this->res_prop_.setDensities(param.getDefault("density1", d1_default), param.getDefault("density2", d2_default));
    }

    SimulatorBase<Implementation>::SimulatorBase(const parameter::ParameterGroup& param,
                                                 const Grid& grid,
                                                 const DerivedGeology& geo,
                                                 BlackoilPropsAdInterface& props,
                                                 const RockCompressibility* rock_comp_props,
                                                 NewtonIterationBlackoilInterface& linsolver,
                                                 const double* gravity,
                                                 const bool has_disgas,
                                                 const bool has_vapoil,
                                                 std::shared_ptr<EclipseState> eclipse_state,
                                                 OutputWriter& output_writer,
                                                 const std::vector<double>& threshold_pressures_by_face)
        : param_(param),
          model_param_(param),
          solver_param_(param),
          grid_(grid),
          props_(props),
          rock_comp_props_(rock_comp_props),
          gravity_(gravity),
          geo_(geo),
          solver_(linsolver),
          has_disgas_(has_disgas),
          has_vapoil_(has_vapoil),
          terminal_output_(param.getDefault("output_terminal", true)),
          eclipse_state_(eclipse_state),
          output_writer_(output_writer),
          rateConverter_(props_, std::vector<int>(AutoDiffGrid::numCells(grid_), 0)),
          threshold_pressures_by_face_(threshold_pressures_by_face)
    {
        // Misc init.
        const int num_cells = AutoDiffGrid::numCells(grid);
        allcells_.resize(num_cells);
        for (int cell = 0; cell < num_cells; ++cell) {
            allcells_[cell] = cell;
        }
#if HAVE_MPI
        if ( terminal_output_ ) {
            if ( solver_.parallelInformation().type() == typeid(ParallelISTLInformation) )
            {
                const ParallelISTLInformation& info =
                    boost::any_cast<const ParallelISTLInformation&>(solver_.parallelInformation());
                // Only rank 0 does print to std::cout
                terminal_output_ = ( info.communicator().rank() == 0 );
                is_parallel_run_ = ( info.communicator().size() > 1 );
            }
        }
#endif
    }

 LinearSolverIstl::LinearSolverIstl(const parameter::ParameterGroup& param)
     : linsolver_residual_tolerance_(1e-8),
       linsolver_verbosity_(0),
       linsolver_type_(CG_AMG),
       linsolver_save_system_(false),
       linsolver_max_iterations_(0),
       linsolver_smooth_steps_(2),
       linsolver_prolongate_factor_(1.6)
 {
     linsolver_residual_tolerance_ = param.getDefault("linsolver_residual_tolerance", linsolver_residual_tolerance_);
     linsolver_verbosity_ = param.getDefault("linsolver_verbosity", linsolver_verbosity_);
     linsolver_type_ = LinsolverType(param.getDefault("linsolver_type", int(linsolver_type_)));
     linsolver_save_system_ = param.getDefault("linsolver_save_system", linsolver_save_system_);
     if (linsolver_save_system_) {
         linsolver_save_filename_ = param.getDefault("linsolver_save_filename", std::string("linsys"));
     }
     linsolver_max_iterations_ = param.getDefault("linsolver_max_iterations", linsolver_max_iterations_);
     linsolver_smooth_steps_ = param.getDefault("linsolver_smooth_steps", linsolver_smooth_steps_);
     linsolver_prolongate_factor_ = param.getDefault("linsolver_prolongate_factor", linsolver_prolongate_factor_);
     
 }

        // read values from parameter class
        NewtonIterationBlackoilInterleavedParameters( const parameter::ParameterGroup& param )
        {
            // set default parameters
            reset();

            // read parameters (using previsouly set default values)
            newton_use_gmres_        = param.getDefault("newton_use_gmres", newton_use_gmres_ );
            linear_solver_reduction_ = param.getDefault("linear_solver_reduction", linear_solver_reduction_ );
            linear_solver_maxiter_   = param.getDefault("linear_solver_maxiter", linear_solver_maxiter_);
            linear_solver_restart_   = param.getDefault("linear_solver_restart", linear_solver_restart_);
            linear_solver_verbosity_ = param.getDefault("linear_solver_verbosity", linear_solver_verbosity_);
            require_full_sparsity_pattern_ = param.getDefault("require_full_sparsity_pattern", require_full_sparsity_pattern_);
            ignoreConvergenceFailure_ = param.getDefault("linear_solver_ignoreconvergencefailure", ignoreConvergenceFailure_);
        }

    LinearSolverFactory::LinearSolverFactory(const parameter::ParameterGroup& param)
    {
#if HAVE_SUITESPARSE_UMFPACK_H
        std::string default_solver = "umfpack";
#elif HAVE_DUNE_ISTL
        std::string default_solver = "istl";
#elif HAVE_PETSC
        std::string default_solver = "petsc";
#else
        std::string default_solver = "no_solver_available";
        OPM_THROW(std::runtime_error, "No linear solver available, you must have UMFPACK , dune-istl or Petsc installed to use LinearSolverFactory.");
#endif

        const std::string ls =
            param.getDefault("linsolver", default_solver);

        if (ls == "umfpack") {
#if HAVE_SUITESPARSE_UMFPACK_H
            solver_.reset(new LinearSolverUmfpack);
#endif
        }

        else if (ls == "istl") {
#if HAVE_DUNE_ISTL
            solver_.reset(new LinearSolverIstl(param));
#endif
        }
        else if (ls == "petsc"){
#if HAVE_PETSC
            solver_.reset(new LinearSolverPetsc(param));
#endif
        }

        else {
            OPM_THROW(std::runtime_error, "Linear solver " << ls << " is unknown.");
        }

        if (! solver_) {
            OPM_THROW(std::runtime_error, "Linear solver " << ls << " is not enabled in "
                  "this configuration.");
        }
    }