Cylindrical Joint

This section describes the Cylindrical joint entity of MotionView and shows the various usage, creation, and editing methods.

Theory/Background

A Cylindrical joint is a two degree-of-freedom kinematic pair used in mechanisms. Cylindrical joints provide one translation and one rotation function.

cylindrical_joint_diagram_mv

Cylindrical joint construction

Cylindrical Joints are commonly used in many places, such as:

•	Shock absorber tube and rod

•	Hydraulic cylinder/rod pair

Joint Definition

The Cylindrical joint is represented using Markers when exported to an MBD Solver. The representation can be visualized as shown in the figure below:

cylindrical_joint_marker_representation_mv_ug

Cylindrical joint marker representation

The bodies that are constrained by the Cylindrical joint are represented using two markers: Marker I and Marker J. Marker I belongs to Body 1 and Marker J belongs to Body 2. The constraints and displacement are applied on the Marker I with respect to the Marker J. Both of the markers will have a common point of origin, the same as the joint’s Origin Point. The orientation axis of the Cylindrical joint is represented by the Z axis of both I and J markers. Thus, the Markers I and J share a common point of origin and the direction of orientation of their Z axes. Marker I is free to translate along and rotate about the Z axis of the Marker J.

Entity Data Members

The topological information required to define an Cylindrical Joint is shown in the figure below:

cylindrical_joint_diagram2_mv

The data members of the Cylindrical joint can be classified into the following members:

Connectivity

An Cylindrical joint needs the following:

•	Body 1 and Body 2 - Specify two Bodies between which the joint is to be created.

•	Origin - Specify Point, which defines the location of the joint.

•	Alignment Axis - Orientation of the joint specified using a Point or Vector.

•	Compliant Mode (Optional) - If required, the joint’s Compliant Mode can be set to True (in order to make it compliant).

•	Friction Properties (Optional) - Friction properties can be assigned to a Cylindrical joint.

The joint can be modeled as a Single entity or as a Pair entity.

Note	Displacement Initial Conditions for Joints is not supported by MotionSolve as of version 12.0. Only Velocity Initial Conditions are supported by MotionSolve. Displacement Initial Conditions can be specified when building models using the ADAMS Solver.

Properties

Optional Initial Conditions can also be specified for the joint:

•	Since the joint has one translational DOF and one rotational DOF, the joint can have one set of Translational Initial Conditions (Displacement and Velocity) and one set of Rotational Initial Conditions.

Note	Displacement Initial Conditions are not supported by MotionSolve version 12.0. This option can only be when building models using the ADAMS Solver.

•	The editable properties of a Cylindrical Joint are the Translational and Rotational Initial Conditions of the joint.

•	When modeled as a Pair entity, the joint can have symmetric properties.

Optional Friction properties can also be specified for the joint:

cylindrical_joint_friction_properties_diagram_mv_ug

Activating the Use Friction option on the Friction Properties tab will display the following options in the panel:

Coefficient Dynamic

Coefficient Static

Stiction Transition Velocity

Max. Stiction Deformation (Adams only)

Active for Static/Quasi-Static Analysis

True/False

Effect

•	Stiction and Sliding

•	Stiction Only

•	Sliding Only

Input Forces

•	Preload (True/False)

•	Reaction Force (True/False)

•	Bending Moment (True/False)

Force Preload

Pin Radius

Torque Preload

Initial Overlap

Overlap Delta

•

Increase

•

Decrease

•

Constant

LuGre Parameters

•	Bristle Stiffness

•	Damping Coefficient

•	Viscous Coefficient

Creating and Editing Joints

To learn how to add a Cylindrical joint to a model, please see the Joints topic.

1.	Once an Cylindrical Joint has been added to the model using any of the "entity" creation methods, the panel for the joint will automatically be displayed in the panel area. See the panel examples below:

cylindrical_joint_panel_conn_tab_mv

Joints Panel (Cylindrical Joint) – Connectivity Tab - Single Entity

cylindrical_joint_panel_conn_tab_pair_mv

Joints Panel (Cylindrical Joint) – Connectivity Tab - Pair Entity

2.	The joint definition needs two bodies which are connected by the joint. Select Body 1 by picking the body from the graphics area, or double click the Body 1 collector to open to the model tree (from which the desired body can be selected).

3.	Similarly, pick Body 2 from the graphics area by clicking on the desired body (or use the collector and model tree method).

4.	Select the Origin Point from the Project Browser, or the graphics area, to specify a location for the joint.

5.	Specify the Alignment axis for the joint using either of the methods listed below:

-	Point – Select a point that lies on the desired Alignment axis for the joint.

-	Vector – If the Alignment axis for the joint is along any of the Global Axes, then the Global X, Y,or Z axis can be selected by clicking on the desired axis in the graphics area (or by browsing through the model tree).

alignment_axis_vector_example_mv

6.	Displacement and Velocity Initial Conditions can also be specified for the Joint. In case of a Cylindrical Joint, you can specify Translational and Rotational Initial Conditions (see the panel examples below):

cylindrical_joint_panel_int_cond_tab_mv

Joints Panel (Cylindrical Joint) – Initial Conditions Tab - Single Entity

cylindrical_joint_panel_int_cond_tab_pair_mv

Joints Panel (Cylindrical Joint) – Initial Conditions Tab - Pair Entity

7.	To specify Translational Initial Conditions, click the Translation check box and type in the Displacement and Velocity initial conditions values. To specify Rotational Initial Conditions, click the Rotation check box and specify the Initial Condition values.

8.	When modeled as a Pair entity, the joint can have symmetric properties.

9.	Optionally, you can specify frictional properties for the joint. Activate the Use Friction check box on the Friction Properties tab. The attributes related to the Cylindrical joint friction are shown below:

cylindrical_joint_friction_properties_tab_mv_ug

Joints panel - Friction Properties tab

Checking the Use Friction option displays a set of input fields which you need to specify as needed by the friction model of the solver. In addition, the LuGre Parameters tab also appears if the SolverMode is set to MotionSolve.

cylindrical_joint_lugre_properties_tab_mv_ug

Joints panel - LuGre Parameters tab

For additional details on the various fields in the Friction Properties and LuGre Parameters tab, please refer to the Joints Panel – Friction Properties Tab and Joints Panel - LuGre Parameters Tab topics.

Based on the joint selection, the relevant fields will be displayed in the Friction Properties tab. These fields are populated by default values as shown above. You can click the Restore Default Values button in the LuGre Parameters tab in order to populate default LuGre parameters.

Note - The same steps as shown above can also be used to define Pair Cylindrical Joint entities. When defining a Pair Cylindrical Joint use pair entities for Body 1, Body 2, Origin, etc.

1.	Left click the Joints panel icon on the Constraint toolbar.

The Project Browser will filter the entities and display only the Joints in the model.

2.	Select the desired joint in the Project Browser.

The corresponding panel is automatically displayed.

3.	From the Connectivity tab, use the Joint type drop-down menu to change the joint type, or use the collectors to change the bodies and origins/alignment points of the joint.

cylindrical_joint_drop_down_menu_mv_ug

Joints panel - Connectivity tab - joint type drop-down menu

Cylindrical Joint in MDL and XML Formats

The model containing the Cylindrical Joint can be saved in MDL format from MotionView and exported in the MotionSolve XML format.

The Cylindrical Joint can be of the following types:

1.	Non-Compliant - Single and Pair

2.	Compliant – Single and Pair

These four types of entities can be added to the model using MDL Statements shown below:

Syntax:

*CylJoint(joint_name, "joint_label", body_1,

body_2,

origin,

POINT|VECTOR,

point|vector,

[ALLOW_COMPLIANCE])

To understand the complete syntax of the MDL statement please refer to the *CylJoint topic.

The *SetJointICFlag and *SetJointIC statements can be used for specifying initial conditions for the Cylindrical joint.

Syntax:

*SetJointICFlag(joint_name, TRANS, true)

*SetJointICFlag(joint_name, ROT, true)

*SetJointIC(joint_name, TRANS, ic_disp, ic_vel)

*SetJointIC(joint_name, ROT, ic_disp, ic_vel)

Note that the *SetJointIC statement is a common statement that can be used for all joints which allow specification of joint initial conditions.

To understand the complete syntax of this MDL statement please refer to the *SetJointIC topic.

The *SetJointFriction and *SetJointFrictionLugre statements can be used for specifying the friction properties for the Cylindrical joint.

Syntax:

*SetJointFriction(varname, use_friction, mu_static, mu_dynamic, use_static, transition_vel, max_deformation, effect, preload_input, reaction_force_input, bending_moment_input, torsional_moment_input, f_preload, reaction_arm, initial_overlap, overlap_delta, rot_constraint, t_preload, pin_radius, friction_arm, bending_reaction_arm, ball_radius )

*SetJointFrictionLugre(varname, bristle_stiffness, damping_effects, viscous_effects )

Note that these two statements are common for all the joints where friction can be applied, however a few of the fields might not be applicable to certain joints.

Syntax:

*CylJointPair(joint_name, "joint_label", body_1,

body_2,

origin,

POINT|VECTOR,

point|vector,

[ALLOW_COMPLIANCE])

To understand the complete syntax of the MDL statement please refer to the *CylJointPair topic.

The *SetJointICFlag and *SetJointIC statements can be used for specifying initial conditions for the Pair Cylindrical joint.

Syntax for Asymmetric Cylindrical Joint Pair:

*SetJointICFlag(joint_name, , TRANS, true, true)

*SetJointICFlag(joint_name, , ROT, true, true)

*SetJointIC(joint_name, ,TRANS, l_ic_disp, l_ic_vel, r_ic_disp, r_ic_vel)

*SetJointIC(joint_name, ,ROT, l_ic_disp, l_ic_vel, r_ic_disp, r_ic_vel)

Syntax for Symmetric Cylindrical Joint Pair:

*SetJointICFlag(joint_name, LEFT|RIGHT, TRANS, true)

*SetJointICFlag(joint_name, LEFT|RIGHT, ROT, true)

*SetJointIC(joint_name, LEFT|RIGHT, TRANS, ic_disp, ic_vel)

*SetJointIC(joint_name, LEFT|RIGHT, ROT, ic_disp, ic_vel)

Note that the *SetJointIC statement is a common statement that can be used for all joints which allow specification of joint initial conditions.

To understand the complete syntax of this MDL statement please refer to the *SetJointIC topic.

The *SetJointFriction and *SetJointFrictionLugre statements can be used for specifying the friction properties for the Pair Cylindrical joint.

Syntax for Asymmetric Cylindrical Joint Pair:

*SetJointFriction(varname, , use_friction_l, mu_static_l, mu_dynamic_l, use_static_l, transition_vel_l, max_deformation_l, effect_l, preload_input_l, reaction_force_input_l, bending_moment_input_l, torsional_moment_input_l, f_preload_l, reaction_arm_l, initial_overlap_l, overlap_delta_l, rot_constraint_l, t_preload_l, pin_radius_l, friction_arm_l, bending_reaction_arm_l, ball_radius_l

, use_friction_r, mu_static_r, mu_dynamic_r, use_static_r, transition_vel_r, max_deformation_r, effect_r, preload_input_r, reaction_force_input_r, bending_moment_input_r, torsional_moment_input_r, f_preload_r, reaction_arm_r, initial_overlap_r, overlap_delta_r, rot_constraint_r, t_preload_r, pin_radius_r, friction_arm_r, bending_reaction_arm_r, ball_radius_r )

Syntax for Symmetric Cylindrical Joint Pair:

*SetJointFriction(varname, LEFT|RIGHT, use_friction, mu_static, mu_dynamic, use_static, transition_vel, max_deformation, effect, preload_input, reaction_force_input, bending_moment_input, torsional_moment_input, f_preload, reaction_arm, initial_overlap, overlap_delta, rot_constraint, t_preload, pin_radius, friction_arm, bending_reaction_arm, ball_radius )

*SetJointFrictionLugre(varname, bristle_stiffness_l, damping_effects_l, viscous_effects_l,

bristle_stiffness_r, damping_effects_r, viscous_effects_r)

The syntax for the LuGre parameters statement for an asymmetric joint pair is identical to its symmetric counterpart. MotionView will ignore the part of the statement that belongs to the dependent side of the joint and replicate it with the parent side parameters.

To learn how to create a complete model using MDL Statements please refer to tutorial MV-1060: Introduction to MDL.

The Cylindrical Joint when exported to the MotionSolve XML format is defined as a Constraint_Joint statement.

Syntax:

<Constraint_Joint

id = "integer"

label = "Name of Joint"

type = "JOINT TYPE"

i_marker_id = "integer"

j_marker_id = "integer"

Initial Velocity Conditions of the Cylindrical Joint are defined using JointInitialVel_Cyl the statement:

<JointInitialVel_Cyl

joint_id = "integer"

trans_iv = "real"

rot_iv = "real"

In the case of the Cylindrical Joint the model statement will be as shown below:

<Constraint_Joint

id = "301001"

label = "Cyl Joint"

type = "CYLINDRICAL"

i_marker_id = "30103050"

j_marker_id = "30101050"

In the above XML Model statement the i_marker_id and j_marker_id represent the I and J markers of the Joint which belong to Body 1 and Body 2 respectively. To understand the complete syntax of the Constraint_Joint XML model statement, please refer to the MotionSolve Reference Guide Page for Constraint_Joint.

Initial Conditions Example:

<JointInitialVel_Cyl

joint_id = "301001"

trans_iv = "5."

rot_iv = "15."

Creating a Cylindrical Joint using the Tcl Command Layer

In MotionView, Tcl can be used to add any MDL entities to the model. There are two Tcl commands that can be used to add an entity:

Syntax:

mdlmodel_handle InterpretEntity new_handle keyword varname label

Example:

mdlmodel_handle InterpretEntity joint_cyl_handle CylJoint j_cyl "\"Cyl Joint\"" b_1 B_Ground p_ori "POINT" p_axis "ALLOW_COMPLIANCE";

Syntax:

mdlmodel_handle InterpretSet keyword tokens

Example:

mdlmodel_handle InterpretSet SetJointICFlag j_cyl "TRANS" "true"

mdlmodel_handle InterpretSet SetJointICFlag j_cyl "ROT" "true"

mdlmodel_handle InterpretSet SetJointIC j_cyl "TRANS" "0.0" "15.0"

mdlmodel_handle InterpretSet SetJointIC j_cyl "ROT" "0.0" "15.0"

mdlmodel_handle InterpretSet SetJointFriction j_cyl true mu_static mu_dynamic use_static transition_vel max_deformation effect preload_input reaction_force_input bending_moment_input torsional_moment_input f_preload reaction_arm initial_overlap overlap_delta rot_constraint t_preload pin_radius friction_arm bending_reaction_arm ball_radius

mdlmodel_handle InterpretSet SetJointFrictionLugre j_cyl bristle_stiffness damping_effects viscous_effects

The InterpretEntity command is used to add entities to the model and the InterpretSet command is used to set the entity properties. So in the case of the Cylindrical Joint, the properties that can be set are the joint Initial Conditions and joint Friction. Extended definitions for InterpretEntity and InterpretSet can be found in the HyperWorks Desktop Reference Guide.

Note - When using the InterpretEntity and InterpretSet commands, it is important to also use the Evaluate command in order for the changes to take effect immediately.

To learn how to create a complete model using Tcl commands, please refer to tutorial MV-1040: Model Building Using Tcl.

Example Model

The example file below shows a Cylindrical joint connecting two bodies:

*BeginMDL( the_model, "Model" )

*StandardInclude(FILE)

*Point( p_0, "Point 0" )

*PointPair( p_1, "Point 1" )

*Body( b_0, "Body 0", p_0, , , , )

*BodyPair( b_1, "Body 1", p_1, , , , )

//Example for a Cylindrical Joint - Single

*CylJoint( j_cyljsingle, "Cylindrical Joint Single", b_0, B_Ground, p_0, POINT, p_1.r )

//Example for a Cylindrical Joint - Pair

*CylJointPair( j_cyljpairsym, "Cylindrical Joint Pair Sym", b_1, B_Ground, p_1, VECTOR, V_Global_Y )

*CylJointPair( j_cyljpairAsym, "Cylindrical Joint pair Asym", b_1, B_Ground, p_1, VECTOR, V_Global_Y )

*SetPoint( p_1, LEFT, , -100 )

*Set( b_0.usecm, true )

*Set( b_1.usecm, true )

*SetBodyInertia( b_1, LEFT, 1, 10000, 10000, 10000 )

//Example for SetJointICFlag - Single

*SetJointICFlag( j_cyljsingle, ROT, true )

//Example for SetJointIC - Single

*SetJointIC( j_cyljsingle, ROT, , 5 )

//Setting joint friction using SetJointFriction - Single

*SetJointFriction( j_cyljsingle, true, 0.35, 0.26, ACTIVE_STATIC, 0.15, , STICTION_AND_SLIDING, PRELOAD, REACTION_FORCE, , , 1000, 25, , , , 1000, , , , 10 )

//Setting joint friction LuGre parameters using SetJointFrictionLugre - Single

*SetJointFrictionLugre( j_cyljsingle, 100, 0.316, 0.0004 )

//Example for SetJointICFlag – Symmetric Pair

*SetJointICFlag( j_cyljpairsym, LEFT, ROT, true )

//Example for SetJointIC - Symmetric Pair

*SetJointIC( j_cyljpairsym, LEFT, ROT, 0, 10 )

//Setting joint friction using SetJointFriction - Symmetric Pair

*SetJointFriction( j_cyljpairsym, LEFT, true, 0.35, 0.26, ACTIVE_STATIC, 0.15, , STICTION_AND_SLIDING, NO_PRELOAD, REACTION_FORCE, BENDING_MOMENT, , 2000,25 , , , , 1000, 10, 15, 50 )

//Example for SetJointICFlag – Asymmetric Pair

*SetJointICFlag( j_cyljpairAsym, , ROT, true, true )

//Example for SetJointIC - Asymmetric Pair

*SetJointIC( j_cyljpairAsym, , ROT, , 5, , 10 )

//Setting joint friction using SetJointFriction - Asymmetric Pair

*SetJointFriction( j_cyljpairAsym, , true, 0.35, 0.26, ACTIVE_STATIC, 0.15, , STICTION_ONLY, PRELOAD, REACTION_FORCE, , ,1000, 30, , , , 1000, , , , 10

, true, 0.35, 0.26, ACTIVE_STATIC, 0.15, , STICTION_ONLY, PRELOAD, REACTION_FORCE, , ,1000, 30, , , , 1000, , , , 10 )

//Setting joint friction LuGre parameters using SetJointFrictionLugre - Pair

*SetJointFrictionLugre( j_cyljpairAsym, 100, 0.316, 0.0004

, 100, 0.316, 0.0004 )

*EndMDL()