nimble::BoundaryConditionManager Class Reference

#include <nimble_boundary_condition_manager.h>

Public Types
enum	Time_Integration_Scheme { EXPLICIT = 0 , QUASISTATIC = 1 , UNDEFINED = 2 }

Public Member Functions
	BoundaryConditionManager ()
void	Initialize (std::map< int, std::string > const &node_set_names, std::map< int, std::vector< int > > const &node_sets, std::map< int, std::string > const &side_set_names, std::map< int, std::vector< int > > const &side_sets, std::vector< std::string > const &bc_strings, int dim, std::string time_integration_scheme)
virtual	~BoundaryConditionManager ()=default
template<typename ViewT>
void	ApplyInitialConditions (const ViewT reference_coordinates, ViewT velocity, std::vector< ViewT > &offnom_velocities)
template<typename ViewT>
void	ApplyInitialConditions (const ViewT reference_coordinates, ViewT velocity)
template<typename ViewT>
void	ApplyKinematicBC (double time_current, double time_previous, const ViewT reference_coordinates, ViewT displacement, ViewT velocity, std::vector< ViewT > &offnom_velocities)
template<typename ViewT>
void	ApplyKinematicBC (double time_current, double time_previous, const ViewT reference_coordinates, ViewT displacement, ViewT velocity)
template<typename MatT>
void	ModifyTangentStiffnessMatrixForKinematicBC (int num_unknowns, const int *global_node_ids, double diagonal_entry, MatT &tangent_stiffness) const
void	ModifyRHSForKinematicBC (const int *global_node_ids, double *rhs) const
template<typename ViewT>
void	ApplyTractionBC (double time_current, const ViewT reference_coordinates, ViewT internal_force)

Member Enumeration Documentation

Time_Integration_Scheme

enum nimble::BoundaryConditionManager::Time_Integration_Scheme

Enumerator
EXPLICIT
QUASISTATIC
UNDEFINED

  {
    EXPLICIT    = 0,
    QUASISTATIC = 1,
    UNDEFINED   = 2
  };

Constructor & Destructor Documentation

BoundaryConditionManager()

nimble::BoundaryConditionManager::BoundaryConditionManager ( )

inline

{}

~BoundaryConditionManager()

virtual nimble::BoundaryConditionManager::~BoundaryConditionManager ( )

virtualdefault

Member Function Documentation

ApplyInitialConditions() [1/2]

template<typename ViewT>

void nimble::BoundaryConditionManager::ApplyInitialConditions ( const ViewT reference_coordinates, ViewT velocity )

inline

  {
    std::vector<ViewT> empty;
    ApplyInitialConditions<ViewT>(reference_coordinates, velocity, empty);
  }

ApplyInitialConditions() [2/2]

template<typename ViewT>

void nimble::BoundaryConditionManager::ApplyInitialConditions ( const ViewT reference_coordinates, ViewT velocity, std::vector< ViewT > & offnom_velocities )

inline

  {
    for (auto& bc : boundary_conditions_) {
      if (bc.bc_type_ == BoundaryCondition::INITIAL_VELOCITY) {
        int                     node_set_id    = bc.node_set_id_;
        int                     coordinate     = bc.coordinate_;
        bool                    has_expression = bc.has_expression_;
        std::vector<int> const& node_set       = node_sets_[node_set_id];
        if (!has_expression) {
          double magnitude = bc.magnitude_;
          for (int n : node_set) {
            velocity(n, coordinate) = magnitude;
            for (int nuq = 0; nuq < offnom_velocities.size(); nuq++) {
              offnom_velocities[nuq](n, coordinate) = magnitude;
            }
          }
        } else {
          for (int n : node_set) {
            bc.expression_.x = reference_coordinates(n, 0);
            bc.expression_.y = reference_coordinates(n, 1);
            bc.expression_.z = 0.0;
            if (dim_ == 3) { bc.expression_.z = reference_coordinates(n, 2); }
            bc.expression_.t        = 0.0;
            velocity(n, coordinate) = bc.expression_.eval();
            for (int nuq = 0; nuq < offnom_velocities.size(); nuq++) {
              offnom_velocities[nuq](n, coordinate) = bc.expression_.eval();
            }
          }
        }
      }
    }
  }

ApplyKinematicBC() [1/2]

template<typename ViewT>

void nimble::BoundaryConditionManager::ApplyKinematicBC ( double time_current, double time_previous, const ViewT reference_coordinates, ViewT displacement, ViewT velocity )

inline

  {
    std::vector<ViewT> empty;
    ApplyKinematicBC(time_current, time_previous, reference_coordinates, displacement, velocity, empty);
  }

ApplyKinematicBC() [2/2]

template<typename ViewT>

void nimble::BoundaryConditionManager::ApplyKinematicBC ( double time_current, double time_previous, const ViewT reference_coordinates, ViewT displacement, ViewT velocity, std::vector< ViewT > & offnom_velocities )

inline

  {
    double delta_t = time_current - time_previous;
 
    for (auto& bc : boundary_conditions_) {
      int                     node_set_id    = bc.node_set_id_;
      int                     coordinate     = bc.coordinate_;
      bool                    has_expression = bc.has_expression_;
      std::vector<int> const& node_set       = node_sets_[node_set_id];
 
      if (bc.bc_type_ == BoundaryCondition::PRESCRIBED_VELOCITY) {
        if (!has_expression) {
          double velocity_magnitude = bc.magnitude_;
          for (int n : node_set) {
            velocity(n, coordinate) = velocity_magnitude;
            for (int nuq = 0; nuq < offnom_velocities.size(); nuq++) {
              offnom_velocities[nuq](n, coordinate) = velocity_magnitude;
            }
            if (time_integration_scheme_ == QUASISTATIC) {
              displacement(n, coordinate) += velocity_magnitude * delta_t;
            }
          }
        } else {
          for (int n : node_set) {
            bc.expression_.x = reference_coordinates(n, 0);
            bc.expression_.y = reference_coordinates(n, 1);
            bc.expression_.z = 0.0;
            if (dim_ == 3) { bc.expression_.z = reference_coordinates(n, 2); }
            bc.expression_.t          = time_current;
            double velocity_magnitude = bc.expression_.eval();
            velocity(n, coordinate)   = velocity_magnitude;
            for (int nuq = 0; nuq < offnom_velocities.size(); nuq++) {
              offnom_velocities[nuq](n, coordinate) = velocity_magnitude;
            }
            if (time_integration_scheme_ == QUASISTATIC) {
              displacement(n, coordinate) += velocity_magnitude * delta_t;
            }
          }
        }
      } else if (bc.bc_type_ == BoundaryCondition::PRESCRIBED_DISPLACEMENT && delta_t > 0.0) {
        if (!has_expression) {
          double displacement_magnitude = bc.magnitude_;
          for (int n : node_set) {
            velocity(n, coordinate) = (displacement_magnitude - displacement(n, coordinate)) / delta_t;
            if (time_integration_scheme_ == QUASISTATIC) { displacement(n, coordinate) = displacement_magnitude; }
          }
        } else {
          for (int n : node_set) {
            bc.expression_.x = reference_coordinates(n, 0);
            bc.expression_.y = reference_coordinates(n, 1);
            bc.expression_.z = 0.0;
            if (dim_ == 3) { bc.expression_.z = reference_coordinates(n, 2); }
            bc.expression_.t              = time_current;
            double displacement_magnitude = bc.expression_.eval();
            velocity(n, coordinate)       = (displacement_magnitude - displacement(n, coordinate)) / delta_t;
            if (time_integration_scheme_ == QUASISTATIC) { displacement(n, coordinate) = displacement_magnitude; }
          }
        }
      }
    }
  }

ApplyTractionBC()

template<typename ViewT>

void nimble::BoundaryConditionManager::ApplyTractionBC ( double time_current, const ViewT reference_coordinates, ViewT internal_force )

inline

  {
    for (auto& bc : boundary_conditions_) {
      int                     side_set_id    = bc.side_set_id_;
      int                     coordinate     = bc.coordinate_;
      bool                    has_expression = bc.has_expression_;
      std::vector<int> const& side_set       = side_sets_[side_set_id];
      if (bc.bc_type_ == BoundaryCondition::PRESCRIBED_TRACTION) {
        if (has_expression == true) {
          for (int ss : side_set) {}
        } else {
          for (int ss : side_set) {}
        }
      }
    }
  }

Initialize()

void nimble::BoundaryConditionManager::Initialize	(	std::map< int, std::string > const &	node_set_names,
		std::map< int, std::vector< int > > const &	node_sets,
		std::map< int, std::string > const &	side_set_names,
		std::map< int, std::vector< int > > const &	side_sets,
		std::vector< std::string > const &	bc_strings,
		int	dim,
		std::string	time_integration_scheme )

{
  node_set_names_ = node_set_names;
  node_sets_      = node_sets;
  side_set_names_ = side_set_names;
  side_sets_      = side_sets;
  dim_            = dim;
 
  if (time_integration_scheme == "explicit") {
    time_integration_scheme_ = EXPLICIT;
  } else if (time_integration_scheme == "quasistatic") {
    time_integration_scheme_ = QUASISTATIC;
  }
 
  for (int i = 0; i < bc_strings.size(); i++) {
    BoundaryCondition bc;
    bool              is_valid = bc.Initialize(dim_, bc_strings[i], node_set_names, side_set_names);
    if (is_valid) { boundary_conditions_.push_back(bc); }
  }
}

ModifyRHSForKinematicBC()

void nimble::BoundaryConditionManager::ModifyRHSForKinematicBC	(	const int *	global_node_ids,
		double *	rhs ) const

{
  for (unsigned int i_bc = 0; i_bc < boundary_conditions_.size(); i_bc++) {
    BoundaryCondition const& bc          = boundary_conditions_[i_bc];
    int                      node_set_id = bc.node_set_id_;
    int                      coordinate  = bc.coordinate_;
    std::vector<int> const&  node_set    = node_sets_.at(node_set_id);
 
    if (bc.bc_type_ == BoundaryCondition::PRESCRIBED_DISPLACEMENT ||
        bc.bc_type_ == BoundaryCondition::PRESCRIBED_VELOCITY) {
      for (unsigned int n = 0; n < node_set.size(); n++) {
        rhs[global_node_ids[node_set[n]] * dim_ + coordinate] = 0.0;
      }
    }
  }
}

ModifyTangentStiffnessMatrixForKinematicBC()

template<typename MatT>

template void nimble::BoundaryConditionManager::ModifyTangentStiffnessMatrixForKinematicBC< CRSMatrixContainer >	(	int	num_unknowns,
		const int *	global_node_ids,
		double	diagonal_entry,
		MatT &	tangent_stiffness ) const

{
  for (unsigned int i_bc = 0; i_bc < boundary_conditions_.size(); i_bc++) {
    BoundaryCondition const& bc          = boundary_conditions_[i_bc];
    int                      node_set_id = bc.node_set_id_;
    int                      coordinate  = bc.coordinate_;
    std::vector<int> const&  node_set    = node_sets_.at(node_set_id);
 
    if (bc.bc_type_ == BoundaryCondition::PRESCRIBED_DISPLACEMENT ||
        bc.bc_type_ == BoundaryCondition::PRESCRIBED_VELOCITY) {
      for (unsigned int n = 0; n < node_set.size(); n++) {
        int index = global_node_ids[node_set[n]] * dim_ + coordinate;
        tangent_stiffness.SetRowValues(index, 0.0);
        tangent_stiffness.SetColumnValues(index, 0.0);
        tangent_stiffness(index, index) = diagonal_entry;
      }
    }
  }
}

---

The documentation for this class was generated from the following files:

• src/nimble_boundary_condition_manager.h
• src/nimble_boundary_condition_manager.cc