Logo Search packages:      
Sourcecode: yade version File versions  Download package

Public Types | Public Member Functions | Public Attributes

ThreeDTriaxialEngine Class Reference

Class for controlling in stress or in strain with respect to each spatial direction a cubical assembly of particles. More...

#include <ThreeDTriaxialEngine.hpp>

Inheritance diagram for ThreeDTriaxialEngine:
Inheritance graph
[legend]
Collaboration diagram for ThreeDTriaxialEngine:
Collaboration graph
[legend]

List of all members.

Public Types

enum  {
  wall_bottom = 0, wall_top, wall_left, wall_right,
  wall_front, wall_back
}
 

internal index values for retrieving walls


Public Member Functions

virtual void action ()
virtual void callPostLoad (void)
virtual void checkPyClassRegistersItself (const std::string &thisClassName) const
void computeStressStrain ()
 Compute stresses on walls as "Vector3r stress[6]", compute meanStress, strain[3] and mean strain.
Real ComputeUnbalancedForce (bool maxUnbalanced=false)
 Compute the mean/max unbalanced force in the assembly (normalized by mean contact force)
void controlExternalStress (int wall, Vector3r resultantForce, State *p, Real wall_max_vel)
 Regulate the stress applied on walls with flag wall_XXX_activated = true.
void controlInternalStress (Real multiplier)
 Regulate the mean stress by changing spheres size, WARNING : this function assumes that all dynamic bodies in the problem are spheres.
virtual string getBaseClassName (unsigned int i=0) const
virtual int getBaseClassNumber ()
Vector3r getStress (int boundId)
 ! Getter for stress in python
virtual bool isActivated ()
bool operator!= (const Serializable &other)
bool operator== (const Serializable &other)
virtual boost::python::dict pyDict () const
virtual void pyHandleCustomCtorArgs (boost::python::tuple &args, boost::python::dict &kw)
virtual void pyRegisterClass (boost::python::object _scope)
virtual void pySetAttr (const std::string &key, const boost::python::object &value)
std::string pyStr ()
 string representation of this object
void pyUpdateAttrs (const boost::python::dict &d)
 REGISTER_BASE_CLASS_NAME (Factorable)
 REGISTER_CLASS_NAME (Serializable)
 REGISTER_CLASS_NAME (Factorable)
template<class ArchiveT >
void serialize (ArchiveT &ar, unsigned int version)
void setContactProperties (Real frictionDegree)
 Change physical properties of interactions and/or bodies in the middle of a simulation (change only friction for the moment, complete this function to set cohesion and others before compression test)
void updateStiffness ()
 update the stiffness of boundary-packing interaction (sum of contacts stiffness on the boundary)
 YADE_CLASS_BASE_DOC (GlobalEngine, Engine,"Engine that will generally affect the whole simulation (contrary to PartialEngine).")
 YADE_CLASS_BASE_DOC_ATTRS_CTOR_PY (ThreeDTriaxialEngine, TriaxialStressController,"The engine perform a triaxial compression with a control in direction 'i' in stress (if stressControl_i) else in strain.\n\n""For a stress control the imposed stress is specified by 'sigma_i' with a 'max_veli' depending on 'strainRatei'. To obtain the same strain rate in stress control than in strain control you need to set 'wallDamping = 0.8'.\n""For a strain control the imposed strain is specified by 'strainRatei'.\n""With this engine you can also perform internal compaction by growing the size of particles by using ``TriaxialStressController::controlInternalStress``. For that, just switch on 'internalCompaction=1' and fix sigma_iso=value of mean pressure that you want at the end of the internal compaction.\n",((Real, strainRate1, 0,,"target strain rate in direction 1 (./s)"))((Real, currentStrainRate1, 0,,"current strain rate in direction 1 - converging to :yref:'ThreeDTriaxialEngine::strainRate1' (./s)"))((Real, strainRate2, 0,,"target strain rate in direction 2 (./s)"))((Real, currentStrainRate2, 0,,"current strain rate in direction 2 - converging to :yref:'ThreeDTriaxialEngine::strainRate2' (./s)"))((Real, strainRate3, 0,,"target strain rate in direction 3 (./s)"))((Real, currentStrainRate3, 0,,"current strain rate in direction 3 - converging to :yref:'ThreeDTriaxialEngine::strainRate3' (./s)"))((Real, UnbalancedForce, 1,,"mean resultant forces divided by mean contact force"))((Real, frictionAngleDegree,-1,,"Value of friction used in the simulation if (updateFrictionAngle)"))((bool, updateFrictionAngle, false,,"Switch to activate the update of the intergranular frictionto the value :yref:'ThreeDTriaxialEngine::frictionAngleDegree"))((bool, stressControl_1, true,,"Switch to choose a stress or a strain control in directions 1"))((bool, stressControl_2, true,,"Switch to choose a stress or a strain control in directions 2"))((bool, stressControl_3, true,,"Switch to choose a stress or a strain control in directions 3"))((std::string, Key,"",,"A string appended at the end of all files, use it to name simulations.")), translationAxisy=Vector3r(0, 1, 0);translationAxisx=Vector3r(1, 0, 0);translationAxisz=Vector3r(0, 0, 1);firstRun=true;boxVolume=0;,.def("setContactProperties",&ThreeDTriaxialEngine::setContactProperties,"Assign a new friction angle (degrees) to dynamic bodies and relative interactions")) DECLARE_LOGGER
 YADE_CLASS_BASE_DOC_ATTRS_INIT_CTOR_PY (TriaxialStressController, BoundaryController,"An engine maintaining constant stresses on some boundaries of a parallepipedic packing.",((unsigned int, stiffnessUpdateInterval, 10,,"target strain rate (./s)"))((unsigned int, radiusControlInterval, 10,,""))((unsigned int, computeStressStrainInterval, 10,,""))((Real, wallDamping, 0.25,,"wallDamping coefficient - wallDamping=0 implies a (theoretical) perfect control, wallDamping=1 means no movement"))((Real, thickness,-1,,""))((int, wall_bottom_id, 0,,"id of boundary ; coordinate 1-"))((int, wall_top_id, 0,,"id of boundary ; coordinate 1+"))((int, wall_left_id, 0,,"id of boundary ; coordinate 0-"))((int, wall_right_id, 0,,"id of boundary ; coordinate 0+"))((int, wall_front_id, 0,,"id of boundary ; coordinate 2+"))((int, wall_back_id, 0,,"id of boundary ; coordinate 2-"))((bool, wall_bottom_activated, true,,""))((bool, wall_top_activated, true,,""))((bool, wall_left_activated, true,,""))((bool, wall_right_activated, true,,""))((bool, wall_front_activated, true,,""))((bool, wall_back_activated, true,,""))((Real, height, 0,,""))((Real, width, 0,,""))((Real, depth, 0,,""))((Real, height0, 0,,""))((Real, width0, 0,,""))((Real, depth0, 0,,""))((Real, sigma_iso, 0,,"prescribed confining stress (see :yref:`TriaxialStressController::isAxisymetric`)"))((Real, sigma1, 0,,"prescribed stress on axis 1 (see :yref:`TriaxialStressController::isAxisymetric`)"))((Real, sigma2, 0,,"prescribed stress on axis 2 (see :yref:`TriaxialStressController::isAxisymetric`)"))((Real, sigma3, 0,,"prescribed stress on axis 3 (see :yref:`TriaxialStressController::isAxisymetric`)"))((bool, isAxisymetric, true,,"if true, sigma_iso is assigned to sigma1, 2 and 3 (applies at each iteration and overrides user-set values of s1,2,3)"))((Real, maxMultiplier, 1.001,,"max multiplier of diameters during internal compaction (initial fast increase - :yref:`TriaxialStressController::finalMaxMultiplier` is used in a second stage)"))((Real, finalMaxMultiplier, 1.00001,,"max multiplier of diameters during internal compaction (secondary precise adjustment - :yref:`TriaxialStressController::maxMultiplier` is used in the initial stage)"))((Real, max_vel, 0.001,,"Maximum allowed walls velocity [m/s]. This value superseeds the one assigned by the stress controller if the later is higher. max_vel can be set to infinity in many cases, but sometimes helps stabilizing packings. Based on this value, different maxima are computed for each axis based on the dimensions of the sample, so that if each boundary moves at its maximum velocity, the strain rate will be isotropic (see e.g. :yref:`TriaxialStressController::max_vel1`)."))((Real, previousStress, 0,,""))((Real, previousMultiplier, 1,,""))((bool, internalCompaction, true,,"Switch between 'external' (walls) and 'internal' (growth of particles) compaction."))((Real, meanStress, 0,,"Mean stress in the packing."))((Real, volumetricStrain, 0,,"Volumetric strain (see :yref:`TriaxialStressController::strain`)."))((Real, externalWork, 0,,"Energy provided by boundaries.")),, first=true;stiffness.resize(6);previousTranslation.assign(Vector3r::Zero());for(int i=0;i< 6;++i){normal[i]=stress[i]=force[i]=Vector3r::Zero();stiffness[i]=0;}normal[wall_bottom].y()=1;normal[wall_top].y()=-1;normal[wall_left].x()=1;normal[wall_right].x()=-1;normal[wall_front].z()=-1;normal[wall_back].z()=1;porosity=1;,.def_readonly("strain",&TriaxialStressController::strain,"Current strain (logarithmic).").def_readonly("porosity",&TriaxialStressController::porosity,"Porosity of the packing.").def_readonly("boxVolume",&TriaxialStressController::boxVolume,"Total packing volume.").def_readonly("spheresVolume",&TriaxialStressController::spheresVolume,"Total volume pf spheres.").def_readonly("max_vel1",&TriaxialStressController::max_vel1,"see :yref:`TriaxialStressController::max_vel` |ycomp|").def_readonly("max_vel2",&TriaxialStressController::max_vel2,"see :yref:`TriaxialStressController::max_vel` |ycomp|").def_readonly("max_vel3",&TriaxialStressController::max_vel3,"see :yref:`TriaxialStressController::max_vel` |ycomp|").def("stress",&TriaxialStressController::getStress,(python::arg("id")),"Return the mean stress vector acting on boundary 'id', with 'id' between 0 and 5.")) DECLARE_LOGGER

Public Attributes

Real boxVolume
 Value of box volume.
bool firstRun
 is this the beginning of the simulation, after reading the scene? -> it is the first time that Yade passes trought the engine ThreeDTriaxialEngine
Vector3r force [6]
Real max_vel1
Real max_vel2
Real max_vel3
Vector3r normal [6]
Real porosity
 Sample porosity.
Real position_back
Real position_bottom
Real position_front
Real position_left
Real position_right
Real position_top
boost::array< Vector3r, 6 > previousTranslation
 Stores the value of the translation at the previous time step, stiffness, and normal.
Scenescene
Real spheresVolume
 Value of spheres volume (solid volume)
vector< Real > stiffness
 The value of stiffness (updated according to stiffnessUpdateInterval)
Vector3r strain
Vector3r stress [6]
 The values of stresses.
shared_ptr< TimingDeltastimingDeltas
 precise profiling information (timing of fragments of the engine)
TimingInfo timingInfo
 high-level profiling information; not serializable
Vector3r translationAxisx
Vector3r translationAxisy
Vector3r translationAxisz
int wall_id [6]
 real index values of walls in the Scene

Detailed Description

Class for controlling in stress or in strain with respect to each spatial direction a cubical assembly of particles.

The engine perform a triaxial compression with a control in direction "i" in stress "if (stressControl_i)" else in strain. For a stress control the imposed stress is specified by "sigma_i" with a "max_veli" depending on "strainRatei". To obtain the same strain rate in stress control than in strain control you need to set "wallDamping = 0.8". For a strain control the imposed strain is specified by "strainRatei". With this engine you can perform internal compaction by growing the size of particles by using TriaxialStressController::controlInternalStress . For that, just switch on 'internalCompaction=1' and fix sigma_iso=value of mean pressure that you want at the end of the internal compaction.

Definition at line 28 of file ThreeDTriaxialEngine.hpp.


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

Generated by  Doxygen 1.6.0   Back to index