std::shared_ptr<NeumannBCAbstract>
  ParsedFunctionNeumannBCFactoryHelper<FunctionType>::build_neumman_func_common( const GetPot& input,
                                                                                 MultiphysicsSystem& system,
                                                                                 const FEVariablesBase& fe_var,
                                                                                 const std::string& flux_input )
  {
    const std::vector<std::string>& var_names = fe_var.active_var_names();

    std::shared_ptr<NeumannBCAbstract> func;

    // Use "standard" parsed version if there's only one variable
    if( var_names.size() == 1 )
      {
        libmesh_assert_equal_to( fe_var.var_indices().size(), 1 );
        std::string expression = input(flux_input,std::string("DIE!"));
        func = this->build_parsed_neumann_func(system,expression,fe_var.var_indices()[0]);
      }
    // Otherwise, use the composite versions
    else
      {
        libmesh_assert_equal_to( fe_var.var_indices().size(), var_names.size() );

        // We already checked size consistency for flux input and var_names
        // so just use var_names for the size
        std::vector<std::string> expressions(var_names.size());

        for( unsigned int i = 0; i < var_names.size(); i++ )
          expressions[i] = input(flux_input,std::string("DIE!"),i);

        func = this->build_composite_parsed_neumann_func(system,expressions,fe_var.var_indices());
      }

    return func;
  }
  SharedPtr<NeumannBCAbstract>
  CatalyticWallNeumannBCFactoryCommon<ImpType>::build_catalytic_wall_common( const GetPot& input,
                                                                             const FEVariablesBase& fe_var,
                                                                             const std::string& material,
                                                                             const std::string& reaction,
                                                                             SharedPtr<CatalycityBase>& gamma_ptr,
                                                                             libMesh::Real p0,
                                                                             std::string& thermochem_lib )
  {
    // Extract species variables and material
    std::vector<VariableIndex> species_vars;
    this->extract_species_vars( fe_var, species_vars );

    libmesh_assert_equal_to( fe_var.active_var_names().size(), species_vars.size() );

    // Extract Temperature variable index.
    VariableIndex T_var = this->extract_temp_var();

    return _wall_impl.build_catalytic_wall(input,reaction,gamma_ptr,species_vars,
                                           material,T_var,p0,thermochem_lib);
  }
 void CatalyticWallNeumannBCFactoryCommon<ImpType>::extract_species_vars
 ( const FEVariablesBase& fe_var, std::vector<VariableIndex>& species_vars ) const
 {
   species_vars = fe_var.var_indices();
 }