Exemplo n.º 1
0
BubbleBase::BubbleBase(const InputParameters & parameters)
  :Kernel(parameters),
  _names(getParam<std::vector<VariableName> >("coupled_conc")),
  _this_var(getParam<NonlinearVariableName>("variable")),
  _atoms(getParam<std::vector<Real> >("coupled_atoms")),
  _widths(getParam<std::vector<Real> >("coupled_widths"))
{
	_G = coupledComponents("coupled_conc");
  if ( _G != coupledComponents("coupled_rad") )
    mooseError("From BubbleBase: The number of coupled concentrations does not match coupled radii.");
  if ( _G != _atoms.size() )
    mooseError("From BubbleBase: The number of coupled concentrations does not match atom sizes list.");

  for ( unsigned int i=0; i<_G; ++i )
  {
    _c.push_back( &coupledValue("coupled_conc", i) );
    _r.push_back( &coupledValue("coupled_rad", i) );
  }

  // Determine which group current kernel acts on
  _g = -1;
  for ( unsigned int i=0; i<_G; ++i )
  {
    if ( _names[i].compare(_this_var) == 0 )
    {
      _g = i;
      break;
    }
  }
  if (_g == -1)
    mooseError("From BubbleBase: Variable not found in coupled_conc list. Check the list.");

  mooseDoOnce( displayBubbleInfo() );
}
Exemplo n.º 2
0
bool
FauxGrainTracker::doesFeatureIntersectBoundary(unsigned int /*feature_id*/) const
{
  mooseDoOnce(mooseWarning("FauxGrainTracker::doesFeatureIntersectboundary() is unimplemented"));

  return false;
}
Exemplo n.º 3
0
Real
FeatureFloodCount::getNodalValue(dof_id_type node_id, unsigned int var_idx, bool show_var_coloring) const
{
  mooseDoOnce(mooseWarning("Please call getEntityValue instead"));

  return getEntityValue(node_id, var_idx, show_var_coloring);
}
Exemplo n.º 4
0
std::vector<std::vector<std::pair<unsigned int, unsigned int> > >
NodalFloodCount::getElementalValues(unsigned int /*elem_id*/) const
{
  std::vector<std::vector<std::pair<unsigned int, unsigned int> > > empty;

  mooseDoOnce(mooseWarning("Method not implemented"));
  return empty;
}
Exemplo n.º 5
0
void
Material::resetQpProperties()
{
  if (!_compute)
    mooseDoOnce(mooseWarning("You disabled the computation of this (",
                             name(),
                             ") material by MOOSE, but have not overridden the 'resetQpProperties' "
                             "method, this can lead to unintended values being set for material "
                             "property values."));
}
Exemplo n.º 6
0
MultiAppTransfer::MultiAppTransfer(const InputParameters & parameters)
  : Transfer(parameters),
    _multi_app(_fe_problem.getMultiApp(getParam<MultiAppName>("multi_app"))),
    _direction(getParam<MooseEnum>("direction")),
    _displaced_source_mesh(false),
    _displaced_target_mesh(false)
{
  bool check = getParam<bool>("check_multiapp_execute_on");
  if (check && (getExecuteOnEnum() != _multi_app->getExecuteOnEnum()))
    mooseDoOnce(mooseWarning("MultiAppTransfer execute_on flags do not match associated Multiapp "
                             "execute_on flags"));
}
Exemplo n.º 7
0
Real
FauxGrainTracker::getEntityValue(dof_id_type entity_id,
                                 FeatureFloodCount::FieldType field_type,
                                 std::size_t var_idx) const
{
  if (var_idx == FeatureFloodCount::invalid_size_t)
    var_idx = 0;

  mooseAssert(var_idx < _n_vars, "Index out of range");

  switch (field_type)
  {
    case FieldType::UNIQUE_REGION:
    case FieldType::VARIABLE_COLORING:
    {
      auto entity_it = _entity_id_to_var_num.find(entity_id);

      if (entity_it != _entity_id_to_var_num.end())
        return entity_it->second;
      else
        return -1;
      break;
    }

    case FieldType::CENTROID:
    {
      if (_periodic_node_map.size())
        mooseDoOnce(mooseWarning(
            "Centroids are not correct when using periodic boundaries, contact the MOOSE team"));

      // If this element contains the centroid of one of features, return it's index
      const auto * elem_ptr = _mesh.elemPtr(entity_id);
      for (MooseIndex(_vars) var_num = 0; var_num < _n_vars; ++var_num)
      {
        const auto centroid = _centroid.find(var_num);
        if (centroid != _centroid.end())
          if (elem_ptr->contains_point(centroid->second))
            return 1;
      }

      return 0;
    }

    // We don't want to error here because this should be a drop in replacement for the real grain
    // tracker.
    // Instead we'll just return zero and continue
    default:
      return 0;
  }

  return 0;
}
Exemplo n.º 8
0
void Factory::deprecatedMessage(const std::string obj_name)
{
  std::map<std::string, time_t>::iterator
    time_it = _deprecated_time.find(obj_name);

  // If the object is not deprecated return
  if (time_it == _deprecated_time.end())
    return;

  // Get the current time
  time_t now;
  time(&now);

  // Get the stop time
  time_t t_end = time_it->second;

  // Message storage
  std::ostringstream msg;

  std::map<std::string, std::string>::iterator
    name_it = _deprecated_name.find(obj_name);

  // Expired object
  if (now > t_end)
  {
    msg << "***** Invalid Object: " << obj_name << " *****\n";
    msg << "Expired on " << ctime(&t_end);

    // Append replacement object, if it exsits
    if (name_it != _deprecated_name.end())
      msg << "Upadate your application using the '" << name_it->second << "' object";

    // Produce the error message
    mooseError(msg.str());
  }

  // Expiring object
  else
  {
    // Build the basic message
    msg << "Deprecated Object: " << obj_name << "\n";
    msg << "This object will be removed on " << ctime(&t_end);

    // Append replacement object, if it exsits
    if (name_it != _deprecated_name.end())
      msg << "Replaced " << obj_name << " with " <<  name_it->second;

    // Produce the error message
    mooseDoOnce(mooseWarning(msg.str()));
  }
}
Exemplo n.º 9
0
const std::vector<std::pair<unsigned int, unsigned int> > &
GrainTracker::getElementalValues(dof_id_type elem_id) const
{
  const std::map<dof_id_type, std::vector<std::pair<unsigned int, unsigned int> > >::const_iterator pos = _elemental_data.find(elem_id);

  if (pos != _elemental_data.end())
    return pos->second;
  else
  {
#if DEBUG
    mooseDoOnce(Moose::out << "Elemental values not in structure for elem: " << elem_id << " this may be normal.");
#endif
    return _empty;
  }
}
Exemplo n.º 10
0
MultiAppTransfer::MultiAppTransfer(const InputParameters & parameters) :
    /**
     * Here we need to remove the special option that indicates to the user that this object will follow it's associated
     * Multiapp execute_on. This non-standard option is not understood by SetupInterface. In the absence of any execute_on
     * parameters, will populate the execute_on MultiMooseEnum with the values from the associated MultiApp (see execFlags).
     */
    Transfer(removeSpecialOption(parameters)),
    _multi_app(_fe_problem.getMultiApp(getParam<MultiAppName>("multi_app"))),
    _direction(getParam<MooseEnum>("direction")),
    _displaced_source_mesh(false),
    _displaced_target_mesh(false)
{
  if (execFlags() != _multi_app->execFlags())
      mooseDoOnce(mooseWarning("MultiAppTransfer execute_on flags do not match associated Multiapp execute_on flags"));
}
void
AddCoupledSolidKinSpeciesAction::act()
{
  mooseDoOnce(printReactions());

  std::vector<bool> primary_participation(_primary_species.size(), false);
  std::vector<std::string> solid_kin_species(_reactions.size());
  std::vector<Real> weight;

  // Loop through reactions
  for (unsigned int j = 0; j < _reactions.size(); ++j)
  {
    std::vector<std::string> tokens;

    // Parsing each reaction
    MooseUtils::tokenize(_reactions[j], tokens, 1, "+=");
    if (tokens.size() == 0)
      mooseError("Empty reaction specified.");

    std::vector<Real> stos(tokens.size() - 1);
    std::vector<VariableName> rxn_species(tokens.size() - 1);

    for (unsigned int k = 0; k < tokens.size(); ++k)
    {
      std::vector<std::string> stos_primary_species;
      MooseUtils::tokenize(tokens[k], stos_primary_species, 1, "()");
      if (stos_primary_species.size() == 2)
      {
        Real coef;
        std::istringstream iss(stos_primary_species[0]);
        iss >> coef;
        stos[k] = coef;
        rxn_species[k] = stos_primary_species[1];

        // Check the participation of primary species
        for (unsigned int i = 0; i < _primary_species.size(); ++i)
          if (rxn_species[k] == _primary_species[i])
            primary_participation[i] = true;
      }
      else
        solid_kin_species[j] = stos_primary_species[0];
    }
Exemplo n.º 12
0
bool
TimeSequenceStepperFailTest::converged()
{
  // The goal is to fail exactly one timestep which matches its
  // original sequence point order, other than the initial condition.
  // This can only happen once, since after you fail, you are no
  // longer on the original time sequence (off by one or more).  Since
  // this can only happen once, we only check the [1]th sequence
  // point.  (Having fewer than two sequence points doesn't really
  // make sense...)
  mooseAssert(_original_time_sequence.size() > 1, "Must have at least two sequence points!");

  if (_t_step == 1 && MooseUtils::absoluteFuzzyEqual(_time, _original_time_sequence[1]))
    {
      mooseDoOnce(Moose::out << "TimeSequenceStepperFailTest: Simulating failed solve of first timestep.\n");
      return false;
    }

  return TimeStepper::converged();
}
Exemplo n.º 13
0
const std::vector<std::pair<unsigned int, unsigned int> > &
NodalFloodCount::getNodalValues(unsigned int /*node_id*/) const
{
  mooseDoOnce(mooseWarning("Method not implemented"));
  return _empty;
}
Exemplo n.º 14
0
void
Material::initQpStatefulProperties()
{
  mooseDoOnce(mooseWarning(std::string("Material \"") + _name + "\" declares one or more stateful properties but initQpStatefulProperties() was not overridden in the derived class."));
}
Exemplo n.º 15
0
const std::vector<std::pair<unsigned int, unsigned int> > &
FeatureFloodCount::getElementalValues(dof_id_type /*elem_id*/) const
{
  mooseDoOnce(mooseWarning("Method not implemented"));
  return _empty;
}
Exemplo n.º 16
0
Real
NodalFloodCount::getElementalValue(unsigned int /*element_id*/) const
{
  mooseDoOnce(mooseWarning("Method not implemented"));
  return 0;
}
Exemplo n.º 17
0
Real
FeatureFloodCount::getEntityValue(dof_id_type entity_id, FieldType field_type, std::size_t var_index) const
{
  auto use_default = false;
  if (var_index == invalid_size_t)
  {
    use_default = true;
    var_index = 0;
  }

  mooseAssert(var_index < _maps_size, "Index out of range");

  switch (field_type)
  {
    case FieldType::UNIQUE_REGION:
    {
      const auto entity_it = _feature_maps[var_index].find(entity_id);

      if (entity_it != _feature_maps[var_index].end())
        return entity_it->second; // + _region_offsets[var_index];
      else
        return -1;
    }

    case FieldType::VARIABLE_COLORING:
    {
      const auto entity_it = _var_index_maps[var_index].find(entity_id);

      if (entity_it != _var_index_maps[var_index].end())
        return entity_it->second;
      else
        return -1;
    }

    case FieldType::GHOSTED_ENTITIES:
    {
      const auto entity_it = _ghosted_entity_ids.find(entity_id);

      if (entity_it != _ghosted_entity_ids.end())
        return entity_it->second;
      else
        return -1;
    }

    case FieldType::HALOS:
    {
      if (!use_default)
      {
        const auto entity_it = _halo_ids[var_index].find(entity_id);
        if (entity_it != _halo_ids[var_index].end())
          return entity_it->second;
      }
      else
      {
        // Showing halos in reverse order for backwards compatibility
        for (auto map_num = _maps_size; map_num-- /* don't compare greater than zero for unsigned */; )
        {
          const auto entity_it = _halo_ids[map_num].find(entity_id);

          if (entity_it != _halo_ids[map_num].end())
            return entity_it->second;
        }
      }
      return -1;
    }

    case FieldType::CENTROID:
    {
      if (_periodic_node_map.size())
        mooseDoOnce(mooseWarning("Centroids are not correct when using periodic boundaries, contact the MOOSE team"));

      // If this element contains the centroid of one of features, return one
      const auto * elem_ptr = _mesh.elemPtr(entity_id);

      for (const auto & feature : _feature_sets)
      {
        if (feature._status == Status::INACTIVE)
          continue;

        if (elem_ptr->contains_point(feature._centroid))
          return 1;
      }

      return 0;
    }

    default:
      return 0;
  }
}
Exemplo n.º 18
0
Problem &
Executioner::problem()
{
  mooseDoOnce(mooseWarning("This method is deprecated, use feProblem() instead"));
  return _fe_problem;
}
Exemplo n.º 19
0
Real
FeatureFloodCount::getElementalValue(dof_id_type /*element_id*/) const
{
  mooseDoOnce(mooseWarning("Method not implemented"));
  return 0;
}