I think it should obvious that in a physical system you should not get a spiral in a rotating frame, if a particle is standing still in the noninertial frame.
This seems trivially settled by just writing a small python script and computing  to test if nothing else your understanding. As I have done below with the correct forms of the forces. I also included some trajectories (an artifact of what I’m talking about)  as you should do in the future so discussions can be productive. The trajectory is fairly circular with a small enough timestep for the trajectory, but does indeed travel outwards in a spiral that tightens the smaller you choose the timestep. I would lean towards what Adrian describes in this setup being numerically unstable.
I show 3 cases each run for the same amount of numerical time (they are shown in order)  all should go ~16 revolutions
 time step = 0.01; steps = 10^4 (radial position ~100X larger than the correct answer)
 time step = 0.001; steps = 10^5 (radial position about 100% error)
 time step = 0.0001; steps = 10^6 (gives ~ 2% error in the radial position)
This situation seems ripe for instability with two forces that must intimately balance one another with one essentially depending on the magnitude of the position (centrifugal) and the magnitude of the velocity (Coriolis). At a very basic level, having force evaluations where position (\propto centrifugal repulsive force) is a half step ahead of the velocity (\propto Coriolis attractive force) might be cause for concern and a growing numerical instability.
However… Ultimately, you’ll be performing DEM. I assume you’ll be bounding your domain and you’ve got some rotating piece of machinery  otherwise why do it. Given that granular potentials and walls are quite dissipative, frictional, and normally have plenty of contacts, you might not even care about this issue  as long as your timestep is small enough. On top of that a comparison of the timescales of your granular interactions and those required for getting reasonably stable behavior in your rotating frame (over some large time span) might very well show that the instability it not of much concern for industrially relevant problems.
HTH.
import numpy as np
import matplotlib.pyplot as plt
def Calc_Centrifugal_Accel(angular_velocity,position):
f_cent = np.cross(angular_velocity,np.cross(angular_velocity,position))
return f_cent
def Calc_Coriolis_Accel(angular_velocity, velocity):
f_cor = 2.*np.cross(angular_velocity,velocity)
return f_cor
assumes we rotate about the origin
axis_of_rotation = np.array([0,0,1])
angular_speed = 1
angular_velocity = angular_speed*axis_of_rotation
position = np.zeros((1,3))
position[0,0] = 1
initial velocity of the particle is in the opposite direction
of the tangential velocity of the frame at that point
velocity = np.sign(angular_speed)*np.cross( angular_velocity ,position)
pos = position
a_cent = Calc_Centrifugal_Accel(angular_velocity, position)
a_cor = Calc_Coriolis_Accel(angular_velocity, velocity)
print(a_cent, a_cor)
delt = 0.0001
perform velocity verlet integration on the particle
for i in range(1000000):
a_cent = Calc_Centrifugal_Accel(angular_velocity, position)
a_cor = Calc_Coriolis_Accel(angular_velocity, velocity)
vhalf = velocity + 0.5*(a_cent + a_cor)delt
position = position + vhalfdelt
a_cent = Calc_Centrifugal_Accel(angular_velocity, position)
a_cor = Calc_Coriolis_Accel(angular_velocity, vhalf)
velocity = vhalf + 0.5*(a_cent + a_cor)*delt
#print(np.linalg.norm(position), np.arctan2(position[0,0], position[0,1]), np.linalg.norm(velocity))
pos = np.append(pos, position, axis=0)
plt.plot(pos[:,0],pos[:,1])



Regards,
Eric Murphy, PhD
Multiphase Flow Scientist
Mechanical Engineer
[email protected]…24…  5634496661
LinkedIn  ResearchGate  Google Scholar