C++ coupled函数代码示例

GapHeatTransfer::GapHeatTransfer(const std::string & name, InputParameters parameters)
    :IntegratedBC(name, parameters),
     _gap_type_set(false),
     _gap_type(Moose::COORD_XYZ),
     _quadrature(getParam<bool>("quadrature")),
     _slave_flux(!_quadrature ? &_sys.getVector("slave_flux") : NULL),
     _gap_conductance(getMaterialProperty<Real>("gap_conductance"+getParam<std::string>("appended_property_name"))),
     _gap_conductance_dT(getMaterialProperty<Real>("gap_conductance"+getParam<std::string>("appended_property_name")+"_dT")),
     _min_gap(getParam<Real>("min_gap")),
     _max_gap(getParam<Real>("max_gap")),
     _gap_temp(0),
     _gap_distance(88888),
     _edge_multiplier(1.0),
     _has_info(false),
     _xdisp_coupled(isCoupled("disp_x")),
     _ydisp_coupled(isCoupled("disp_y")),
     _zdisp_coupled(isCoupled("disp_z")),
     _xdisp_var(_xdisp_coupled ? coupled("disp_x") : 0),
     _ydisp_var(_ydisp_coupled ? coupled("disp_y") : 0),
     _zdisp_var(_zdisp_coupled ? coupled("disp_z") : 0),
     _gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
     _gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
     _penetration_locator(!_quadrature ? NULL : &getQuadraturePenetrationLocator(parameters.get<BoundaryName>("paired_boundary"),
                          getParam<std::vector<BoundaryName> >("boundary")[0],
                          Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")))),
     _warnings(getParam<bool>("warnings"))
{
    if (_quadrature)
    {
        if (!parameters.isParamValid("paired_boundary"))
            mooseError(std::string("No 'paired_boundary' provided for ") + _name);
    }
    else
    {
        if (!isCoupled("gap_distance"))
            mooseError(std::string("No 'gap_distance' provided for ") + _name);

        if (!isCoupled("gap_temp"))
            mooseError(std::string("No 'gap_temp' provided for ") + _name);
    }
}

ForchheimerMass::ForchheimerMass(const InputParameters & parameters) :
  Kernel(parameters),
  // Coupled gradients
  _grad_u_vel(coupledGradient("u")),
  _grad_v_vel(coupledGradient("v")),
  _grad_w_vel(coupledGradient("w")),
  _grad_p(coupledGradient("p")),
  // Coupled variables
  _u_vel(coupledValue("u")),
  _v_vel(coupledValue("v")),
  _w_vel(coupledValue("w")),
  _p(coupledValue("p")),
  // Density from Richards
  _density(getUserObject<RichardsDensity>("gas_density_userobject")),
  // Variable numberings
  _u_vel_var_number(coupled("u")),
  _v_vel_var_number(coupled("v")),
  _w_vel_var_number(coupled("w")),
  _p_var_number(coupled("p"))
{
}

FunctionMaterialBase::FunctionMaterialBase(const std::string & name,
                                               InputParameters parameters) :
    DerivativeMaterialInterface<Material>(name, parameters),
    _F_name(getParam<std::string>("f_name")),
    _prop_F(&declareProperty<Real>(_F_name)),
    _number_of_nl_variables(_fe_problem.getNonlinearSystem().nVariables()),
    _arg_index(_number_of_nl_variables)
{
  // loop counters
  unsigned int i, j, k;

  // fetch names and numbers of all coupled variables
  _mapping_is_unique = true;
  for (std::set<std::string>::const_iterator it = _pars.coupledVarsBegin(); it != _pars.coupledVarsEnd(); ++it)
  {
    std::map<std::string, std::vector<MooseVariable *> >::iterator vars = _coupled_vars.find(*it);

    // no MOOSE variable was provided for this coupling, skip derivatives w.r.t. this variable
    if (vars == _coupled_vars.end())
      continue;

    // check if we have a 1:1 mapping between parameters and variables
    if (vars->second.size() != 1)
      _mapping_is_unique = false;

    // iterate over all components
    for (unsigned int j = 0; j < vars->second.size(); ++j)
    {
      // make sure each nonlinear variable is coupled in only once
      if (std::find(_arg_names.begin(), _arg_names.end(), vars->second[j]->name()) != _arg_names.end())
        mooseError("A nonlinear variable can only be coupled in once.");

      // insert the map values
      //unsigned int number = vars->second[j]->number();
      unsigned int number = coupled(*it, j);
      _arg_names.push_back(vars->second[j]->name());
      _arg_numbers.push_back(number);
      _arg_param_names.push_back(*it);

      // populate number -> arg index lookup table skipping aux variables
      if (number < _number_of_nl_variables)
        _arg_index[number] = _args.size();

      // get variable value
      _args.push_back(&coupledValue(*it, j));
    }
  }
  _nargs = _arg_names.size();

  // check number of coupled variables
  if (_nargs == 0)
    mooseError("Need at least one couple variable for Function Materials.");
}

JouleHeatingSource::JouleHeatingSource(const InputParameters & parameters)
  : DerivativeMaterialInterface<JvarMapKernelInterface<HeatSource>>(parameters),
    _grad_elec(coupledGradient("elec")),
    _elec_var(coupled("elec")),
    _elec_cond(getMaterialProperty<Real>("electrical_conductivity")),
    _delec_cond_dT(getMaterialPropertyDerivative<Real>("electrical_conductivity", _var.name())),
    _delec_cond_darg(_coupled_moose_vars.size())
{
  for (unsigned int i = 0; i < _delec_cond_darg.size(); ++i)
    _delec_cond_darg[i] = &getMaterialPropertyDerivative<Real>("electrical_conductivity",
                                                               _coupled_moose_vars[i]->name());
}

PorousFlow2PhasePP::PorousFlow2PhasePP(const InputParameters & parameters) :
    PorousFlowVariableBase(parameters),

    _phase0_porepressure_nodal(coupledNodalValue("phase0_porepressure")),
    _phase0_porepressure_qp(coupledValue("phase0_porepressure")),
    _phase0_gradp_qp(coupledGradient("phase0_porepressure")),
    _phase0_porepressure_varnum(coupled("phase0_porepressure")),
    _p0var(_dictator_UO.isPorousFlowVariable(_phase0_porepressure_varnum) ? _dictator_UO.porousFlowVariableNum(_phase0_porepressure_varnum) : 0),

    _phase1_porepressure_nodal(coupledNodalValue("phase1_porepressure")),
    _phase1_porepressure_qp(coupledValue("phase1_porepressure")),
    _phase1_gradp_qp(coupledGradient("phase1_porepressure")),
    _phase1_porepressure_varnum(coupled("phase1_porepressure")),
    _p1var(_dictator_UO.isPorousFlowVariable(_phase1_porepressure_varnum) ? _dictator_UO.porousFlowVariableNum(_phase1_porepressure_varnum) : 0),

    _tvar(_dictator_UO.isPorousFlowVariable(_temperature_varnum) ? _dictator_UO.porousFlowVariableNum(_temperature_varnum) : 0)

{
  if (_dictator_UO.numPhases() != 2)
    mooseError("The Dictator announces that the number of phases is " << _dictator_UO.numPhases() << " whereas PorousFlow2PhasePP can only be used for 2-phase simulation.  When you have an efficient government, you have a dictatorship.");
}

RichardsHalfGaussianSinkFlux::RichardsHalfGaussianSinkFlux(const InputParameters & parameters)
  : SideIntegralVariablePostprocessor(parameters),
    _feproblem(dynamic_cast<FEProblemBase &>(_subproblem)),
    _maximum(getParam<Real>("max")),
    _sd(getParam<Real>("sd")),
    _centre(getParam<Real>("centre")),
    _richards_name_UO(getUserObject<RichardsVarNames>("richardsVarNames_UO")),
    _pvar(_richards_name_UO.richards_var_num(coupled("variable"))),
    _m_func(getFunction("multiplying_fcn")),
    _pp(getMaterialProperty<std::vector<Real>>("porepressure"))
{
}

ComputeExternalGrainForceAndTorque::ComputeExternalGrainForceAndTorque(const InputParameters & parameters) :
    DerivativeMaterialInterface<ShapeElementUserObject>(parameters),
    GrainForceAndTorqueInterface(),
    _c_name(getVar("c", 0)->name()),
    _c_var(coupled("c")),
    _dF_name(getParam<MaterialPropertyName>("force_density")),
    _dF(getMaterialPropertyByName<std::vector<RealGradient> >(_dF_name)),
    _dFdc(getMaterialPropertyByName<std::vector<RealGradient> >(propertyNameFirst(_dF_name, _c_name))),
    _op_num(coupledComponents("etas")),
    _grain_tracker(getUserObject<GrainTrackerInterface>("grain_data")),
    _vals_var(_op_num),
    _vals_name(_op_num),
    _dFdeta(_op_num)
{
  for (unsigned int i = 0; i < _op_num; ++i)
  {
    _vals_var[i] = coupled("etas", i);
    _vals_name[i] = getVar("etas", i)->name();
    _dFdeta[i] = &getMaterialPropertyByName<std::vector<RealGradient> >(propertyNameFirst(_dF_name, _vals_name[i]));
  }
}

DesorptionToPorespace::DesorptionToPorespace(const std::string & name,
                                             InputParameters parameters) :
    Kernel(name,parameters),
    _conc_val(&coupledValue("conc_var")),
    _conc_var(coupled("conc_var")),

    _desorption_time_const(getMaterialProperty<Real>("desorption_time_const")),
    _adsorption_time_const(getMaterialProperty<Real>("adsorption_time_const")),
    _equilib_conc(getMaterialProperty<Real>("desorption_equilib_conc")),
    _equilib_conc_prime(getMaterialProperty<Real>("desorption_equilib_conc_prime"))
{
}

OrderParameterFunctionMaterial::OrderParameterFunctionMaterial(const std::string & name,
                                                               InputParameters parameters) :
    DerivativeMaterialInterface<Material>(name, parameters),
    _eta(coupledValue("eta")),
    _eta_var(coupled("eta")),
    _eta_name(getVar("eta", 0)->name()),
    _function_name(getParam<std::string>("function_name")),
    _prop_f(declareProperty<Real>(_function_name)),
    _prop_df(declarePropertyDerivative<Real>(_function_name, _eta_name)),
    _prop_d2f(declarePropertyDerivative<Real>(_function_name, _eta_name, _eta_name))
{
}

ACMultiInterface::ACMultiInterface(const InputParameters & parameters) :
    Kernel(parameters),
    _num_etas(coupledComponents("etas")),
    _eta(_num_etas),
    _grad_eta(_num_etas),
    _eta_vars(_fe_problem.getNonlinearSystem().nVariables(), -1),
    _kappa_names(getParam<std::vector<MaterialPropertyName> >("kappa_names")),
    _kappa(_num_etas),
    _L(getMaterialProperty<Real>("mob_name"))
{
  if (_num_etas != _kappa_names.size())
    mooseError("Supply the same nummber of etas and kappa_names.");

  unsigned int nvariables = _fe_problem.getNonlinearSystem().nVariables();

  int a = -1;
  for (unsigned int i = 0; i < _num_etas; ++i)
  {
    // get all order parameters and their gradients
    _eta[i] = &coupledValue("etas", i);
    _grad_eta[i] = &coupledGradient("etas", i);

    // populate lookup table form jvar to _eta index
    unsigned int var = coupled("etas", i);
    if (var < nvariables)
      _eta_vars[var] = i;

    // get the index of the variable the kernel is operating on
    if (coupled("etas", i) == _var.number())
      a = i;

    // get gradient prefactors
    _kappa[i] = &getMaterialPropertyByName<Real>(_kappa_names[i]);
  }

  if (a < 0)
    mooseError("Kernel variable must be listed in etas for ACMultiInterface kernel " << name());
  else
    _a = a;
}

INSSplitMomentum::INSSplitMomentum(const InputParameters & parameters)
  : Kernel(parameters),

    // Coupled variables
    _u_vel(coupledValue("u")),
    _v_vel(_mesh.dimension() >= 2 ? coupledValue("v") : _zero),
    _w_vel(_mesh.dimension() == 3 ? coupledValue("w") : _zero),

    _a1(coupledValue("a1")),
    _a2(_mesh.dimension() >= 2 ? coupledValue("a2") : _zero),
    _a3(_mesh.dimension() == 3 ? coupledValue("a3") : _zero),

    // Gradients
    _grad_u_vel(coupledGradient("u")),
    _grad_v_vel(_mesh.dimension() >= 2 ? coupledGradient("v") : _grad_zero),
    _grad_w_vel(_mesh.dimension() == 3 ? coupledGradient("w") : _grad_zero),

    // Variable numberings
    _u_vel_var_number(coupled("u")),
    _v_vel_var_number(_mesh.dimension() >= 2 ? coupled("v") : libMesh::invalid_uint),
    _w_vel_var_number(_mesh.dimension() == 3 ? coupled("w") : libMesh::invalid_uint),

    _a1_var_number(coupled("a1")),
    _a2_var_number(_mesh.dimension() >= 2 ? coupled("a2") : libMesh::invalid_uint),
    _a3_var_number(_mesh.dimension() == 3 ? coupled("a3") : libMesh::invalid_uint),

    // Required parameters
    _gravity(getParam<RealVectorValue>("gravity")),
    _component(getParam<unsigned>("component")),

    // Material properties
    _mu(getMaterialProperty<Real>("mu_name")),
    _rho(getMaterialProperty<Real>("rho_name"))
{
}

ContactMaster::ContactMaster(const InputParameters & parameters) :
    DiracKernel(parameters),
    _component(getParam<unsigned int>("component")),
    _model(contactModel(getParam<std::string>("model"))),
    _formulation(contactFormulation(getParam<std::string>("formulation"))),
    _normalize_penalty(getParam<bool>("normalize_penalty")),
    _penetration_locator(getPenetrationLocator(getParam<BoundaryName>("boundary"),
                                               getParam<BoundaryName>("slave"),
                                               Utility::string_to_enum<Order>(getParam<MooseEnum>("order")))),
    _penalty(getParam<Real>("penalty")),
    _friction_coefficient(getParam<Real>("friction_coefficient")),
    _tension_release(getParam<Real>("tension_release")),
    _capture_tolerance(getParam<Real>("capture_tolerance")),
    _updateContactSet(true),
    _residual_copy(_sys.residualGhosted()),
    _x_var(isCoupled("disp_x") ? coupled("disp_x") : libMesh::invalid_uint),
    _y_var(isCoupled("disp_y") ? coupled("disp_y") : libMesh::invalid_uint),
    _z_var(isCoupled("disp_z") ? coupled("disp_z") : libMesh::invalid_uint),
    _mesh_dimension(_mesh.dimension()),
    _vars(_x_var, _y_var, _z_var),
    _nodal_area_var(getVar("nodal_area", 0)),
    _aux_system(_nodal_area_var->sys()),
    _aux_solution(_aux_system.currentSolution())
{
  if (parameters.isParamValid("tangential_tolerance"))
    _penetration_locator.setTangentialTolerance(getParam<Real>("tangential_tolerance"));

  if (parameters.isParamValid("normal_smoothing_distance"))
    _penetration_locator.setNormalSmoothingDistance(getParam<Real>("normal_smoothing_distance"));

  if (parameters.isParamValid("normal_smoothing_method"))
    _penetration_locator.setNormalSmoothingMethod(parameters.get<std::string>("normal_smoothing_method"));

  if (_model == CM_GLUED ||
      (_model == CM_COULOMB && _formulation == CF_DEFAULT))
    _penetration_locator.setUpdate(false);

  if (_friction_coefficient < 0)
    mooseError("The friction coefficient must be nonnegative");
}

// DEPRECATED CONSTRUCTOR
StressDivergencePFFracTensors::StressDivergencePFFracTensors(const std::string & deprecated_name, InputParameters parameters) :
    StressDivergenceTensors(deprecated_name, parameters),
    _c_coupled(isCoupled("c")),
    _c_var(_c_coupled ? coupled("c") : 0)
{
  if (_c_coupled)
  {
    if (!isParamValid("pff_jac_prop_name"))
      mooseError("StressDivergencePFFracTensors: Provide pff_jac_prop_name that contains d_stress_d_c: Coupled variable only used in Jacobian evaluation");
    else
      _d_stress_dc  = &getMaterialProperty<RankTwoTensor>("pff_jac_prop_name");
  }
}

CoupledTPBPotentialYSZQS::CoupledTPBPotentialYSZQS(const InputParameters & parameters) :
    Kernel(parameters),
    _s0(getParam<Real>("s0")),
    _z(getParam<Real>("z")),
    _F(getParam<Real>("F")),
    _R(getParam<Real>("R")),
    _T(getParam<Real>("T")),
    _func_phi_LSM(getFunction("function_phi_LSM")),
    _pO2_CE(getParam<Real>("pO2_CE")),
    _num_p_O2(coupled("p_O2")),
    _p_O2(coupledValue("p_O2"))
{
}

INSProjection::INSProjection(const std::string & name, InputParameters parameters) :
  Kernel(name, parameters),

  // Coupled variables
  _a1(coupledValue("a1")),
  _a2(_mesh.dimension() >= 2 ? coupledValue("a2") : _zero),
  _a3(_mesh.dimension() == 3 ? coupledValue("a3") : _zero),

  // Gradients
  _grad_p(coupledGradient("p")),

  // Variable numberings
  _a1_var_number(coupled("a1")),
  _a2_var_number(_mesh.dimension() >= 2 ? coupled("a2") : libMesh::invalid_uint),
  _a3_var_number(_mesh.dimension() == 3 ? coupled("a3") : libMesh::invalid_uint),
  _p_var_number(coupled("p")),

  // Required parameters
  _rho(getParam<Real>("rho")),
  _component(getParam<unsigned>("component"))
{
}