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::PBCData > &bc_data)
	Constructor.
bool	needToProcessParticle (size_t id, const inp::PBCData &bc)
	Function that checks if given particle with id = id needs to be processed within boundary condition data bc.
bool	needToComputeDof (const util::Point &x, size_t id, const inp::PBCData &bc)
	Function that checks if we need to do computation at a given point x within a particle with id = id.
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::PBCData >	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::PBCData > &

bc_data

)

Constructor.

Parameters

bc_data

Boundary condition data

Definition at line 33 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 115 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, and if we have already applied
    // displacement then do not need to reapply this
    if (bc.d_isDisplacementZero && d_pZeroDisplacementApplied[s])
      continue;
 
    // set to true so that next time this is not called
    if (bc.d_isDisplacementZero)
      d_pZeroDisplacementApplied[s] = true;
 
    // 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->box();
 
    // for (size_t i = 0; i < particle->getNumNodes(); i++) {
    tf::Executor executor(util::parallel::getNThreads());
    tf::Taskflow taskflow;
 
    taskflow.for_each_index(
            (std::size_t) 0, particle->getNumNodes(), (std::size_t) 1,
            [time, &particle, bc, reg_box, this] (std::size_t 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
            }
    ); // for_each
 
    executor.run(taskflow).get();
  } // loop over bc sets
}

References util::derRotate2D(), util::parallel::getNThreads(), and util::rotate2D().

Here is the call graph for this function:

needToComputeDof()

bool loading::ParticleULoading::needToComputeDof	(	const util::Point &	x,
		size_t	id,
		const inp::PBCData &	bc
	)

Function that checks if we need to do computation at a given point x within a particle with id = id.

Parameters

x	Coordinates of a point within particle (reference coordinate)
id	Id of particle in all particle list
bc	Boundary condition data

Returns

bool True if we compute at x

Definition at line 60 of file particleULoading.cpp.

                                                                       {
 
  if (!bc.d_isRegionActive) {
    if (bc.d_selectionType == "particle" &&
        isInList(id, bc.d_pList))
      return true;
  }
  else {
    if (bc.d_selectionType == "region" && bc.d_regionGeomData.d_geom_p->isInside(x))
      return true;
    else if (bc.d_selectionType == "region_with_include_list" &&
             bc.d_regionGeomData.d_geom_p->isInside(x) &&
             isInList(id, bc.d_pList))
      return true;
    else if (bc.d_selectionType == "region_with_exclude_list" &&
             bc.d_regionGeomData.d_geom_p->isInside(x) &&
             !isInList(id, bc.d_pNotList))
      return true;
    else if (bc.d_selectionType == "region_with_include_list_with_exclude_list" &&
             bc.d_regionGeomData.d_geom_p->isInside(x) &&
             isInList(id, bc.d_pList) &&
             !isInList(id, bc.d_pNotList))
      return true;
  }
 
  return false;
}

References util::geometry::GeomData::d_geom_p, inp::PBCData::d_isRegionActive, inp::PBCData::d_pList, inp::PBCData::d_pNotList, inp::PBCData::d_regionGeomData, and inp::PBCData::d_selectionType.

needToProcessParticle()

bool loading::ParticleULoading::needToProcessParticle	(	size_t	id,
		const inp::PBCData &	bc
	)

Function that checks if given particle with id = id needs to be processed within boundary condition data bc.

Parameters

id	Id of particle in all particle list
bc	Boundary condition data

Returns

bool True if particle should be processed further

Definition at line 41 of file particleULoading.cpp.

                                                                                   {
 
  // if there is a list, and if particle is not in the list, skip
  bool skip_condition1 = (bc.d_selectionType == "particle"
                          || bc.d_selectionType == "region_with_include_list")
                         && !isInList(id, bc.d_pList);
  // if there is an exclusion list, and if particle is in the list, skip
  bool skip_condition2 = (bc.d_selectionType == "region_with_exclude_list")
                         && isInList(id, bc.d_pNotList);
  // if there is a inclusion and an exclusion list,
  // and if particle is either in the exclusion list or not in the inclusion list, skip
  bool skip_condition3 = (bc.d_selectionType == "region_with_include_list_with_exclude_list")
                         && (isInList(id, bc.d_pNotList) ||
                             !isInList(id, bc.d_pList));
 
  bool skip = skip_condition1 or skip_condition2 or skip_condition3;
  return !skip;
}

References inp::PBCData::d_pList, inp::PBCData::d_pNotList, and inp::PBCData::d_selectionType.

setFixity()

void loading::ParticleULoading::setFixity

(

particle::BaseParticle *

particle

)

Sets fixity mask.

Parameters

particle

Particle object pointer

Definition at line 90 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
}

Field Documentation

d_pZeroDisplacementApplied

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

Flag to indicate whether particles are fixed.

Definition at line 79 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