loading::ParticleULoading Class Reference

A class to apply displacement boundary condition. More...

#include <particleULoading.h>

Inheritance diagram for loading::ParticleULoading:

Collaboration diagram for loading::ParticleULoading:

Public Member Functions
	ParticleULoading (std::vector< inp::BCBaseDeck > &bc_data)
	Constructor.
void	setFixity (particle::BaseParticle *particle)
	Sets fixity mask.
void	apply (const double &time, particle::BaseParticle *particle)
	Applies displacement boundary condition.
Public Member Functions inherited from loading::ParticleLoading
	ParticleLoading ()=default
	Constructor.

Data Fields
std::vector< bool >	d_pZeroDisplacementApplied
	Flag to indicate whether particles are fixed.

Additional Inherited Members
Protected Attributes inherited from loading::ParticleLoading
std::vector< inp::BCBaseDeck >	d_bcData
	List of displacement bcs.

Detailed Description

A class to apply displacement boundary condition.

Definition at line 35 of file particleULoading.h.

Constructor & Destructor Documentation

ParticleULoading()

loading::ParticleULoading::ParticleULoading

(

std::vector< inp::BCBaseDeck > &

bc_data

)

Constructor.

Parameters

bc_data

Boundary condition data

Definition at line 18 of file particleULoading.cpp.

                                       {
 
  d_bcData = bc_data;
 
  d_pZeroDisplacementApplied = std::vector<bool>(d_bcData.size(), false);
}

References loading::ParticleLoading::d_bcData, and d_pZeroDisplacementApplied.

Member Function Documentation

apply()

void loading::ParticleULoading::apply	(	const double &	time,
		particle::BaseParticle *	particle
	)

Applies displacement boundary condition.

Parameters

time	Current time
particle	Particle object pointer

Definition at line 51 of file particleULoading.cpp.

                                                                      {
 
  for (size_t s = 0; s < d_bcData.size(); s++) {
 
    // get alias for bc data
    const auto &bc = d_bcData[s];
 
    // if this is zero displacement condition, we do not apply displacement
    if (bc.d_isDisplacementZero)
      continue;
 
    // check if we need to process this particle
    if (!needToProcessParticle(particle->getId(), bc))
      continue;
 
    // get bounding box (quite possibly be generic)
    auto reg_box = bc.d_regionGeomData.d_geom_p == nullptr ? std::pair<util::Point, util::Point>(util::Point(), util::Point()) : bc.d_regionGeomData.d_geom_p->box();
 
    for (size_t i = 0; i < particle->getNumNodes(); i++) {
 
                const auto x = particle->getXRefLocal(i);
 
                double umax = bc.d_timeFnParams[0];
                double du = 0.;
                double dv = 0.;
 
                auto box = reg_box;
                if (!bc.d_isRegionActive) {
                  // get box from particle
                  box = particle->d_geom_p->box();
                }
 
                if (needToComputeDof(x, particle->getId(), bc)) {
 
                  // apply spatial function
                  if (bc.d_spatialFnType == "hat_x") {
                    umax = bc.d_spatialFnParams[0] *
                           util::hatFunction(x.d_x, box.first.d_x,
                                             box.second.d_x);
                  } else if (bc.d_spatialFnType == "hat_y") {
                    umax = bc.d_spatialFnParams[0] *
                           util::hatFunction(x.d_y, box.first.d_y,
                                             box.second.d_y);
                  } else if (bc.d_spatialFnType == "sin_x") {
                    double a = M_PI * bc.d_spatialFnParams[0];
                    umax = umax * std::sin(a * x.d_x);
                  } else if (bc.d_spatialFnType == "sin_y") {
                    double a = M_PI * bc.d_spatialFnParams[0];
                    umax = umax * std::sin(a * x.d_y);
                  } else if (bc.d_spatialFnType == "linear_x") {
                    double a = bc.d_spatialFnParams[0];
                    umax = umax * a * x.d_x;
                  } else if (bc.d_spatialFnType == "linear_y") {
                    double a = bc.d_spatialFnParams[0];
                    umax = umax * a * x.d_y;
                  }
 
                  // apply time function
                  if (bc.d_timeFnType == "constant")
                    du = umax;
                  else if (bc.d_timeFnType == "linear") {
                    du = umax * time;
                    dv = umax;
                  } else if (bc.d_timeFnType == "quadratic") {
                    du = umax * time + bc.d_timeFnParams[1] * time * time;
                    dv = umax + bc.d_timeFnParams[1] * time;
                  } else if (bc.d_timeFnType == "sin") {
                    double a = M_PI * bc.d_timeFnParams[1];
                    du = umax * std::sin(a * time);
                    dv = umax * a * std::cos(a * time);
                  }
 
                  auto u_i = util::Point();
                  auto v_i = util::Point();
                  for (auto d : bc.d_direction) {
                    u_i[d-1] = du;
                    v_i[d-1] = dv;
                  }
 
                  if (bc.d_timeFnType == "rotation") {
                    auto x0 = util::Point(bc.d_timeFnParams[1], bc.d_timeFnParams[2],
                                          bc.d_timeFnParams[3]);
                    auto dx = x - x0;
                    auto r_x = util::rotate2D(
                            dx, bc.d_timeFnParams[0] * time);
                    auto dr_x = util::derRotate2D(
                            dx, bc.d_timeFnParams[0] * time);
 
                    u_i += r_x - dx;
                    v_i += bc.d_timeFnParams[0] * dr_x;
                  }
 
                  for (auto d : bc.d_direction) {
                    particle->setULocal(i, d-1, u_i[d-1]);
                    particle->setVLocal(i, d-1, v_i[d-1]);
                    auto xref = particle->getXRefLocal(i)[d-1];
                    particle->setXLocal(i, d-1, u_i[d-1] + xref);
                  }
                } // if compute displacement
    }
  } // loop over bc sets
}

References util::derRotate2D(), util::hatFunction(), loading::needToComputeDof(), loading::needToProcessParticle(), and util::rotate2D().

Here is the call graph for this function:

setFixity()

void loading::ParticleULoading::setFixity

(

particle::BaseParticle *

particle

)

Sets fixity mask.

Parameters

particle

Particle object pointer

Definition at line 26 of file particleULoading.cpp.

                                                                      {
 
  for (size_t s = 0; s < d_bcData.size(); s++) {
 
    // get alias for bc data
    const auto &bc = d_bcData[s];
 
    // check if we need to process this particle
    if (!needToProcessParticle(particle->getId(), bc))
      continue;
 
    for (size_t i = 0; i < particle->getNumNodes(); i++) {
 
      const auto x = particle->getXRefLocal(i);
 
      if (!needToComputeDof(x, particle->getId(), bc))
        continue;
 
      // set fixity to true
      for (auto d : bc.d_direction)
        particle->setFixLocal(i, d - 1, true);
    } // loop over nodes
  }   // loop over bc sets
}

References loading::needToComputeDof(), and loading::needToProcessParticle().

Here is the call graph for this function:

Field Documentation

d_pZeroDisplacementApplied

std::vector<bool> loading::ParticleULoading::d_pZeroDisplacementApplied

Flag to indicate whether particles are fixed.

Definition at line 58 of file particleULoading.h.

Referenced by ParticleULoading().

---

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

• /home/user/project/src/loading/particleULoading.h
• /home/user/project/src/loading/particleULoading.cpp