State vectors ($x, y, z, v_x, v_y, v_z$) are the real output of the ephemeris for the planets and moons, and the orbit propagators for the minor bodies and spacecraft that Horizons provides. What you are looking at are Osculating Orbital Elements, which are the instantaneous values of a hypothetical, elliptical orbit that would be tangent to the real orbit at that moment in time. Every new line in the osculating elements table is a totally different hypothetical orbit that is perfectly tangent to the real orbit at that moment only.
An excellent clue to this would be the fact that every point in time has new values for all of the orbital elements. If these were fixed, elliptical orbits instead of instantaneous osculating elements, the numbers would not have to be recalculated for each point in time.
You can read more about osculating vs Keplerian orbits in this excellent answer. You can also see "live" osculating orbits changing moment-by-moment in the excellent YouTube video Pythagorean 3-Body Problem With Osculating Orbits. Here is a screen shot: (read more about this mathematical problem in this question.) While the orbits (thick lines) are chaotic, the osculating orbits are always elliptical.
No solar system orbit is perfectly elliptical because of the mutual gravitational attraction between all bodies, including central and tidal forces. However, for the period of one year, Venus' orbit around the Sun itself is much closer to elliptical than is it's path around the solar system barycenter. Over years, the Sun slowly moves around by a few hundred thousand kilometers in response to the motion of the large outer planets Jupiter, Saturn, Uranus and Neptune. However, the inner planets keep fairly close to Kelperian orbits around the Sun wherever it happens to be at the time.
Here is the setup I used to extract daily osculating elements for Venus around first the Sun (body centered) and then the solar system barycenter.
This is a plot of some of those elements, including eccentricity. The straight (blue) lines are the osculating parameters for the Sun-centered data, and the wavy (green) lines are the osculating parameters calculated about the Solar System Barycenter. You can see that for the barycentric osculating elements they vary quite a bit, while the osculating elements for orbits about the Sun are almost constant, meaning that the real orbit of Venus is extremely close to a hypothetical elliptical orbit around the Sun.
You can see your values of ~0.017 and ~0.007 as the starting points on the left side of the top (eccentricity) plot!
I've also included the Python script that made the plot, so you can check how it's done.
import numpy as np
import matplotlib.pyplot as plt
fnames = ("Venus Sun 2018 daily horizons_results.txt",
"Venus Bary 2018 daily horizons_results.txt")
"""
JDTDB Julian Day Number, Barycentric Dynamical Time
EC Eccentricity, e
QR Periapsis distance, q (au)
IN Inclination w.r.t XY-plane, i (degrees)
OM Longitude of Ascending Node, OMEGA, (degrees)
W Argument of Perifocus, w (degrees)
Tp Time of periapsis (Julian Day Number)
N Mean motion, n (degrees/day)
MA Mean anomaly, M (degrees)
TA True anomaly, nu (degrees)
A Semi-major axis, a (au)
AD Apoapsis distance (au)
PR Sidereal orbit period (day)
"""
blobs = []
element_sets = []
for fname in fnames:
with open(fname, 'r') as infile:
blob = infile.read().splitlines()
print fname
istart = [i for i, line in enumerate(blob) if "$$SOE" in line][0]
iend = [i for i, line in enumerate(blob) if "$$EOE" in line][0]
print len(blob), istart, iend
blob = [line.split(',') for line in blob[istart+1: iend]]
blobs.append(blob)
JD = np.array([float(line[0]) for line in blob])
elements = np.array([[float(x) for x in line[2:14]] for line in blob])
data = np.vstack((JD, elements.T))
element_sets.append(data)
Data = np.stack(element_sets, axis=1)[..., :225] # just 225 days
print Data.shape
if 1 == 1:
plt.figure()
indices = (1, 2, 10, 11, 12)
names = ('eccentricity', 'periapsis (AU)', 'semi-major axis (AU)',
'apoapsis AU', 'period (days)')
for i, (j, name) in enumerate(zip(indices, names)):
plt.subplot(len(indices), 1, i+1)
for k, thing in enumerate(Data[j]):
plt.plot(Data[0, k]-Data[0, k, 0], thing)
plt.title(name)
plt.show()
