tresolve contact relative movement - slidergrid - grid of elastic sliders on a frictional surface
(HTM) git clone git://src.adamsgaard.dk/slidergrid
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 1cbb23226d339f3e3ef3d13fef3ab0141148fcbe
(DIR) parent 75872d905c2b8343e79dfd89b2122ad4d51b4f63
(HTM) Author: Anders Damsgaard <anders.damsgaard@geo.au.dk>
Date: Tue, 15 Mar 2016 16:23:06 -0700
resolve contact relative movement
Diffstat:
M main.c | 6 ++++--
M slider.c | 74 ++++++++++++++++++++++++++++---
M slider.h | 43 ++++++++++++++++++++++++++-----
M vector_math.c | 12 ++++++++++++
M vector_math.h | 2 ++
5 files changed, 124 insertions(+), 13 deletions(-)
---
(DIR) diff --git a/main.c b/main.c
t@@ -13,10 +13,12 @@ int main(int argc, char** argv)
const int N = nx*ny*nz;
slider* sliders = create_regular_slider_grid(nx, ny, nz, 1.0, 1.0, 1.0);
- // set slider masses
+ // set slider masses and moments of inertia
int i;
- for (i=0; i<N; i++)
+ for (i=0; i<N; i++) {
sliders[i].mass = 1.;
+ sliders[i].moment_of_inertia = 1.;
+ }
find_and_bond_to_neighbors_n2(sliders, N, 1.5);
(DIR) diff --git a/slider.c b/slider.c
t@@ -14,30 +14,94 @@ void print_slider_position(slider s)
void update_kinematics(slider s, Float dt, long int iteration)
{
s.acc = divide_float3_scalar(s.force, s.mass);
+ s.angacc = divide_float3_scalar(s.torque, s.moment_of_inertia);
- Float3 acc0;
- if (iteration == 0)
+ Float3 acc0, angacc0;
+ if (iteration == 0) {
acc0 = make_float3(0., 0., 0.);
- else
+ angacc0 = make_float3(0., 0., 0.);
+ } else {
acc0 = s.acc;
+ angacc0 = s.angacc;
+ }
const Float3 dacc_dt = make_float3(
(s.acc.x - acc0.x)/dt,
(s.acc.y - acc0.y)/dt,
(s.acc.z - acc0.z)/dt);
+ const Float3 dangacc_dt = make_float3(
+ (s.angacc.x - angacc0.x)/dt,
+ (s.angacc.y - angacc0.y)/dt,
+ (s.angacc.z - angacc0.z)/dt);
+
const Float3 dpos_dt = make_float3(
s.vel.x*dt + 0.5*s.acc.x*dt*dt + 1./6.*dacc_dt.x*dt*dt*dt,
s.vel.y*dt + 0.5*s.acc.y*dt*dt + 1./6.*dacc_dt.y*dt*dt*dt,
s.vel.z*dt + 0.5*s.acc.z*dt*dt + 1./6.*dacc_dt.z*dt*dt*dt);
+ const Float3 dangpos_dt = make_float3(
+ s.angvel.x*dt + 0.5*s.angacc.x*dt*dt + 1./6.*dangacc_dt.x*dt*dt*dt,
+ s.angvel.y*dt + 0.5*s.angacc.y*dt*dt + 1./6.*dangacc_dt.y*dt*dt*dt,
+ s.angvel.z*dt + 0.5*s.angacc.z*dt*dt + 1./6.*dangacc_dt.z*dt*dt*dt);
const Float3 dvel_dt = make_float3(
s.acc.x*dt + 0.5*dacc_dt.x*dt*dt,
s.acc.y*dt + 0.5*dacc_dt.y*dt*dt,
s.acc.z*dt + 0.5*dacc_dt.z*dt*dt);
- s.pos = add_float3(s.pos, dpos_dt);
- s.vel = add_float3(s.vel, dvel_dt);
+ const Float3 dangvel_dt = make_float3(
+ s.angacc.x*dt + 0.5*dangacc_dt.x*dt*dt,
+ s.angacc.y*dt + 0.5*dangacc_dt.y*dt*dt,
+ s.angacc.z*dt + 0.5*dangacc_dt.z*dt*dt);
+
+ s.pos = add_float3(s.pos, dpos_dt);
+ s.angpos = add_float3(s.angpos, dangpos_dt);
+ s.vel = add_float3(s.vel, dvel_dt);
+ s.angvel = add_float3(s.angvel, dangvel_dt);
+}
+
+// Find the relative displacement and velocity between two sliders
+void slider_displacement(slider s1, const slider s2, const Float dt)
+{
+
+ const Float3 dist = subtract_float3(s1.pos, s2.pos);
+ const Float dist_norm = norm_float3(dist);
+
+
+ // relative contact interface velocity w/o rolling
+ const Float3 vel_linear = subtract_float3(s1.vel, s2.vel);
+
+ // relative contact interface velocity with rolling
+ const Float3 vel = add_float3(vel_linear,
+ add_float3(
+ multiply_scalar_float3(dist_norm/2.,
+ cross_float3(dist, s1.angvel)),
+ multiply_scalar_float3(dist_norm/2.,
+ cross_float3(dist, s2.angvel))));
+
+
}
+
+
+// Resolve bond mechanics between a slider and one of its neighbors
+
+
+// Resolve interaction between a slider and all of its neighbors
+void slider_neighbor_interaction(
+ slider s,
+ const slider* sliders,
+ const int N)
+{
+ int i;
+ for (i=0; i<MAX_NEIGHBORS; i++) {
+ if (s.neighbors[i] != -1) {
+
+
+ }
+ }
+}
+
+
+
(DIR) diff --git a/slider.h b/slider.h
t@@ -6,13 +6,44 @@
#define MAX_NEIGHBORS 32
typedef struct {
- Float3 pos; // spatial position [m]
- Float3 vel; // spatial velocity [m/s]
- Float3 acc; // spatial acceleration [m/(s*s)]
- Float3 force; // sum of forces [N]
- Float mass; // mass [kg]
+
+ // linear position, velocity, acceleration of this slider
+ Float3 pos; // [m]
+ Float3 vel; // [m/s]
+ Float3 acc; // [m/(s*s)]
+
+ // angular position, velocity, acceleration of this slider
+ Float3 angpos; // [m]
+ Float3 angvel; // [m/s]
+ Float3 angacc; // [m/(s*s)]
+
+ // sum of forces acting on this slider [N]
+ Float3 force;
+
+ // sum of torques acting on this slider [N*m]
+ Float3 torque;
+
+ // slider mass [kg]
+ Float mass;
+
+ // moment of inertia [kg m*m]
+ Float moment_of_inertia;
+
+ // inter-slider contact model parameters
Float spring_stiffness; // elastic compressibility [N/m]
- int neighbors[MAX_NEIGHBORS]; // indexes of sliders this one is bonded to
+
+ // slider-surface contact model parameters
+ Float coulomb_friction; // Coulomb frictional value [-]
+
+ // The uniquely identifying indexes of the slider neighbors which are bonded
+ // to this slider. A value of -1 denotes an empty field. Preallocated for
+ // speed.
+ int neighbors[MAX_NEIGHBORS];
+
+ // relative spatial movement between this slider and its neighbors
+ Float3 neighbor_relative_displacement[MAX_NEIGHBORS];
+ Float3 neighbor_relative_contact_velocity[MAX_NEIGHBORS];
+
} slider;
(DIR) diff --git a/vector_math.c b/vector_math.c
t@@ -43,6 +43,13 @@ inline Float3 divide_float3(Float3 v1, Float3 v2)
return make_float3(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z);
}
+inline Float3 cross_float3(Float3 v1, Float3 v2)
+{
+ return make_float3(
+ v1.y*v2.z - v1.z*v2.y,
+ v1.z*v2.x - v1.x*v2.z,
+ v1.x*v2.y - v1.y*v2.x);
+}
// vector-scalar operations
inline Float3 add_float3_scalar(Float3 v, Float s)
t@@ -70,6 +77,11 @@ inline Float3 multiply_float3_scalar(Float3 v, Float s)
return make_float3(v.x*s, v.y*s, v.z*s);
}
+inline Float3 multiply_scalar_float3(Float s, Float3 v)
+{
+ return multiply_float3_scalar(v, s);
+}
+
inline Float3 divide_float3_scalar(Float3 v, Float s)
{
return make_float3(v.x/s, v.y/s, v.z/s);
(DIR) diff --git a/vector_math.h b/vector_math.h
t@@ -12,9 +12,11 @@ Float3 add_float3(Float3 v1, Float3 v2);
Float3 subtract_float3(Float3 v1, Float3 v2);
Float3 multiply_float3(Float3 v1, Float3 v2);
Float3 divide_float3(Float3 v1, Float3 v2);
+Float3 cross_float3(Float3 v1, Float3 v2);
// vector-scalar operations
Float3 multiply_float3_scalar(Float3 v, Float s);
+Float3 multiply_scalar_float3(Float s, Float3 v);
Float3 divide_float3_scalar(Float3 v, Float s);
Float3 divide_scalar_float3(Float s, Float3 v);
Float3 add_float3_scalar(Float3 v, Float s);