material Namespace Reference

Data Structures
class	BaseInfluenceFn
	A base class for computing influence function. More...
class	ConstInfluenceFn
	A class to implement constant influence function. More...
class	GaussianInfluenceFn
	A class to implement Gaussian influence function. More...
class	LinearInfluenceFn
	A class to implement linear influence function. More...
class	Material
	Collection of methods and database related to peridynamic material. More...
class	PdElastic
	A class providing methods to compute energy density and force of peridynamic material. More...
class	PdState
	A class providing methods to compute energy density and force of peridynamic material. More...
class	PmbMaterial
	A class providing methods to compute energy density and force of peridynamic material. More...
class	RnpMaterial
	A class providing methods to compute energy density and force of peridynamic material. More...

Functions
void	computeStateMx (model::ModelData *model, bool compute_in_parallel=false)
	Computes the moment \( m_x \) term in state-based peridynamic formulation.
void	computeStateThetax (model::ModelData *model, bool compute_in_parallel=false)
void	computeHydrostaticStrain (model::ModelData *model, bool compute_in_parallel=false)
void	updateBondFractureData (model::ModelData *model, bool compute_in_parallel=false)

Function Documentation

computeHydrostaticStrain()

void material::computeHydrostaticStrain	(	model::ModelData *	model,
		bool	compute_in_parallel = false
	)

Definition at line 293 of file materialUtil.cpp.

                                                                                       {
 
  model->d_thetaX.resize(model->d_x.size());
  if (!compute_in_parallel) {
    for (size_t i = 0; i < model->d_x.size(); i++) {
      const auto &pti = model->getPtId(i);
      const auto &particle = model->getParticleFromAllList(pti);
 
      auto thetax = computeHydrostaticStrainI(i, model->d_xRef, model->d_u,
                                        model->d_vol,
                                        model->d_neighPd, model->d_neighPdSqdDist,
                                        particle->getMeshSize(),
                                        particle->getMaterial(),
                                        model->d_fracture_p.get(),
                                        particle->getDimension());
 
      model->setThetax(i, thetax);
    }
  } else {
 
    tf::Executor executor(util::parallel::getNThreads());
    tf::Taskflow taskflow;
 
    taskflow.for_each_index(
      (std::size_t) 0, model->d_x.size(), (std::size_t) 1, [model](std::size_t i) {
        const auto &pti = model->getPtId(i);
        const auto &particle = model->getParticleFromAllList(pti);
 
        auto thetax = computeHydrostaticStrainI(i, 
          model->d_xRef, 
          model->d_u,
          model->d_vol,
          model->d_neighPd, model->d_neighPdSqdDist,
          particle->getMeshSize(),
          particle->getMaterial(),
          model->d_fracture_p.get(),
          particle->getDimension());
 
        model->setThetax(i, thetax);
      }
    ); // for_each
 
    executor.run(taskflow).get();
  }
 
}

References anonymous_namespace{materialUtil.cpp}::computeHydrostaticStrainI(), and util::parallel::getNThreads().

Here is the call graph for this function:

computeStateMx()

void material::computeStateMx	(	model::ModelData *	model,
		bool	compute_in_parallel = false
	)

Computes the moment \( m_x \) term in state-based peridynamic formulation.

Definition at line 211 of file materialUtil.cpp.

                                                                             {
 
  model->d_mX.resize(model->d_x.size());
  if (!compute_in_parallel) {
    for (size_t i = 0; i < model->d_x.size(); i++) {
      const auto &pti = model->getPtId(i);
      const auto &particle = model->getParticleFromAllList(pti);
      auto mx = computeStateMxI(i, model->d_xRef, model->d_vol,
                                model->d_neighPd, model->d_neighPdSqdDist,
                                particle->getMeshSize(),
                                particle->getMaterial());
 
      model->setMx(i, mx);
    }
  } else {
 
    tf::Executor executor(util::parallel::getNThreads());
    tf::Taskflow taskflow;
 
    taskflow.for_each_index(
      (std::size_t) 0, model->d_x.size(), (std::size_t) 1, [model](std::size_t i) {
        const auto &pti = model->getPtId(i);
        const auto &particle = model->getParticleFromAllList(pti);
        auto mx = computeStateMxI(i, model->d_xRef, model->d_vol,
                                  model->d_neighPd, model->d_neighPdSqdDist,
                                  particle->getMeshSize(),
                                  particle->getMaterial());
 
        model->setMx(i, mx);
      }
    ); // for_each
 
    executor.run(taskflow).get();
  }
}

References anonymous_namespace{materialUtil.cpp}::computeStateMxI(), and util::parallel::getNThreads().

Referenced by model::DEMModel::init().

Here is the call graph for this function:

Here is the caller graph for this function:

computeStateThetax()

void material::computeStateThetax	(	model::ModelData *	model,
		bool	compute_in_parallel = false
	)

Definition at line 247 of file materialUtil.cpp.

                                                                                 {
 
  model->d_thetaX.resize(model->d_x.size());
  if (!compute_in_parallel) {
    for (size_t i = 0; i < model->d_x.size(); i++) {
      const auto &pti = model->getPtId(i);
      const auto &particle = model->getParticleFromAllList(pti);
 
      auto thetax = computeStateThetaxI(i, model->d_xRef, model->d_u,
                                        model->d_vol,
                                        model->d_neighPd, model->d_neighPdSqdDist,
                                        particle->getMeshSize(),
                                      particle->getMaterial(),
                                        model->d_fracture_p.get(),
                                        model->d_mX);
 
      model->setThetax(i, thetax);
 
    }
 
  } else {
 
    tf::Executor executor(util::parallel::getNThreads());
    tf::Taskflow taskflow;
 
    taskflow.for_each_index(
      (std::size_t) 0, model->d_x.size(), (std::size_t) 1, [model](std::size_t i) {
        const auto &pti = model->getPtId(i);
        const auto &particle = model->getParticleFromAllList(pti);
 
        auto thetax = computeStateThetaxI(i, model->d_xRef, model->d_u,
                                          model->d_vol,
                                          model->d_neighPd, model->d_neighPdSqdDist,
                                          particle->getMeshSize(),
                                          particle->getMaterial(),
                                          model->d_fracture_p.get(),
                                          model->d_mX);
 
        model->setThetax(i, thetax);
      }
    ); // for_each
 
    executor.run(taskflow).get();
  }
}

References anonymous_namespace{materialUtil.cpp}::computeStateThetaxI(), and util::parallel::getNThreads().

Here is the call graph for this function:

updateBondFractureData()

void material::updateBondFractureData	(	model::ModelData *	model,
		bool	compute_in_parallel = false
	)

Definition at line 340 of file materialUtil.cpp.

                                                                                     {
 
  if (!compute_in_parallel) {
    for (size_t i = 0; i < model->d_x.size(); i++) {
      const auto &pti = model->getPtId(i);
      const auto &particle = model->getParticleFromAllList(pti);
 
      updateBondFractureDataI(i, model->d_xRef, model->d_neighPd, model->d_u,
                              particle->getMaterial(),
                                              model->d_fracture_p.get());
    }
  } else {
 
    tf::Executor executor(util::parallel::getNThreads());
    tf::Taskflow taskflow;
 
    taskflow.for_each_index(
      (std::size_t) 0, model->d_x.size(), (std::size_t) 1, [model](std::size_t i) {
        const auto &pti = model->getPtId(i);
        const auto &particle = model->getParticleFromAllList(pti);
 
        updateBondFractureDataI(i, 
          model->d_xRef, 
          model->d_neighPd, 
          model->d_u,
          particle->getMaterial(),
          model->d_fracture_p.get());
      }
    ); // for_each
 
    executor.run(taskflow).get();
  }
}

References util::parallel::getNThreads(), and anonymous_namespace{materialUtil.cpp}::updateBondFractureDataI().

Here is the call graph for this function: