tug/include/tug/Boundary.hpp

/**
 * @file Boundary.hpp
 * @brief API of Boundary class, that holds all information for each boundary
 * condition at the edges of the diffusion grid.
 *
 */
#ifndef BOUNDARY_H_
#define BOUNDARY_H_

#include "Grid.hpp"
#include <cstddef>

/**
 * @brief Enum defining the two implemented boundary conditions.
 *
 */
enum BC_TYPE { BC_TYPE_CLOSED, BC_TYPE_CONSTANT };

/**
 * @brief Enum defining all 4 possible sides to a 1D and 2D grid.
 *
 */
enum BC_SIDE { BC_SIDE_LEFT, BC_SIDE_RIGHT, BC_SIDE_TOP, BC_SIDE_BOTTOM };

/**
 * This class defines the boundary conditions of individual boundary elements.
 * These can be flexibly used and combined later in other classes.
 * The class serves as an auxiliary class for structuring the Boundary class.
 */
class BoundaryElement {
public:
  /**
   * @brief Construct a new Boundary Element object for the closed case.
   *        The boundary type is here automatically set to the type
   *        BC_TYPE_CLOSED, where the value takes -1 and does not hold any
   *        physical meaning.
   */
  BoundaryElement();

  /**
   * @brief Construct a new Boundary Element object for the constant case.
   *        The boundary type is automatically set to the type
   * BC_TYPE_CONSTANT.
   *
   * @param value Value of the constant concentration to be assumed at the
   *              corresponding boundary element.
   */
  BoundaryElement(double value);

  /**
   * @brief Allows changing the boundary type of a corresponding
   *        BoundaryElement object.
   *
   * @param type Type of boundary condition. Either BC_TYPE_CONSTANT or
                 BC_TYPE_CLOSED.
   */
  void setType(BC_TYPE type);

  /**
   * @brief Sets the value of a boundary condition for the constant case.
   *
   * @param value Concentration to be considered constant for the
   *              corresponding boundary element.
   */
  void setValue(double value);

  /**
   * @brief Return the type of the boundary condition, i.e. whether the
   *        boundary is considered closed or constant.
   *
   * @return BC_TYPE Type of boundary condition, either BC_TYPE_CLOSED or
             BC_TYPE_CONSTANT.
   */
  BC_TYPE getType();

  /**
   * @brief Return the concentration value for the constant boundary condition.
   *
   * @return double Value of the concentration.
   */
  double getValue();

private:
  BC_TYPE type{BC_TYPE_CLOSED};
  double value{-1};
};

/**
 * This class implements the functionality and management of the boundary
 * conditions in the grid to be simulated.
 */
class Boundary {
public:
  /**
   * @brief Creates a boundary object based on the passed grid object and
   *        initializes the boundaries as closed.
   *
   * @param grid Grid object on the basis of which the simulation takes place
   *             and from which the dimensions (in 2D case) are taken.
   */
  Boundary(Grid grid);

  /**
   * @brief Sets all elements of the specified boundary side to the boundary
   *        condition closed.
   *
   * @param side Side to be set to closed, e.g. BC_SIDE_LEFT.
   */
  void setBoundarySideClosed(BC_SIDE side);

  /**
   * @brief Sets all elements of the specified boundary side to the boundary
   *        condition constant. Thereby the concentration values of the
   *        boundaries are set to the passed value.
   *
   * @param side Side to be set to constant, e.g. BC_SIDE_LEFT.
   * @param value Concentration to be set for all elements of the specified
   * page.
   */
  void setBoundarySideConstant(BC_SIDE side, double value);

  /**
   * @brief Specifically sets the boundary element of the specified side
   *        defined by the index to the boundary condition closed.
   *
   * @param side Side in which an element is to be defined as closed.
   * @param index Index of the boundary element on the corresponding
   *              boundary side. Must index an element of the corresponding
   * side.
   */
  void setBoundaryElementClosed(BC_SIDE side, int index);

  /**
   * @brief Specifically sets the boundary element of the specified side
   *        defined by the index to the boundary condition constant with the
            given concentration value.
   *
   * @param side Side in which an element is to be defined as constant.
   * @param index Index of the boundary element on the corresponding
   *              boundary side. Must index an element of the corresponding
   side.
   * @param value Concentration value to which the boundary element should be
   set.
   */
  void setBoundaryElementConstant(BC_SIDE side, int index, double value);

  /**
   * @brief Returns the boundary condition of a specified side as a vector
   *        of BoundarsElement objects.
   *
   * @param side Boundary side from which the boundary conditions are to be
   * returned.
   * @return vector<BoundaryElement> Contains the boundary conditions as
   * BoundaryElement objects.
   */
  const std::vector<BoundaryElement> getBoundarySide(BC_SIDE side);

  /**
   * @brief Get thes Boundary Side Values as a vector. Value is -1 in case some
   specific boundary is closed.
   *
   * @param side Boundary side for which the values are to be returned.
   * @return VectorXd Vector with values as doubles.
   */
  Eigen::VectorXd getBoundarySideValues(BC_SIDE side);

  /**
   * @brief Returns the boundary condition of a specified element on a given
   * side.
   *
   * @param side Boundary side in which the boundary condition is located.
   * @param index Index of the boundary element on the corresponding
   *              boundary side. Must index an element of the corresponding
   * side.
   * @return BoundaryElement Boundary condition as a BoundaryElement object.
   */
  BoundaryElement getBoundaryElement(BC_SIDE side, int index);

  /**
   * @brief Returns the type of a boundary condition, i.e. either BC_TYPE_CLOSED
   or BC_TYPE_CONSTANT.
   *
   * @param side Boundary side in which the boundary condition type is located.
   * @param index Index of the boundary element on the corresponding
   *              boundary side. Must index an element of the corresponding
   side.
   * @return BC_TYPE Boundary Type of the corresponding boundary condition.
   */
  BC_TYPE getBoundaryElementType(BC_SIDE side, int index);

  /**
   * @brief Returns the concentration value of a corresponding
   *        BoundaryElement object if it is a constant boundary condition.
   *
   * @param side Boundary side in which the boundary condition value is
   *             located.
   * @param index Index of the boundary element on the corresponding
   *              boundary side. Must index an element of the corresponding
   *              side.
   * @return double Concentration of the corresponding BoundaryElement object.
   */
  double getBoundaryElementValue(BC_SIDE side, int index);

private:
  Grid grid; // Boundary is directly dependent on the dimensions of a predefined

  std::vector<std::vector<BoundaryElement>>
      boundaries; // Vector with Boundary Element information
};

#endif // BOUNDARY_H_