ObjectContactFrictionCircleCable2D.rst

ObjectContactFrictionCircleCable2D

A very specialized penalty-based contact/friction condition between a 2D circle in the local x/y plane (=marker0, a RigidBody Marker, from node or object) on a body and an ANCFCable2DShape (=marker1, Marker: BodyCable2DShape), in xy-plane; a node NodeGenericData is required with 3\times(number of contact segments) -- containing per segment: [contact gap, stick/slip (stick=0, slip=+-1, undefined=-2), last friction position]. The connector works with Cable2D and ALECable2D, HOWEVER, due to conceptual differences the (tangential) frictionStiffness cannot be used with ALECable2D; if using, it gives wrong tangential stresses, even though it may work in general.

Additional information for ObjectContactFrictionCircleCable2D:

• This Object has/provides the following types = Connector
• Requested Marker type = _None
• Requested Node type = GenericData

The item ObjectContactFrictionCircleCable2D with type = 'ContactFrictionCircleCable2D' has the following parameters:

• name [type = String, default = '']:

  connector's unique name
• markerNumbers [[m0,m1]\tp, type = ArrayMarkerIndex, default = [ invalid [-1], invalid [-1] ]]:

  a marker m0 with position and orientation and a marker m1 of type BodyCable2DShape; together defining the contact geometry
• nodeNumber [n_g, type = NodeIndex, default = invalid (-1)]:

  node number of a NodeGenericData with 3 \times n_{cs} dataCoordinates (used for active set strategy \ra hold the gap of the last discontinuous iteration, friction state (+-1=slip, 0=stick, -2=undefined) and the last sticking position; initialize coordinates with list [0.1]*n_{cs}+[-2]*n_{cs}+[0.]*n_{cs}, meaning that there is no initial contact with undefined slip/stick
• numberOfContactSegments [n_{cs}, type = PInt, default = 3]:

  number of linear contact segments to determine contact; each segment is a line and is associated to a data (history) variable; must be same as in according marker
• contactStiffness [k_c, type = UReal, default = 0.]:

  contact (penalty) stiffness [SI:N/m/(contact segment)]; the stiffness is per contact segment; specific contact forces (per length) f_n act in contact normal direction only upon penetration
• contactDamping [d_c, type = UReal, default = 0.]:

  contact damping [SI:N/(m s)/(contact segment)]; the damping is per contact segment; acts in contact normal direction only upon penetration
• frictionVelocityPenalty [\mu_v, type = UReal, default = 0.]:

  tangential velocity dependent penalty coefficient for friction [SI:N/(m s)/(contact segment)]; the coefficient causes tangential (contact) forces against relative tangential velocities in the contact area
• frictionStiffness [\mu_k, type = UReal, default = 0.]:

  tangential displacement dependent penalty/stiffness coefficient for friction [SI:N/m/(contact segment)]; the coefficient causes tangential (contact) forces against relative tangential displacements in the contact area
• frictionCoefficient [\mu, type = UReal, default = 0.]:

  friction coefficient [SI: 1]; tangential specific friction forces (per length) f_t must fulfill the condition f_t \le \mu f_n
• circleRadius [r, type = UReal, default = 0.]:

  radius [SI:m] of contact circle
• useSegmentNormals [type = Bool, default = True]:

  True: use normal and tangent according to linear segment; this is appropriate for very long (compared to circle) segments; False: use normals at segment points according to vector to circle center; this is more consistent for short segments, as forces are only applied in beam tangent and normal direction
• activeConnector [type = Bool, default = True]:

  flag, which determines, if the connector is active; used to deactivate (temporarily) a connector or constraint
• visualization [type = VObjectContactFrictionCircleCable2D]:

  parameters for visualization of item

The item VObjectContactFrictionCircleCable2D has the following parameters:

• show [type = Bool, default = True]:

  set True, if item is shown in visualization and false if it is not shown; note that only normal contact forces can be drawn, which are approximated by k_c \cdot g (neglecting damping term)
• showContactCircle [type = Bool, default = True]:

  if True and show=True, the underlying contact circle is shown; uses circleTiling*4 for tiling (from VisualizationSettings.general)
• drawSize [type = float, default = -1.]:

  drawing size = diameter of spring; size == -1.f means that default connector size is used
• color [type = Float4, default = [-1.,-1.,-1.,-1.]]:

  RGBA connector color; if R==-1, use default color

---

DESCRIPTION of ObjectContactFrictionCircleCable2D

The following output variables are available as OutputVariableType in sensors, Get...Output() and other functions:

• Coordinates: [u_{t,0},\, g_0,\, u_{t,1},\, g_1,\, \ldots,\, u_{t,n_{cs}},\, g_{n_{cs}}]\tp

  local (relative) displacement in tangential ({\mathbf{t}}) and normal ({\mathbf{n}}) direction per segment (n_{cs}); values are only provided in case of contact, otherwise zero; tangential displacement is only non-zero in case of sticking!
• Coordinates\_t: [v_{t,0},\, v_{n,0},\, v_{t,1},\, v_{n,1},\, \ldots,\, v_{t,n_{cs}},\, v_{n,n_{cs}}]\tp

  local (relative) velocity in tangential ({\mathbf{t}}) and normal ({\mathbf{n}}) direction per segment (n_{cs}); values are only provided in case of contact, otherwise zero
• ForceLocal: [f_{t,0},\, f_{n,0},\, f_{t,1},\, f_{n,1},\, \ldots,\, f_{t,n_{cs}},\, f_{n,n_{cs}}]\tp

  local contact forces in tangential ({\mathbf{t}}) and normal ({\mathbf{n}}) direction per segment (n_{cs})

Definition of quantities

intermediate variables	symbol	description
marker m0 position	\LU{0}{{\mathbf{p}}}_{m0}	represents current global position of the circle's centerpoint
marker m0 velocity	\LU{0}{{\mathbf{v}}}_{m0}	current global velocity which is provided by marker m0
marker m1		represents the 2D ANCF cable
data node	{\mathbf{x}}=[x_{i},\; \ldots,\; x_{3 n_{cs} -1}]\tp	coordinates of node with node number n_{GD}
data coordinates for segment i	[x_i,\, x_{n_{cs}+ i},\, x_{2\cdot n_{cs}+ i}]\tp = [x_{gap},\, x_{isSlipStick},\, x_{lastStick}]\tp, with i \in [0,n_{cs}-1]	The data coordinates include the gap x_{gap}, the stick-slip state x_{isSlipStick} and the previous sticking position x_{lastStick} as computed in the PostNewtonStep, see description below.
shortest distance to segment s_i	{\mathbf{d}}_{g,i}	shortest distance of center of circle to contact segment, considering the endpoint of the segment

Sketch of cable, contact segments and circle; showing case without contact, |\mathbf{d}_{g1}| > r, while contact occurs with |\mathbf{d}_{g1}| \le r; the shortest distance vector \mathbf{d}_{g1} is related to segment s_1 (which is perpendicular to the the segment line) and \mathbf{d}_{g2} is the shortest distance to the end point of segment s_2, not being perpendicular

Connector forces: contact geometry

The connector represents a force element between a 'circle' (or cylinder) represented by a marker m0, which has position and orientation, and an ANCFCable2D beam element (denoted as 'cable') represented by a MarkerBodyCable2DShape m1. The cable with reference length L is discretized by splitting into n_{cs} straight segments s_i, located between points p_i and p_{i+1}. Note that these points can be placed with an offset from the cable centerline, see verticalOffset defined in MarkerBodyCable2DShape. In order to compute the gap function for a line segment, the shortest distance of one line segment with points {\mathbf{p}}_i, {\mathbf{p}}_{i+1} to the circle's centerpoint given by the marker {\mathbf{p}}_{m0} is computed. All computations here are performed in the global coordinates system (0), including edge points of every segment.

With the intermediate quantities (all of them related to segment s_i)(we omit s_i in some terms for brevity!),

{\mathbf{v}}_s = {\mathbf{p}}_{i+1} - {\mathbf{p}}_i, \quad {\mathbf{v}}_p = {\mathbf{p}}_{m0} - {\mathbf{p}}_i, \quad n = {\mathbf{v}}_s\tp {\mathbf{v}}_p, \quad d = {\mathbf{v}}_s\tp {\mathbf{v}}_s

and assuming that d \neq 0 (otherwise the two segment points would be identical and the shortest distance would be d_g = |{\mathbf{v}}_p|), we find the relative position \rho of the shortest (projected) point on the segment, which runs from 0 to 1 if lying on the segment, as

\rho = \frac{n}{d}

We distinguish 3 cases (see also :numref:`fig-objectcontactfrictioncirclecable2d-sketch` for cases 1 and 2):

• If \rho \le 0, the shortest distance would be the distance to point {\mathbf{p}}_p={\mathbf{p}}_i,

  reading

d_g = |{\mathbf{p}}_{m0} - {\mathbf{p}}_i| \quad (\rho \le 0)

• If \rho \ge 1, the shortest distance would be the distance to point {\mathbf{p}}_p={\mathbf{p}}_{i+1},

  reading

d_g = |{\mathbf{p}}_{m0} - {\mathbf{p}}_{i+1}| \quad (\rho \ge 1)

• Finally, if 0 < \rho < 1, then the shortest distance has a projected point somewhere

  on the segment with the point (projected on the segment)

{\mathbf{p}}_p = {\mathbf{p}}_i + \rho \cdot {\mathbf{v}}_s

 and the distance

d_g = |{\mathbf{d}}_g| = \sqrt{{\mathbf{v}}_p\tp {\mathbf{v}}_p - (n^2)/d}

Here, the shortest distance vector for every segment results from the projected point {\mathbf{p}}_pof the above mentioned cases, see also :numref:`fig-objectcontactfrictioncirclecable2d-sketch`, with the relation

{\mathbf{d}}_g = {\mathbf{d}}_{g,s_i}= {\mathbf{p}}_{m0} - {\mathbf{p}}_p .

The contact gap for a specific point for segment s_i is in general defined as

g = g_{s_i} = d_g - r .

using d_g = |{\mathbf{d}}_g|.

Contact frame and relative motion

Irrespective of the choice of useSegmentNormals, the contact normal vector {\mathbf{n}}_{s_i} and tangential vector {\mathbf{t}}_{s_i} are defined per segment as

{\mathbf{n}}_{s_i} = {\mathbf{n}} = [n_0, n_1]\tp = \frac{1}{|{\mathbf{d}}_{g,s_i}|} {\mathbf{d}}_{g,s_i}, \quad {\mathbf{t}}_{s_i} = {\mathbf{t}} = [-n_1, n_0]\tp

The vectors {\mathbf{t}}_{s_i} and {\mathbf{n}}_{s_i} define the local (contact) frame for further computations.

The velocity at the closest point of the segment s_i is interpolated using \rho and computed as

\dot {\mathbf{p}}_p = (1-\rho) \cdot {\mathbf{v}}_i + \rho \cdot {\mathbf{v}}_{i+1}

Alternatively, \dot {\mathbf{p}}_p could be computed from the cable element by evaluating the velocity at the contact points, but we feel that this choice is more consistent with the computations at position level.

The gap velocity v_n (\neq \dot g) thus reads

v_n = \left( \dot {\mathbf{p}}_p - \dot {\mathbf{p}}_{m0} \right) {\mathbf{n}}

In a similar, the tangential velocity reads

v_t = \left( \dot {\mathbf{p}}_p - \dot {\mathbf{p}}_{m0} \right) {\mathbf{t}}

In case of frictionStiffness != 0, we continuously track the sticking position at which the cable element (or segment) and the circle previously sticked together, similar as proposed by Lugr{'i}s et al.~. The difference here to the latter reference, is that we explicitly exclude switching from Newton's method and that Lugr{'i}s et al.~used contact points, while we use linear segments. For a simple 1D example using this position based approach for friction, see Examples/lugreFrictionText.py, which compares the traditional LuGre friction model with the position based model with tangential stiffness.

Calculation of last sticking position; blue parts mark the sticking position calculated as x^*_{curStick}.

Because there is the chance to wind/unwind relative to the (last) sticking position without slipping, the following strategy is used. In case of sliding (which could be the last time sliding before sticking), we compute the current sticking position, see :numref:`fig-objectcontactfrictioncirclecable2d-stickingpos`, as the sum of the relative position at the segment s

x_{s,curStick} = \rho \cdot L_{seg}

in which \rho \in [0,1] denotes the relative position of contact at the segment with reference length L_{seg}=\frac{L}{n_{cs}}. The relative position at the circle c is

x_{c,curStick} = \alpha \cdot r

We immediately see, that under pure rolling(neglecting the effects of small penetration, usually much smaller than shown for visibility in :numref:`fig-objectcontactfrictioncirclecable2d-stickingpos`.),

x_{s,curStick} + x_{c,curStick}  = \mathrm{const}.

Note that the verticalOffset from the cable center line, as defined in the related MarkerBodyCable2DShape, influences the behavior significantly, which is why we recommend to use verticalOffset=0 whenever this is an appropriate assumption. Thus, the current sticking position x_{curStick} is computed per segment as

x^*_{curStick} = x_{s,curStick} + x_{c,curStick}, \quad

Due to the possibility of switching of \alpha+\phi between -\pi and \pi, the result is normalized to

x_{curStick} = x^*_{curStick} - \mathrm{floor}\left(\frac{x^*_{curStick} }{2 \pi \cdot r} + \frac{1}{2}\right) \cdot 2 \pi \cdot r, \quad

which gives \bar x_{curStick} \in [-\pi \cdot r,\pi \cdot r], which is stored in the 3rd data variable (per segment). The function floor() is a standardized version of rounding, available in C and Python programming languages. In the PostNewtonStep, the last sticking position is computed, x_{lastStick} = x_{curStick}, and it is also available in the startOfStep state.

Contact forces: definition

The contact force f_n is zero for g > 0 and otherwise computed from

f_n = k_c \cdot g + d_c \cdot v_n

NOTE that currently, there is only a linear spring-damper model available, assuming that the impact dynamics is not dominating (such as in belt drives or reeving systems).

Friction forces are primarily based on relative (tangential) velocity at each segment. The 'linear' friction force, based on the velocity penalty parameter \mu_v reads

f_t^{(lin)} = \mu_v \cdot v_t ,

PostNewtonStep

In general, see the solver flow chart for the DiscontinuousIteration, see :numref:`fig-solver-discontinuous-iteration`, should be considered when reading this description. Every step is started with values startOfStep, while current values are iterated and updated in the Newton or DiscontinuousIteration.

The PostNewtonStep computes 3 values per segment, which are used for computation of contact forces, irrespectively of the current geometryof the contact. The PostNewtonStep is called after every full Newton method and evaluates the current state w.r.t. the assumed data variables. If the assumptions do not fit, new data variables are computed. This is necessary in order to avoid discontinuities in the equations, while otherwise the Newton iterations would not (or only slowly) converge.

The data variables per segment are

[x_{gap},\, x_{isSlipStick},\, x_{lastStick}]

Here, x_{gap} contains the gap of the segment (\le 0 means contact), x_{lastStick} is described in Eq. :eq:`objectcontactfrictioncirclecable2d-curstick`, and x_{isSlipStick} defines the stick or slip case,

• x_{isSlipStick} = -2: undefined, used for initialization
• x_{isSlipStick} = 0: sticking
• x_{isSlipStick} = \pm 1: slipping, sign defines slipping direction

The basic algorithm in the PostNewtonStep, with all operations given for any segment s_i, can be summarized as follows:

• [I.] Evaluate gap per segment g using Eq. :eq:`objectcontactfrictioncirclecable2d-gap` and store in data variable:

  x_{gap} = g

• [II.] If x_{gap} < 0 and (\mu_v \neq 0 or \mu_k \neq 0):
• Compute contact force f_n according to Eq. :eq:`objectcontactfrictioncirclecable2d-contactforce`
• Compute current sticking position x_{curStick} according to Eq. :eq:`objectcontactfrictioncirclecable2d-lastcurstick`(terms are only evaluated if \mu_k \neq 0)

• Retrieve startOfStep sticking position(Importantly, the PostNewtonStep always refers to the startOfStep state in the sticking position, because in the discontinuous iterations, the algorithm could switch to slipping in between and override the last sticking position in the current step) in x^{startOfStep}_{lastStick} and compute and normalize

  difference in sticking position(in case that x_{isSlipStick} = -2, meaning that there is no stored sticking position, we set \Delta x_{stick} = 0):

\Delta x^*_{stick} = x_{curStick} - x^{startOfStep}_{lastStick}, \quad \Delta x_{stick} = \Delta x^*_{stick} - \mathrm{floor}\left(\frac{\Delta x^*_{stick} }{2 \pi \cdot r} + \frac{1}{2}\right) \cdot 2 \pi \cdot r

• Compute linear tangential force for friction stiffness and velocity penalty:

f_{t,lin} = \mu_v \cdot v_t + \mu_k \Delta x_{stick}

• Compute tangential force according to Coulomb friction model (note that the sign of \Delta x_{stick} is used here, but

  alternatively we may also use the sign of f_{t,lin}):

f_t = \begin{cases} f_t^{(lin)}, \quad \quad \quad \quad \quad \quad \quad \mathrm{if} \quad |f_t^{(lin)}| \le \mu \cdot |f_n| \\ \mu \cdot |f_n| \cdot \mathrm{Sign}(\Delta x_{stick}), \quad \mathrm{else} \end{cases}

• In the case of slipping, given by |f_t^{(lin)}| > \mu \cdot |f_n|, we update the last sticking position in the data variable,

  such that the spring is pre-tensioned already,

x_{lastStick} = x_{curStick} - \mathrm{Sign}(\Delta x_{stick}) \frac{\mu \cdot |f_n|}{\mu_k}, \quad x_{isSlipStick} = \mathrm{Sign}(\Delta x_{stick})

• In the case of sticking, given by |f_t^{(lin)}| \le \mu \cdot |f_n| : Set x_{isSlipStick} = 0 and,

  if x^{startOfStep}_{isSlipStick} = -2 (undefined), we update x_{lastStick} = x_{curStick}, while otherwise, x_{lastStick} is unchanged.

• [III. ] If x_{gap} > 0 or (\mu_v == 0 and \mu_k == 0), we set x_{isSlipStick} = -2 (undefined); this means that in the next step (if this step is accepted), there is no stored sticking position.

• [IV.] Compute an error \varepsilon_{PNS} = \varepsilon^n_{PNS}+\varepsilon^t_{PNS},

  with physical units forces (per segment point), for PostNewtonStep:

• if gap x_{gap,lastPNS} of previous PostNewtonStep had different sign to current gap, set

\varepsilon^n_{PNS} = k_c \cdot \Vert x_{gap} - x_{gap,lastPNS}\Vert

while otherwise \varepsilon^n_{PNS}=0. + if stick-slip-state x_{isSlipStick,lastPNS} of previous PostNewtonStep is different from current x_{isSlipStick}, set

\varepsilon^t_{PNS} = \Vert \left(\Vert f_t^{(lin)} \Vert  - \mu \cdot |f_n| \right)\Vert

while otherwise \varepsilon^t_{PNS}=0.

Note that the PostNewtonStep is iterated and the data variables are updated continuously until convergence, or until a max.number of iterations is reached. If ignoreMaxIterations == 0, computation will continue even if no convergence is reached after the given number of iterations. This will lead so larger errors in such steps, but may have less influence on the overall solution if such cases are rare.

Computation of connector forces in Newton

The computation of LHS terms, the action of forces produced by the contact-friction element, is done during Newton iterations and may not have discontinuous behavior, thus relating computations to data variables computed in the PostNewtonStep. For efficiency, the LHS computation is only performed, if the PostNewtonStep determined contact in any segment.

The operations are similar to the PostNewtonStep, but without switching. The following operations are performed for each segment s_i, if x_{gap, s_i} <= 0:

• [I.] Compute contact force f_n, Eq. :eq:`objectcontactfrictioncirclecable2d-contactforce`.
• [II.] In case of sticking (|x_{isSlipStick}|\neq 1):
• [II.1] the current sticking position x_{curStick} is computed from Eq. :eq:`objectcontactfrictioncirclecable2d-lastcurstick`, and the difference of current and last sticking position reads(see the difference to the PostNewtonStep: we use x_{lastStick} here, not the startOfStep variant.):

\Delta x^*_{stick} = x_{curStick} - x_{lastStick}, \quad \Delta x_{stick} = x^*_{stick} - \mathrm{floor}\left(\frac{\Delta x^*_{stick} }{2 \pi \cdot r} + \frac{1}{2}\right) \cdot 2 \pi \cdot r

• [II.2] if the friction stiffness is \mu_k==0 or if x_{isSlipStick} == -2, we set \Delta x_{stick}=0
• [II.3] using the tangential velocity from Eq. :eq:`objectcontactfrictioncirclecable2d-vtangent`, the tangent force follows as (even if it is larger than the sticking limit)

f_t = \mu_v \cdot v_t + \mu_k \Delta x_{stick}

• [III.] In case of slipping (|x_{isSlipStick}|=1), the tangential firction force is set as(see again difference to PostNewtonStep!),

f_t = \mu \cdot |f_n| \cdot x_{isSlipStick}, \quad \mathrm{else}

Note that in the Newton method, the tangential force may be inconsistent with the Kuhn-Tucker conditions. However, the PostNewtonStep resolves this inconsistency.

Computation of LHS terms for circle and ANCF cable element

If activeConnector = True, contact forces {\mathbf{f}}_i with i \in [0,n_{cs}] -- these are (n_{cs}+1) forces -- are applied at the points p_i, and they are computed for every contact segments (i.e., two segments may contribute to contact forces of one point). For every contact computation, first all contact forces at segment points are set to zero. We distinguish two cases SN and PWN. If useSegmentNormals==True, we use the SN case, while otherwise the PWN case is used, compare :numref:`fig-objectcontactfrictioncirclecable2d-normals`.

Choice of normals and tangent vectors for calculation of normal contact forces and tangential (friction) forces; note that the useSegmentNormals=False is not appropriate for this setup and would produce highly erroneous forces.

Segment normals (=SN) lead to always good approximations for normal directions, irrespectively of short or extremely long segments as compared to the circle. However, in case of segments that are short as compared to the circle radius, normals computed from the center of the circle to the segment points (=PWN) are more consistent and produce tangents only in circumferential direction, which may improve behavior in some applications. The equations for the two cases read:

CASE SN: use Segment Normals

If there is contact in a segment s_i, i.e., gap state x_{gap} \le 0, see :numref:`fig-objectcontactfrictioncirclecable2d-sketch`(right), contact forces {\mathbf{f}}_{s_i} are computed per segment,

{\mathbf{f}}_{s_i} = f_n \cdot {\mathbf{n}}_{s_i} + f_t {\mathbf{t}}_{s_i}

and added to every force at segment points according to

{\mathbf{f}}_i &\pluseq& (1-\rho) \cdot {\mathbf{f}}_{s_i}      \\
\nonumber {\mathbf{f}}_{i+1} &\pluseq& \rho \cdot {\mathbf{f}}_{s_i}

while in case x_{gap} > 0 nothing is added.

CASE PWN: use Point Wise Normals (at segment points)

If there is contact in a segment s_i, i.e., gap x_{gap} \le 0, see :numref:`fig-objectcontactfrictioncirclecable2d-sketch`(right), intermediate contact forces {\mathbf{f}}^{l,r}_{i} are computed per segment point,

 {\mathbf{f}}^l = f_n \cdot {\mathbf{n}}_{l,s_i} + f_t {\mathbf{t}}_{l,s_i}, \quad {\mathbf{f}}^r = f_n \cdot {\mathbf{n}}_{r,s_i} + f_t {\mathbf{t}}_{r,s_i}

in which \ :math:`{\mathbf{n}}_{l,s_i}`\  is the vector from circle center to the left point (\ :math:`i`\ ) of the segment \ :math:`s_i`\ ,
and \ :math:`{\mathbf{n}}_{l,s_i}`\  to the right point (\ :math:`i+1`\ ). The tangent vectors are perpendicular to the normals.
The forces are then applied to the contact forces \ :math:`{\mathbf{f}}_i`\  using the parameter \ :math:`\rho`\ , which takes into account the distance of contact to the left or right side of the segment,

{\mathbf{f}}_i &\pluseq& (1-\rho) \cdot {\mathbf{f}}^l      \\
\nonumber {\mathbf{f}}_{i+1} &\pluseq& \rho \cdot {\mathbf{f}}^r

while in case x_{gap} > 0 nothing is added.

The forces {\mathbf{f}}_i are then applied through the marker to the ObjectANCFCable2D element as point loads via a position jacobian (using the according access function), for details see the C++ implementation.

The forces on the circle marker m0 are computed as the total sum of all segment contact forces,

{\mathbf{f}}_{m0} = -\sum_{s_i} {\mathbf{f}}_{s_i}

and additional torques on the circle's rotation simply follow from

\tau_{m0} = -\sum_{s_i} r \cdot f_{t_{s_i}} .

During Newton iterations, the contact forces for segment s_i are considered only, if x_i <= 0. The dataCoordinate x_i is not modified during Newton iterations, but computed during the DiscontinuousIteration, see :numref:`fig-solver-discontinuous-iteration` in the solver description.

If activeConnector = False, all contact and friction forces on the cable and the force and torque on the circle's marker are set to zero.

Relevant Examples and TestModels with weblink:

beltDriveALE.py (Examples/), beltDriveReevingSystem.py (Examples/), beltDrivesComparison.py (Examples/), sliderCrank3DwithANCFbeltDrive.py (Examples/), sliderCrank3DwithANCFbeltDrive2.py (Examples/), ANCFcontactFrictionTest.py (TestModels/), ANCFmovingRigidBodyTest.py (TestModels/), ANCFslidingAndALEjointTest.py (TestModels/)

The web version may not be complete. For details, consider also the Exudyn PDF documentation : theDoc.pdf