loading::ParticleFLoading Class Reference

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

#include <particleFLoading.h>

Inheritance diagram for loading::ParticleFLoading:

Collaboration diagram for loading::ParticleFLoading:

Public Member Functions
	ParticleFLoading (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	apply (const double &time, particle::BaseParticle *particle)
	Applies force boundary condition.
Public Member Functions inherited from loading::ParticleLoading
	ParticleLoading ()=default
	Constructor.

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 force boundary condition.

Definition at line 31 of file particleFLoading.h.

Constructor & Destructor Documentation

ParticleFLoading()

loading::ParticleFLoading::ParticleFLoading

(

std::vector< inp::PBCData > &

bc_data

)

Constructor.

Parameters

bc_data

Boundary condition data

Definition at line 31 of file particleFLoading.cpp.

                                    {
 
  d_bcData = bc_data;
}

References loading::ParticleLoading::d_bcData.

Member Function Documentation

apply()

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

Applies force boundary condition.

Parameters

time	Current time
particle	Particle object pointer

Definition at line 85 of file particleFLoading.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;
 
    // 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 fmax = 1.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") {
                    fmax = bc.d_spatialFnParams[0] *
                           util::hatFunction(x.d_x, box.first.d_x,
                                             box.second.d_x);
                  } else if (bc.d_spatialFnType == "hat_y") {
                    fmax = 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];
                    fmax = bc.d_spatialFnParams[0] * std::sin(a * x.d_x);
                  } else if (bc.d_spatialFnType == "sin_y") {
                    double a = M_PI * bc.d_spatialFnParams[0];
                    fmax = bc.d_spatialFnParams[0] * std::sin(a * x.d_y);
                  } else if (bc.d_spatialFnType == "linear_x") {
                    double a = bc.d_spatialFnParams[0];
                    fmax = bc.d_spatialFnParams[0] * a * x.d_x;
                  } else if (bc.d_spatialFnType == "linear_y") {
                    double a = bc.d_spatialFnParams[0];
                    fmax = bc.d_spatialFnParams[0] * a * x.d_y;
                  }
 
                  // apply time function
                  if (bc.d_timeFnType == "linear")
                    fmax *= time;
                  else if (bc.d_timeFnType == "linear_step")
                    fmax *= util::linearStepFunc(time, bc.d_timeFnParams[1],
                                                 bc.d_timeFnParams[2]);
                  else if (bc.d_timeFnType == "linear_slow_fast") {
                    if (util::isGreater(time, bc.d_timeFnParams[1]))
                      fmax *= bc.d_timeFnParams[3] * time;
                    else
                      fmax *= bc.d_timeFnParams[2] * time;
                  } else if (bc.d_timeFnType == "sin") {
                    double a = M_PI * bc.d_timeFnParams[1];
                    fmax *= std::sin(a * time);
                  }
 
                  // multiply by the slope
                  fmax *= bc.d_timeFnParams[0];
 
                  auto force_i = util::Point();
                  for (auto d : bc.d_direction) {
                    force_i[d-1] = fmax;
                  }
 
                  // add force
                  particle->addFLocal(i, force_i);
                } // if compute force
            }
    ); // for_each
 
    executor.run(taskflow).get();
  } // loop over bc sets
}

References util::parallel::getNThreads(), util::isGreater(), and util::linearStepFunc().

Here is the call graph for this function:

needToComputeDof()

bool loading::ParticleFLoading::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 55 of file particleFLoading.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::ParticleFLoading::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 37 of file particleFLoading.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.

---

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

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