Component1DConnection.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Component.h"

class Component1DConnection : public Component
{
public:
  Component1DConnection(const InputParameters & params);

  enum EEndType
  {
    IN, 
    OUT 
  };
  static const std::map<std::string, EEndType> _end_type_to_enum;

  struct Connection
  {
    const BoundaryName _boundary_name;

    const std::string _component_name;

    const EEndType _end_type;

    Connection(const BoundaryName & boundary_name,
               const std::string & component_name,
               const EEndType & end_type)
      : _boundary_name(boundary_name), _component_name(component_name), _end_type(end_type)
    {
    }
  };

  const std::vector<Connection> & getConnections() const { return _connections; }

  const std::vector<std::string> & getConnectedComponentNames() const
  {
    return _connected_component_names;
  }

  const std::vector<SubdomainName> & getConnectedSubdomainNames() const
  {
    return _connected_subdomain_names;
  }

  virtual const std::vector<dof_id_type> & getNodeIDs() const;

  const std::vector<BoundaryName> & getBoundaryNames() const;

protected:
  virtual void setupMesh() override;
  virtual void init() override;
  virtual void check() const override;

  void addConnection(const BoundaryName & boundary_name);

  void checkNumberOfConnections(const unsigned int & n_connections) const;

  template <typename T>
  void checkSizeEqualsNumberOfConnections(const std::string & param) const;

  template <typename T>
  void checkAllConnectionsHaveSame(const std::vector<T> & objects,
                                   const std::string & description) const;

  std::vector<Point> _positions;
  std::vector<const Elem *> _elems;
  std::vector<unsigned short int> _sides;
  std::vector<dof_id_type> _nodes;
  std::vector<unsigned int> _boundary_ids;
  std::vector<BoundaryName> _boundary_names;
  std::vector<Real> _normals;
  std::vector<RealVectorValue> _directions;

  std::vector<Connection> _connections;
  std::vector<std::string> _connected_component_names;
  std::vector<SubdomainName> _connected_subdomain_names;

public:
  static InputParameters validParams();
};

template <typename T>
void
Component1DConnection::checkSizeEqualsNumberOfConnections(const std::string & param) const
{
  const auto & value = getParam<std::vector<T>>(param);
  if (value.size() != _connections.size())
    logError("The number of entries in '",
             param,
             "' (",
             value.size(),
             ") must equal the number of connections (",
             _connections.size(),
             ")");
}

template <typename T>
void
Component1DConnection::checkAllConnectionsHaveSame(const std::vector<T> & objects,
                                                   const std::string & description) const
{
  for (const auto & obj : objects)
    if (obj != objects[0])
      logError("All connections must have the same ", description);
}

namespace THM
{
template <>
Component1DConnection::EEndType stringToEnum(const std::string & s);
}