#include <friction.h>

Inheritance diagram for DiscreteCoulombFriction:

Collaboration diagram for DiscreteCoulombFriction:

Public Member Functions
	DiscreteCoulombFriction (const BasicScalarFunction *const ff, const doublereal s2, const doublereal vr)

void	SetValue (DataManager pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints ph=0, const unsigned int solution_startdof=0)

unsigned int	iGetNumDof (void) const

virtual std::ostream &	DescribeDof (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeDof (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual std::ostream &	DescribeEq (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeEq (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

DofOrder::Order	GetDofType (unsigned int i) const

DofOrder::Order	GetEqType (unsigned int i) const

doublereal	fc (void) const

void	AfterConvergence (const doublereal F, const doublereal v, const VectorHandler &X, const VectorHandler &XP, const unsigned int solution_startdof)

void	AssRes (SubVectorHandler &WorkVec, const unsigned int startdof, const unsigned int solution_startdof, const doublereal F, const doublereal v, const VectorHandler &X, const VectorHandler &XP) throw (Elem::ChangedEquationStructure)

void	AssJac (FullSubMatrixHandler &WorkMat, ExpandableRowVector &dfc, const unsigned int startdof, const unsigned int solution_startdof, const doublereal dCoef, const doublereal F, const doublereal v, const VectorHandler &X, const VectorHandler &XP, const ExpandableRowVector &dF, const ExpandableRowVector &dv) const

Public Member Functions inherited from SimulationEntity
	SimulationEntity (void)

virtual	~SimulationEntity (void)

virtual bool	bIsValidIndex (unsigned int i) const

virtual Hint *	ParseHint (DataManager pDM, const char s) const

virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const

virtual void	AfterPredict (VectorHandler &X, VectorHandler &XP)

virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

virtual unsigned int	iGetNumPrivData (void) const

virtual unsigned int	iGetPrivDataIdx (const char *s) const

virtual doublereal	dGetPrivData (unsigned int i) const

virtual std::ostream &	OutputAppend (std::ostream &out) const

virtual void	ReadInitialState (MBDynParser &HP)

Private Types
enum	tr_type { null, from_sticked_to_sliding, from_sticking_to_sliding, from_sliding_to_sticked, from_sliding_to_sticking }

enum	status_type { sticked, sticking, sliding }

Private Attributes
logical	converged_sticked

status_type	status

tr_type	transition_type

doublereal	converged_v

logical	first_iter

logical	first_switch

doublereal	previous_switch_v

doublereal	current_velocity

doublereal	saved_sliding_velocity

doublereal	saved_sliding_friction

doublereal	sigma2

doublereal	vel_ratio

doublereal	current_friction_force

const DifferentiableScalarFunction &	fss

doublereal	f

Additional Inherited Members
Public Types inherited from SimulationEntity
typedef std::vector< Hint * >	Hints

Detailed Description

A Coulomb model based on Morandini's ideas

Definition at line 207 of file friction.h.

Member Enumeration Documentation

enum DiscreteCoulombFriction::status_type

private

Enumerator
sticked
sticking
sliding

Definition at line 215 of file friction.h.

                         {
                 sticked,
                 sticking,
                 sliding};

enum DiscreteCoulombFriction::tr_type

private

Enumerator
null
from_sticked_to_sliding
from_sticking_to_sliding
from_sliding_to_sticked
from_sliding_to_sticking

Definition at line 209 of file friction.h.

                     {
                 null,
                 from_sticked_to_sliding,
                 from_sticking_to_sliding,
                 from_sliding_to_sticked,
                 from_sliding_to_sticking};

Constructor & Destructor Documentation

DiscreteCoulombFriction::DiscreteCoulombFriction	(	const BasicScalarFunction *const	ff,
		const doublereal	s2,
		const doublereal	vr
	)

Definition at line 267 of file friction.cc.

References NO_OP.

                                      :
 converged_sticked(true),
 status(sticked),
 transition_type(null),
 converged_v(0),
 first_iter(true),
 first_switch(true),
 previous_switch_v(0),
 current_velocity(0),
 sigma2(s2),
 vel_ratio(vr),
 current_friction_force(0),
 fss(dynamic_cast<const DifferentiableScalarFunction&>(*ff)),
 f(0)
 {
         NO_OP;
 }

Member Function Documentation

void DiscreteCoulombFriction::AfterConvergence	(	const doublereal	F,
		const doublereal	v,
		const VectorHandler &	X,
		const VectorHandler &	XP,
		const unsigned int	solution_startdof
	)

virtual

Reimplemented from BasicFriction.

Definition at line 346 of file friction.cc.

References converged_v, current_velocity, f, first_iter, first_switch, null, previous_switch_v, sliding, status, sticked, sticking, and transition_type.

                                               {
         f = X(solution_startdof+1);
 //      std::cerr << " ** ";
 //      std::cerr << f << " " << v << " " << status << " " << transition_type << " ";
         converged_v = v;
         current_velocity = v;
         previous_switch_v = v;
         transition_type = null;
         first_iter = true;
         first_switch = true;
         if (status == sticking) {
 //*             std::cerr << "sticking" << std::endl;
                 status = sticked;
         } else if (status == sliding) {
 //*             std::cerr << "sliding" << std::endl;
         } else {
 //*             std::cerr << "sticked" << std::endl;
         }
 //      std::cerr << status << " " << transition_type << std::endl;
 //*     std::cerr << "CONVERGENZA; v = " << v << "; f = " << f << std::endl;
 };

void DiscreteCoulombFriction::AssJac	(	FullSubMatrixHandler &	WorkMat,
		ExpandableRowVector &	dfc,
		const unsigned int	startdof,
		const unsigned int	solution_startdof,
		const doublereal	dCoef,
		const doublereal	F,
		const doublereal	v,
		const VectorHandler &	X,
		const VectorHandler &	XP,
		const ExpandableRowVector &	dF,
		const ExpandableRowVector &	dv
	)		const

virtual

Compute self jacobian and friction coefficient derivatives

Implements BasicFriction.

Definition at line 501 of file friction.cc.

References ExpandableRowVector::Add(), DifferentiableScalarFunction::ComputeDiff(), current_friction_force, fss, FullSubMatrixHandler::IncCoef(), ExpandableRowVector::Link(), ExpandableRowVector::ReDim(), ExpandableRowVector::Set(), sigma2, sign(), sliding, status, sticked, sticking, and ExpandableRowVector::Sub().

                                              {
 //*     std::cerr << "Chimata jacobiano. Status:" << status << std::endl;
         switch (status) {
         case sticking: 
         case sticked: {
                 //null velocity at the end of time step
                 //WorkVec.IncCoef(startdof+1,v);
                 dv.Sub(WorkMat,startdof+1);
                 dfc.ReDim(1);
                 dfc.Set(1.,1,startdof+1);
                 break;
         }
         case sliding: {
                 //still sliding
                 //cur_sticking = false;
                 //save friction force value in the (algebric) state
                 //WorkVec.IncCoef(startdof+1,f-current_friction_force);
                 WorkMat.IncCoef(startdof+1,startdof+1,-1);
                 dv.Add(WorkMat,startdof+1,
                         sign(current_friction_force)*fss.ComputeDiff(v)+sigma2);
                 dfc.ReDim(1);
                 dfc.Set(sign(current_friction_force-sigma2*v)*fss.ComputeDiff(v)+sigma2,1); dfc.Link(1, &dv);
                 break;
         }
         default: {
                 silent_cerr("DiscreteCoulombFriction::AssJac() "
                         "logical error" << std::endl);
         }
         }
 };

Here is the call graph for this function:

void DiscreteCoulombFriction::AssRes	(	SubVectorHandler &	WorkVec,
		const unsigned int	startdof,
		const unsigned int	solution_startdof,
		const doublereal	F,
		const doublereal	v,
		const VectorHandler &	X,
		const VectorHandler &	XP
	)
throw	(	Elem::ChangedEquationStructure
	)

virtual

Compute self residual and friction coefficient

Implements BasicFriction.

Definition at line 374 of file friction.cc.

References grad::fabs(), MBDYN_EXCEPT_ARGS, and sign().

                                                                      {
 //      std::cerr << "Chimata residuo. Status:" << status << std::endl;
         f = X(solution_startdof+1);
 //      if ((std::fabs(f)-fss(0) > 1.0E-6) && (first_iter == false)) {
 //*     std::cerr << "Attrito: " << f << " " << (std::fabs(f)-fss(0))/fss(0) << " - " << std::endl;
 //*     std::cerr << "v: " << v << std::endl; 
         transition_type = null;
 //      std::cerr << "Attrito: " << f << " " << std::fabs(f)/fss(0) << " - " << std::endl;
 //      if ((std::fabs(std::fabs(f)-fss(0))/fss(0) > 1.0E-6)) {
         if (std::fabs(f)-fss(0) > 1.0E-6*fss(0)) {
                 //unconditionally switch to sliding
                 if (status == sticked) {
                         transition_type = from_sticked_to_sliding;
 //*                     std::cerr << "switch to sliding from sticked: " << transition_type << std::endl;
                 } else if (status == sticking) {
                         transition_type = from_sticking_to_sliding;
 //*                     std::cerr << "switch to sliding from sticking: " << transition_type << std::endl;
                 } else if (status == sliding) {
                         //do nothing
 //                      std::cerr << "DiscreteCoulombFriction::AssRes message:\n"
 //                              << "you shold not go here1! What's wrong?\n"
 //                              << "status: " << status << "\n"
 //                              << "transition: " << transition_type << "\n"
 //                              << "error: " << fabs(f)-fss(0)
 //                              << std::endl;
                 } else {
                         silent_cerr("DiscreteCoulombFriction::AssRes() "
                                         "logical error1" << std::endl);
                 }
                 status = sliding;
         }
         //else 
         if (status == sliding) {
 //              std::cerr << "v*current_velocity: " << v*current_velocity << std::endl;
                 if (v*current_velocity < 0.) {
 //*                     std::cerr << "sono dentro; v: " << v << 
 //*                             " previous_switch_v: " << previous_switch_v << std::endl;
 //*                     std::cerr << "current velocity: " << current_velocity << std::endl;
                         if (((transition_type != from_sticked_to_sliding) ||
                                 (transition_type != from_sticking_to_sliding)) &&
                                 ((std::fabs(v-current_velocity) < std::fabs(previous_switch_v)) ||
                                         (first_switch == true))) {
 //*                             std::cerr << "Passo a sticking $$" << std::endl;;
                                 first_switch = false;
                                 status = sticking;
                                 transition_type = from_sliding_to_sticking;
                                 previous_switch_v = vel_ratio*(v-current_velocity);
                                 saved_sliding_velocity = v;
                                 saved_sliding_friction = f;
 //                              std::cerr << "switch to sticking: " << transition_type << std::endl;
                         } 
                 }
         }
 
         switch (status) {
         case sticking: {
                 //switch to sticking: null velocity at the end of time step
 //              std::cerr << "sono qui1" << std::endl;
                 current_friction_force = f;
                 WorkVec.IncCoef(startdof+1,v);
                 break;
         }
         case sliding: {
                 //still sliding
                 //cur_sticking = false;
                 switch (transition_type) {
                 case from_sticked_to_sliding: {
 //                      std::cerr << "sono qui2" << std::endl;
                         current_friction_force = sign(f)*fss(v)+sigma2*v;
                         break;
                 }
                 case from_sticking_to_sliding: {
                         current_friction_force = sign(saved_sliding_friction)*fss(v)+sigma2*v;
                         break;
                 }
                 default: {
                         if (std::fabs(v) > 0.) {
 //                              std::cerr << "sono qui3" << std::endl;
 //                              std::cerr << "v: " << v << std::endl;
                                 if (sign(v) == sign(current_velocity)) {
                                         current_friction_force = sign(v)*fss(v)+sigma2*v;
 //*                                     std::cerr << "quixxxx" << std::endl;
                                 } else {
                                         current_friction_force = sign(f)*fss(v)+sigma2*v;
 //*                                     std::cerr << "quiyyyy" << std::endl;
                                 }
                         } else {
                                 //limit the force value while taking the sticking force direction
                                 current_friction_force = sign(f)*fss(v)+sigma2*v;
                         }
                         if (std::abs(v) < std::abs(current_velocity) && !first_iter) {
 //*                             std::cerr << "Aggiorno current velocity" << std::endl;
                                 current_velocity = v;
                         }
                         break;
                 }
                 }
                 //save friction force value in the (algebric) state
 //              std::cerr << "sono qui5" << std::endl;
                 WorkVec.IncCoef(startdof+1,f-current_friction_force);
                 break;
         }
         case sticked: {
                 current_friction_force = f;
                 WorkVec.IncCoef(startdof+1,v);
                 break;
         }
         default: {
                 silent_cerr("DiscreteCoulombFriction::AssRes() "
                         "logical error" << std::endl);
         }
         }
         //update status
         first_iter = false;
         if (transition_type != null) {
                 throw Elem::ChangedEquationStructure(MBDYN_EXCEPT_ARGS);
         }
 //      current_velocity = v;
 };

Here is the call graph for this function:

std::ostream & DiscreteCoulombFriction::DescribeDof	(	std::ostream &	out,
		const char *	prefix = `""`,
		bool	bInitial = `false`
	)		const

virtual

Implements SimulationEntity.

Definition at line 303 of file friction.cc.

 {
         return out << prefix
                 << "[1]: DiscreteCoulombFriction state" << std::endl;
 }

void DiscreteCoulombFriction::DescribeDof	(	std::vector< std::string > &	desc,
		bool	bInitial = `false`,
		int	i = `-1`
	)		const

virtual

Implements SimulationEntity.

Definition at line 310 of file friction.cc.

References ASSERT.

 {
         ASSERT(i == -1 || i == 0);
         desc.resize(1);
         desc[0] = "DiscreteCoulombFriction state";
 }

std::ostream & DiscreteCoulombFriction::DescribeEq	(	std::ostream &	out,
		const char *	prefix = `""`,
		bool	bInitial = `false`
	)		const

virtual

Implements SimulationEntity.

Definition at line 318 of file friction.cc.

 {
         return out << prefix
                 << "[1]: DiscreteCoulombFriction equation" << std::endl;
 }

void DiscreteCoulombFriction::DescribeEq	(	std::vector< std::string > &	desc,
		bool	bInitial = `false`,
		int	i = `-1`
	)		const

virtual

Implements SimulationEntity.

Definition at line 325 of file friction.cc.

References ASSERT.

 {
         ASSERT(i == -1 || i == 0);
         desc.resize(1);
         desc[0] = "DiscreteCoulombFriction equation";
 }

doublereal DiscreteCoulombFriction::fc ( void ) const

virtual

Return last computed friction coefficient

Implements BasicFriction.

Definition at line 342 of file friction.cc.

References current_friction_force.

                                                  {
         return current_friction_force;
 };

DofOrder::Order DiscreteCoulombFriction::GetDofType ( unsigned int i ) const

virtual

Implements SimulationEntity.

Definition at line 332 of file friction.cc.

References DofOrder::ALGEBRAIC, ASSERTMSGBREAK, and iGetNumDof().

                                                                       {
         ASSERTMSGBREAK(i<iGetNumDof(), "INDEX ERROR in ModLugreFriction::GetDofType");
         return DofOrder::ALGEBRAIC;
 };

Here is the call graph for this function:

DofOrder::Order DiscreteCoulombFriction::GetEqType ( unsigned int i ) const

virtual

Reimplemented from SimulationEntity.

Definition at line 337 of file friction.cc.

References ASSERTMSGBREAK, DofOrder::DIFFERENTIAL, and iGetNumDof().

                                                                      {
         ASSERTMSGBREAK(i<iGetNumDof(), "INDEX ERROR in ModLugreFriction::GetEqType");
         return DofOrder::DIFFERENTIAL;
 };

Here is the call graph for this function:

unsigned int DiscreteCoulombFriction::iGetNumDof ( void ) const

virtual

Implements SimulationEntity.

Definition at line 298 of file friction.cc.

Referenced by GetDofType(), and GetEqType().

                                                            {
         return 1;
 };

void DiscreteCoulombFriction::SetValue	(	DataManager *	pDM,
		VectorHandler &	X,
		VectorHandler &	XP,
		SimulationEntity::Hints *	ph = `0`,
		const unsigned int	solution_startdof = `0`
	)

virtual

Set Initial Values

Reimplemented from BasicFriction.

Definition at line 289 of file friction.cc.

References f, and VectorHandler::PutCoef().

 {
         X.PutCoef(solution_startdof+1,f);
 }

Here is the call graph for this function:

Member Data Documentation

logical DiscreteCoulombFriction::converged_sticked

private

Definition at line 219 of file friction.h.

doublereal DiscreteCoulombFriction::converged_v

private

Definition at line 222 of file friction.h.

Referenced by AfterConvergence().

doublereal DiscreteCoulombFriction::current_friction_force

private

Definition at line 231 of file friction.h.

Referenced by AssJac(), and fc().

doublereal DiscreteCoulombFriction::current_velocity

private

Definition at line 226 of file friction.h.

Referenced by AfterConvergence().

doublereal DiscreteCoulombFriction::f

private

Definition at line 234 of file friction.h.

Referenced by AfterConvergence(), and SetValue().

logical DiscreteCoulombFriction::first_iter

private

Definition at line 223 of file friction.h.

Referenced by AfterConvergence().

logical DiscreteCoulombFriction::first_switch

private

Definition at line 224 of file friction.h.

Referenced by AfterConvergence().

const DifferentiableScalarFunction& DiscreteCoulombFriction::fss

private

Definition at line 233 of file friction.h.

Referenced by AssJac().

doublereal DiscreteCoulombFriction::previous_switch_v

private

Definition at line 225 of file friction.h.

Referenced by AfterConvergence().

doublereal DiscreteCoulombFriction::saved_sliding_friction

private

Definition at line 228 of file friction.h.

doublereal DiscreteCoulombFriction::saved_sliding_velocity

private

Definition at line 227 of file friction.h.

doublereal DiscreteCoulombFriction::sigma2

private

Definition at line 229 of file friction.h.

Referenced by AssJac().

status_type DiscreteCoulombFriction::status

private

Definition at line 220 of file friction.h.

Referenced by AfterConvergence(), and AssJac().

tr_type DiscreteCoulombFriction::transition_type

private

Definition at line 221 of file friction.h.

Referenced by AfterConvergence().

doublereal DiscreteCoulombFriction::vel_ratio

private

Definition at line 230 of file friction.h.

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

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation