StressStrainControlBoundary Class Reference

A cuboid box consists of periodic boundaries that can be strain/stress controlled and achieve different deformation modes. User needs to define target stress/strainrate matrix, gain_factor and a boolean parameter isStrainRateControlled to True/False to activate/deactivate strainrate control. More...

#include <StressStrainControlBoundary.h>

Inheritance diagram for StressStrainControlBoundary:

Public Member Functions
	StressStrainControlBoundary ()
	default constructor. More...
	StressStrainControlBoundary (const StressStrainControlBoundary &b)=default
	copy constructor. More...
virtual	~StressStrainControlBoundary ()=default
	destructor. More...
void	read (std::istream &is) override
	Reads the object's id_ from given istream. More...
void	write (std::ostream &os) const override
	Adds object's id_ to given ostream. More...
std::string	getName () const override
	Sets the name of the boundary. More...
StressStrainControlBoundary *	copy () const override
	Used to create a copy of the object. More...
void	checkBoundaryAfterParticlesMove (ParticleHandler &particleHandler) override
	Virtual function that does things to particles, each timestep after particles have moved. More...
void	set (const Matrix3D &stressGoal, const Matrix3D &strainRate, const Matrix3D &gainFactor, bool isStrainRateControlled)
	Sets all boundary inputs at once and determines which deformation mode it is, then combine the right boundaries to assemble the cuboid box/domain. More...
void	setStrainRate (const Matrix3D &strainRate)
void	createPeriodicParticles (ParticleHandler &particleHandler) override
	Create the periodic particles after read in from a restart file to attain right information. More...
void	checkPeriodicLeesEdwardsBoundariesAfterParticlesMove (ParticleHandler &particleHandler)
	Call the boundary and update them based on the new domain size after the stress-control movement. More...
void	determineLengthAndCentre ()
	Determine the length in x,y,z and center location of domain. More...
void	activateStrainRateControl (const ParticleHandler &particleHandler)
	Activate the strainrate control for particle movement based on user's boolean input. More...
void	computeStrainRate ()
	Compute the change of strainrate tensor based on the stress difference and then update the tensor. More...
void	determineStressControlledShearBoundaries ()
	Determines stress-controlled shear Lees-Edwards boundary in x-y direction and normal periodic in z direction. More...
void	updateDomainSize ()
	Update the domain to new sizes. More...
Matrix3D	getStrainRate () const
	Accesses the strainrate tensor. More...
Matrix3D	getStressGoal () const
	Accesses the target stress tensor. More...
Matrix3D	getGainFactor () const
	Accesses the gainFactor. More...
Mdouble	computeStressError ()
double	getIntegratedShift () const
Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...
	BaseBoundary (const BaseBoundary &b)
	copy constructor More...
	~BaseBoundary () override
	destructor More...
virtual void	createPeriodicParticle (BaseParticle *p UNUSED, ParticleHandler &pH UNUSED)
	Creates a periodic particle in case of periodic boundaries in serial build. More...
virtual void	createPeriodicParticles (ParticleHandler &pH UNUSED)
	Creates periodic copies of given particle in case of periodic boundaries. More...
virtual void	checkBoundaryBeforeTimeStep (DPMBase *md)
	Virtual function that does things before each time step. More...
virtual void	actionsBeforeTimeLoop ()
	Virtual function that does something after DPMBase::setupInitialConditions but before the first time step. More...
virtual void	modifyGhostAfterCreation (BaseParticle *particle, int i)
virtual void	writeVTK (std::fstream &file)
void	setHandler (BoundaryHandler *handler)
	Sets the boundary's BoundaryHandler. More...
BoundaryHandler *	getHandler () const
	Returns the boundary's BoundaryHandler. More...
Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...
	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...
virtual	~BaseObject ()=default
	virtual destructor More...
virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...
void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...
void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...
unsigned int	getIndex () const
	Returns the index of the object in the handler. More...
unsigned int	getId () const
	Returns the unique identifier of any particular object. More...
void	setGroupId (unsigned groupId)
unsigned	getGroupId () const

Private Attributes
Matrix3D	stressGoal_
	Stores the stress value the boundary should attain. More...
Matrix3D	strainRate_
Matrix3D	gainFactor_
bool	isStrainRateControlled_
	The boolean input, true means switch on the strain rate control for particles affine movements. More...
Mdouble	integratedShift_
	Shift integrated for all the time when using Lees-Edwards Boundary. More...
std::vector< LeesEdwardsBoundary >	leesEdwardsBoundaries_
std::vector< PeriodicBoundary >	periodicBoundaries_

Detailed Description

A cuboid box consists of periodic boundaries that can be strain/stress controlled and achieve different deformation modes. User needs to define target stress/strainrate matrix, gain_factor and a boolean parameter isStrainRateControlled to True/False to activate/deactivate strainrate control.

Inherits from BaseObject, combining the PeriodicBoundary and LeesEdwardsBoundary. This boundary takes matrices inputs from user and determine which boundaries should be combined together and therefore achieve different deformation mode: e.g. triaxial, bi-aixial, uni-axial and simple shear. The Lees-Edwards boundary is only activated when there is a target shear stress/strainrate set in the matrix. Note that the same component can only be set in either target stress matrix or strainrate matrix, i.e. if the target shear stress XY is set to a constant, the strainrate_XY has to be set to 0, or just leave it free, it is by default set to 0. Note also there are 9 components in the stress/strainrate tensor but we only support the following components due to the boundary inheritance: XX, YY, ZZ, XY

Constructor & Destructor Documentation

StressStrainControlBoundary() [1/2]

StressStrainControlBoundary::StressStrainControlBoundary

(

)

default constructor.

constructor, set all the parameters that boundary needs as inputs to zero.

        : BaseBoundary()
{
    stressGoal_.setZero();
    strainRate_.setZero();
    gainFactor_.setZero();
    isStrainRateControlled_ = true;
    integratedShift_ = 0.0;
    //
    logger(DEBUG, "StressStrainControlBoundary::StressStrainControlBoundary() finished");
}

References DEBUG, gainFactor_, integratedShift_, isStrainRateControlled_, logger, Matrix3D::setZero(), strainRate_, and stressGoal_.

Referenced by copy().

StressStrainControlBoundary() [2/2]

StressStrainControlBoundary::StressStrainControlBoundary ( const StressStrainControlBoundary &  b )

default

copy constructor.

~StressStrainControlBoundary()

virtual StressStrainControlBoundary::~StressStrainControlBoundary ( )

virtualdefault

destructor.

Member Function Documentation

activateStrainRateControl()

void StressStrainControlBoundary::activateStrainRateControl

(

const ParticleHandler &

particleHandler

)

Activate the strainrate control for particle movement based on user's boolean input.

This function activate the strain rate control based on user inputs, it takes only the strainRate_ tensor and move particles based on this tensor, also move boundaries based on the new domain size.

{
    const DPMBase* const dpm = getHandler()->getDPMBase();
    // update the domain size based on the new strain rate tensor
    updateDomainSize();
    
    //  Move the boundaries to next time step
    if (strainRate_.XY != 0 || stressGoal_.XY != 0)
    {
        determineStressControlledShearBoundaries();
    }
    else
    {
        //  Move the boundary in x direction to next time step
        periodicBoundaries_[0].set(Vec3D(1.0, 0.0, 0.0), dpm->getXMin(), dpm->getXMax());
        //  Move the boundary in y direction to next time step
        periodicBoundaries_[1].set(Vec3D(0.0, 1.0, 0.0), dpm->getYMin(), dpm->getYMax());
        //  Move the boundary in z direction to next time step
        periodicBoundaries_[2].set(Vec3D(0.0, 0.0, 1.0), dpm->getZMin(), dpm->getZMax());
    }
    
    //  Give the strain-rate for all particles and move them to next time step before integration
    if (isStrainRateControlled_)
    {
        for (auto& p : particleHandler)
        {
            // Box length Lx, Ly and Lz, and center point C of the box
            Vec3D centerBox;
            centerBox.X = (dpm->getXMax() + dpm->getXMin()) / 2.0;
            centerBox.Y = (dpm->getYMax() + dpm->getYMin()) / 2.0;
            centerBox.Z = (dpm->getZMax() + dpm->getZMin()) / 2.0;
            Vec3D relativeToCenter;
            relativeToCenter.X = p->getPosition().X - centerBox.X;
            relativeToCenter.Y = p->getPosition().Y - centerBox.Y;
            relativeToCenter.Z = p->getPosition().Z - centerBox.Z;
            p->move(Vec3D(strainRate_.XX * dpm->getTimeStep() * relativeToCenter.X +
                          strainRate_.XY * dpm->getTimeStep() * relativeToCenter.Y,
                          strainRate_.YY * dpm->getTimeStep() * relativeToCenter.Y,
                          strainRate_.ZZ * dpm->getTimeStep() * relativeToCenter.Z));
        }
    }
}

References determineStressControlledShearBoundaries(), BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTimeStep(), DPMBase::getXMax(), DPMBase::getXMin(), DPMBase::getYMax(), DPMBase::getYMin(), DPMBase::getZMax(), DPMBase::getZMin(), isStrainRateControlled_, periodicBoundaries_, strainRate_, stressGoal_, updateDomainSize(), Vec3D::X, Matrix3D::XX, Matrix3D::XY, Vec3D::Y, Matrix3D::YY, Vec3D::Z, and Matrix3D::ZZ.

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void StressStrainControlBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  particleHandler )

overridevirtual

Virtual function that does things to particles, each timestep after particles have moved.

This is where the stress-strain control is implemented and the boundary will be checked at each time step to make sure the target stress/strain rate are achieved.

Reimplemented from BaseBoundary.

{
    checkPeriodicLeesEdwardsBoundariesAfterParticlesMove(particleHandler);
    
    //Real Stress and StrainRate Control every time step
    logger.assert_debug(getHandler() != nullptr,
                  "you need to set the handler of this boundary before the parameters can be set");
    
    determineLengthAndCentre();
    
    //this checks if stressGoal matrix is non-zero and then activate only the stress control
    if (stressGoal_.XX != 0 || stressGoal_.YY != 0 || stressGoal_.ZZ != 0 ||
        stressGoal_.XY != 0)
    {
        //the strain rate in the corresponding direction will be calculated
        computeStrainRate();
    }
    activateStrainRateControl(particleHandler);
}

References activateStrainRateControl(), checkPeriodicLeesEdwardsBoundariesAfterParticlesMove(), computeStrainRate(), determineLengthAndCentre(), BaseBoundary::getHandler(), logger, stressGoal_, Matrix3D::XX, Matrix3D::XY, Matrix3D::YY, and Matrix3D::ZZ.

checkPeriodicLeesEdwardsBoundariesAfterParticlesMove()

void StressStrainControlBoundary::checkPeriodicLeesEdwardsBoundariesAfterParticlesMove

(

ParticleHandler &

particleHandler

)

Call the boundary and update them based on the new domain size after the stress-control movement.

This function checks the boundaries after the particles are moved, to serve the stress-control for the following steps.

{
    // Call Boundaries
    for (PeriodicBoundary& b : periodicBoundaries_)
    {
        b.checkBoundaryAfterParticlesMove(particleHandler);
    }
    for (LeesEdwardsBoundary& b : leesEdwardsBoundaries_)
    {
        b.checkBoundaryAfterParticlesMove(particleHandler);
    }
}

References leesEdwardsBoundaries_, and periodicBoundaries_.

Referenced by checkBoundaryAfterParticlesMove().

computeStrainRate()

void StressStrainControlBoundary::computeStrainRate

(

)

Compute the change of strainrate tensor based on the stress difference and then update the tensor.

This function is used to compute the new strain rate tensor based on the stress differences between the actual and user set target values.

{
    // calculate the stress total and average over the volume
    Matrix3D stress = getHandler()->getDPMBase()->getTotalStress();
 
    // controller
    // amount by which the strain rate tensor has to be changed
    if (stressGoal_.XX != 0)
    {
//        Mdouble stressError=(stress.XX- stressGoal_.XX);         // Calculate the Error
//        static PIController xx(0.1,gainFactor_.XX);
//        strainRate_.XX = xx.apply(stressError,timeStep);      // Controller Command
//        logger(VERBOSE, "StressXX = %",stress.XX);
        strainRate_.XX = gainFactor_.XX * (stress.XX - stressGoal_.XX);
    }
    if (stressGoal_.YY != 0)
    {
        strainRate_.YY = gainFactor_.YY * (stress.YY - stressGoal_.YY);
    }
    if (stressGoal_.ZZ != 0)
    {
        strainRate_.ZZ = gainFactor_.ZZ * (stress.ZZ - stressGoal_.ZZ);
    }
    if (stressGoal_.XY != 0)
    {
        strainRate_.XY = gainFactor_.XY * (stress.XY - stressGoal_.XY);
    }
}

References gainFactor_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTotalStress(), strainRate_, stressGoal_, Matrix3D::XX, Matrix3D::XY, Matrix3D::YY, and Matrix3D::ZZ.

Referenced by checkBoundaryAfterParticlesMove().

computeStressError()

Mdouble StressStrainControlBoundary::computeStressError

(

)

                                                       {
    Matrix3D stress = getHandler()->getDPMBase()->getTotalStress();
    return (stress.XX- stressGoal_.XX);
}

References BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTotalStress(), stressGoal_, and Matrix3D::XX.

copy()

StressStrainControlBoundary * StressStrainControlBoundary::copy ( ) const

overridevirtual

Used to create a copy of the object.

Copy method; creates a copy on the boundary and returns its pointer.

Implements BaseBoundary.

{
    return new StressStrainControlBoundary(*this);
}

References StressStrainControlBoundary().

createPeriodicParticles()

void StressStrainControlBoundary::createPeriodicParticles ( ParticleHandler &  particleHandler )

override

Create the periodic particles after read in from a restart file to attain right information.

This function is used to create ghost particles such that the stress are calculated correctly after restart from another configuration.

{
    // Call Boundaries
    for (PeriodicBoundary& b : periodicBoundaries_)
    {
        b.createPeriodicParticles(particleHandler);
    }
    for (LeesEdwardsBoundary& b : leesEdwardsBoundaries_)
    {
        b.createPeriodicParticles(particleHandler);
    }
}

References leesEdwardsBoundaries_, and periodicBoundaries_.

determineLengthAndCentre()

void StressStrainControlBoundary::determineLengthAndCentre

(

)

Determine the length in x,y,z and center location of domain.

This function determines both the length in x,y,z direction and center location of the domain.

{
//    const DPMBase* const dpm = getHandler()->getDPMBase();
}

Referenced by checkBoundaryAfterParticlesMove().

determineStressControlledShearBoundaries()

void StressStrainControlBoundary::determineStressControlledShearBoundaries

(

)

Determines stress-controlled shear Lees-Edwards boundary in x-y direction and normal periodic in z direction.

This function determines the boundary for stress-controlled shear situation. In this case, the Lees-Edwards boundary in x-y directions and normal periodic boundary in z direction are combined together as a cuboid shear box.

{
    const DPMBase* const dpm = getHandler()->getDPMBase();
    //Determine the current shear velocity and shift of the Lees-Edwards boundary
    const Mdouble velocity_xy = strainRate_.XY * (dpm->getXMax() - dpm->getXMin());
    integratedShift_ += velocity_xy * dpm->getTimeStep();
    
    // Determine how to move boundaries based on strain rate control or boundary control
    if (isStrainRateControlled_)
    {
        //  Move the Lees-Edwards boundary in z direction to next time step
        leesEdwardsBoundaries_[0].set(
                [this](Mdouble time)
                { return integratedShift_; },
                [](Mdouble time UNUSED)
                { return 0; },
                dpm->getXMin(), dpm->getXMax(), dpm->getYMin(), dpm->getYMax());
    }
    else
    {
        //  Update the velocity of Lees-Edwards boundary in x-y direction to next time step
        leesEdwardsBoundaries_[0].set(
                [this](Mdouble time)
                { return integratedShift_; },
                [velocity_xy](Mdouble time UNUSED)
                { return velocity_xy; },
                dpm->getXMin(), dpm->getXMax(), dpm->getYMin(), dpm->getYMax());
    }
    //  Move the boundary in z direction to next time step
    periodicBoundaries_[0].set(Vec3D(0.0, 0.0, 1.0), dpm->getZMin(), dpm->getZMax());
}

References BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTimeStep(), DPMBase::getXMax(), DPMBase::getXMin(), DPMBase::getYMax(), DPMBase::getYMin(), DPMBase::getZMax(), DPMBase::getZMin(), integratedShift_, isStrainRateControlled_, leesEdwardsBoundaries_, periodicBoundaries_, strainRate_, UNUSED, and Matrix3D::XY.

Referenced by activateStrainRateControl().

getGainFactor()

Matrix3D StressStrainControlBoundary::getGainFactor ( ) const

inline

Accesses the gainFactor.

{return gainFactor_;}

References gainFactor_.

getIntegratedShift()

double StressStrainControlBoundary::getIntegratedShift ( ) const

inline

{return integratedShift_;}

References integratedShift_.

getName()

std::string StressStrainControlBoundary::getName ( ) const

overridevirtual

Sets the name of the boundary.

Returns the name of the object class.

Returns

the object class' name.

Implements BaseObject.

{
    return "StressStrainControlBoundary";
}

getStrainRate()

Matrix3D StressStrainControlBoundary::getStrainRate ( ) const

inline

Accesses the strainrate tensor.

{return strainRate_;}

References strainRate_.

Referenced by ShearStage::actionsAfterTimeStep(), ShearStage::printTime(), and ShearStage::ShearStage().

getStressGoal()

Matrix3D StressStrainControlBoundary::getStressGoal ( ) const

inline

Accesses the target stress tensor.

{return stressGoal_;}

References stressGoal_.

read()

void StressStrainControlBoundary::read ( std::istream &  is )

overridevirtual

Reads the object's id_ from given istream.

Reads the boundary properties from an istream.

Parameters

[in]

is

the istream.

Implements BaseBoundary.

{
    BaseBoundary::read(is);
    std::string dummy;
    is >> dummy >> stressGoal_;
    is >> dummy >> strainRate_;
    is >> dummy >> gainFactor_;
    is >> dummy >> isStrainRateControlled_;
    set(stressGoal_, strainRate_, gainFactor_, isStrainRateControlled_);
    is >> dummy >> integratedShift_;
}

References gainFactor_, integratedShift_, isStrainRateControlled_, BaseBoundary::read(), set(), strainRate_, and stressGoal_.

set()

void StressStrainControlBoundary::set	(	const Matrix3D &	stressGoal,
		const Matrix3D &	strainRate,
		const Matrix3D &	gainFactor,
		bool	isStrainRateControlled
	)

Sets all boundary inputs at once and determines which deformation mode it is, then combine the right boundaries to assemble the cuboid box/domain.

This function sets the inputs for the whole StressStrainControlBoundary based on the user inputs.

Parameters

[in]	stressGoal	The target stress tensor that needs to achieve at the end of the deformation.
[in]	strainRate	The target strain rate tensor, cannot be set non-zero with target Stress, i.e. stressGoal.XX != 0, then strainRate.XX = 0.
[in]	gainFactor	The incremental factor for the stress control, usually a very small value ~ 0.0001.
[in]	isStrainRateControlled	The boolean key to determine whether particles are moved by strain rate affine movement (true) or dragged by boundary itself (false).

{
    periodicBoundaries_.clear();
    leesEdwardsBoundaries_.clear();
 
    isStrainRateControlled_ = isStrainRateControlled;
    stressGoal_ = stressGoal;
    strainRate_ = strainRate;
    gainFactor_ = gainFactor;
 
    logger.assert_always(stressGoal.XZ == 0, "Shear stress in XZ cannot be controlled; use shear stress in XY instead");
    logger.assert_always(stressGoal.ZX == 0, "Shear stress in ZX cannot be controlled; use shear stress in XY instead");
    logger.assert_always(stressGoal.YZ == 0, "Shear stress in YZ cannot be controlled; use shear stress in XY instead");
    logger.assert_always(stressGoal.ZY == 0, "Shear stress in ZY cannot be controlled; use shear stress in XY instead");
    logger.assert_always(strainRate.XZ == 0, "Strain rate in XZ cannot be controlled; use strain rate in XY instead");
    logger.assert_always(strainRate.ZX == 0, "Strain rate in ZX cannot be controlled; use strain rate in XY instead");
    logger.assert_always(strainRate.YZ == 0, "Strain rate in YZ cannot be controlled; use strain rate in XY instead");
    logger.assert_always(strainRate.ZY == 0, "Strain rate in ZY cannot be controlled; use strain rate in XY instead");
    logger.assert_always(stressGoal.XZ != 0 ? gainFactor.XZ != 0 : true,
                         "You need to set a gain factor in XZ in order to control stress");
    logger.assert_always(stressGoal.XX != 0 ? gainFactor.XX != 0 : true,
                         "You need to set a gain factor in XX in order to control stress");
    logger.assert_always(stressGoal.YY != 0 ? gainFactor.YY != 0 : true,
                         "You need to set a gain factor in YY in order to control stress");
    logger.assert_always(stressGoal.ZZ != 0 ? gainFactor.ZZ != 0 : true,
                         "You need to set a gain factor in ZZ in order to control stress");
 
    logger.assert_always(getHandler() != nullptr, "You need to set the handler of this boundary");
    const DPMBase *dpm = getHandler()->getDPMBase();
 
    // if there is no shear (compression only)
    if (stressGoal_.XY == 0 && strainRate_.XY == 0)
    {
        logger(INFO, "Shear rate is zero, setting up three periodic boundaries");
        // Set up new box periodic boundaries, no simple shear activated
        PeriodicBoundary boundary;
        boundary.setHandler(getHandler());
        boundary.set(Vec3D(1.0, 0.0, 0.0), dpm->getXMin(), dpm->getXMax());
        periodicBoundaries_.push_back(boundary);
        boundary.set(Vec3D(0.0, 1.0, 0.0), dpm->getYMin(), dpm->getYMax());
        periodicBoundaries_.push_back(boundary);
        boundary.set(Vec3D(0.0, 0.0, 1.0), dpm->getZMin(), dpm->getZMax());
        periodicBoundaries_.push_back(boundary);
    }
    else
    {
        logger(INFO, "Shear rate is not zero, setting up Lees-Edwards in xy and a periodic boundary in z");
 
        PeriodicBoundary boundary;
        boundary.setHandler(getHandler());
        boundary.set(Vec3D(0.0, 0.0, 1.0), dpm->getZMin(), dpm->getZMax());
        periodicBoundaries_.push_back(boundary);
 
        // Lees Edwards bc in y direction & periodic boundary in x direction, simple shear boundary activated
        LeesEdwardsBoundary leesEdwardsBoundary;
        leesEdwardsBoundary.setHandler(getHandler());
        double integratedShift = integratedShift_;
        leesEdwardsBoundary.set(
                [&integratedShift](Mdouble time UNUSED) { return integratedShift; },
                [](Mdouble time UNUSED) { return 0; },
                dpm->getXMin(), dpm->getXMax(), dpm->getYMin(), dpm->getYMax());
        leesEdwardsBoundaries_.push_back(leesEdwardsBoundary);
    }
}

References gainFactor_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getXMax(), DPMBase::getXMin(), DPMBase::getYMax(), DPMBase::getYMin(), DPMBase::getZMax(), DPMBase::getZMin(), INFO, integratedShift_, isStrainRateControlled_, leesEdwardsBoundaries_, logger, periodicBoundaries_, LeesEdwardsBoundary::set(), PeriodicBoundary::set(), BaseBoundary::setHandler(), strainRate_, stressGoal_, UNUSED, Matrix3D::XX, Matrix3D::XY, Matrix3D::XZ, Matrix3D::YY, Matrix3D::YZ, Matrix3D::ZX, Matrix3D::ZY, and Matrix3D::ZZ.

Referenced by ShearStage::actionsAfterTimeStep(), read(), StressStrainControl::setupInitialConditions(), and ShearStage::ShearStage().

setStrainRate()

void StressStrainControlBoundary::setStrainRate

(

const Matrix3D &

strainRate

)

{
    strainRate_ = strainRate;
}

References strainRate_.

updateDomainSize()

void StressStrainControlBoundary::updateDomainSize

(

)

Update the domain to new sizes.

This function is used to update the domain size based on the strainRate tensor, note that the system is symmetric and therefore we have to update boundary in both Min and Max.

{
    DPMBase* const dpm = getHandler()->getDPMBase();
    // Box length Lx, Ly and Lz for next time step
    Vec3D lengthBox;
    lengthBox.X = (dpm->getXMax() - dpm->getXMin());
    lengthBox.Y = (dpm->getYMax() - dpm->getYMin());
    lengthBox.Z = (dpm->getZMax() - dpm->getZMin());
    //  Change the system size according to next time step
    dpm->setXMax(dpm->getXMax() + 0.5 * lengthBox.X * strainRate_.XX * dpm->getTimeStep());
    dpm->setXMin(dpm->getXMin() - 0.5 * lengthBox.X * strainRate_.XX * dpm->getTimeStep());
    dpm->setYMax(dpm->getYMax() + 0.5 * lengthBox.Y * strainRate_.YY * dpm->getTimeStep());
    dpm->setYMin(dpm->getYMin() - 0.5 * lengthBox.Y * strainRate_.YY * dpm->getTimeStep());
    dpm->setZMax(dpm->getZMax() + 0.5 * lengthBox.Z * strainRate_.ZZ * dpm->getTimeStep());
    dpm->setZMin(dpm->getZMin() - 0.5 * lengthBox.Z * strainRate_.ZZ * dpm->getTimeStep());
}

References BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTimeStep(), DPMBase::getXMax(), DPMBase::getXMin(), DPMBase::getYMax(), DPMBase::getYMin(), DPMBase::getZMax(), DPMBase::getZMin(), DPMBase::setXMax(), DPMBase::setXMin(), DPMBase::setYMax(), DPMBase::setYMin(), DPMBase::setZMax(), DPMBase::setZMin(), strainRate_, Vec3D::X, Matrix3D::XX, Vec3D::Y, Matrix3D::YY, Vec3D::Z, and Matrix3D::ZZ.

Referenced by activateStrainRateControl().

write()

void StressStrainControlBoundary::write ( std::ostream &  os ) const

overridevirtual

Adds object's id_ to given ostream.

Writes boundary's properties to an ostream.

Parameters

[in]

os

the ostream.

Implements BaseBoundary.

{
    BaseBoundary::write(os);
    os << " stressGoal " << stressGoal_;
    os << " strainRate " << strainRate_;
    os << " gainFactor " << gainFactor_;
    os << " isStrainRateControlled " << isStrainRateControlled_;
    os << " integratedShift " << integratedShift_;
//    os << leesEdwardsBoundaries_.size() << ' ';
//    for (const LeesEdwardsBoundary& b : leesEdwardsBoundaries_)
//    {
//        os << b << ' ';
//    }
//
//    os << periodicBoundaries_.size() << ' ';
//    for (const PeriodicBoundary& b : periodicBoundaries_)
//    {
//        os << b << ' ';
//    }
}

References gainFactor_, integratedShift_, isStrainRateControlled_, strainRate_, stressGoal_, and BaseBoundary::write().

Member Data Documentation

gainFactor_

Matrix3D StressStrainControlBoundary::gainFactor_

private

Referenced by computeStrainRate(), getGainFactor(), read(), set(), StressStrainControlBoundary(), and write().

integratedShift_

Mdouble StressStrainControlBoundary::integratedShift_

private

Shift integrated for all the time when using Lees-Edwards Boundary.

Referenced by determineStressControlledShearBoundaries(), getIntegratedShift(), read(), set(), StressStrainControlBoundary(), and write().

isStrainRateControlled_

bool StressStrainControlBoundary::isStrainRateControlled_

private

The boolean input, true means switch on the strain rate control for particles affine movements.

Referenced by activateStrainRateControl(), determineStressControlledShearBoundaries(), read(), set(), StressStrainControlBoundary(), and write().

leesEdwardsBoundaries_

std::vector<LeesEdwardsBoundary> StressStrainControlBoundary::leesEdwardsBoundaries_

private

Store boundaries into a vector for the pushback. Note, there is always either 0 LeesEdwardsBoundary (XY) and 3 PeriodicBoundary (XYZ), or 1 LeesEdwardsBoundary (XY) and 1 PeriodicBoundary (Z).

Referenced by checkPeriodicLeesEdwardsBoundariesAfterParticlesMove(), createPeriodicParticles(), determineStressControlledShearBoundaries(), and set().

periodicBoundaries_

std::vector<PeriodicBoundary> StressStrainControlBoundary::periodicBoundaries_

private

Referenced by activateStrainRateControl(), checkPeriodicLeesEdwardsBoundariesAfterParticlesMove(), createPeriodicParticles(), determineStressControlledShearBoundaries(), and set().

strainRate_

Matrix3D StressStrainControlBoundary::strainRate_

private

Referenced by activateStrainRateControl(), computeStrainRate(), determineStressControlledShearBoundaries(), getStrainRate(), read(), set(), setStrainRate(), StressStrainControlBoundary(), updateDomainSize(), and write().

stressGoal_

Matrix3D StressStrainControlBoundary::stressGoal_

private

Stores the stress value the boundary should attain.

Unused if the all stressGoal values are set to zero.

Referenced by activateStrainRateControl(), checkBoundaryAfterParticlesMove(), computeStrainRate(), computeStressError(), getStressGoal(), read(), set(), StressStrainControlBoundary(), and write().

---

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

• StressStrainControlBoundary.h
• StressStrainControlBoundary.cc