def plotShiftedPotentialDiff(minDist,
                             maxDist,
                             chartName,
                             filename="plotPotentialDiff"):

    shift = MDFunctions.LennardJonesPotential(3, constants.eps, constants.sig)

    series = np.linspace(2.8, 3.1, 100)
    pot = MDFunctions.LennardJonesPotential(series, constants.eps,
                                            constants.sig, 0)
    pot2 = MDFunctions.LennardJonesPotential(series, constants.eps,
                                             constants.sig, shift)
    diff = pot - pot2

    plt.subplot(1, 1, 1)
    plt.title(chartName)
    plt.plot(series, pot, label=f'Non shifted')
    plt.plot(series, pot2, label=f'Shifted')
    plt.plot(series, diff, label=f'Difference between shifted and non shifted')

    plt.xlabel('distance (sigmas)')
    plt.ylabel('force')
    plt.legend()

    plt.savefig(f'./fig/{filename}.jpg')
    plt.show()
def plotPotential(minDist, maxDist, chartName, filename="plotPotential"):

    series = np.linspace(minDist, maxDist, 100)
    pot = MDFunctions.LennardJonesPotential(series, constants.eps,
                                            constants.sig)
    shiftedPot = MDFunctions.LennardJonesPotential(series, constants.eps,
                                                   constants.sig,
                                                   constants.cutOffRange)

    #plt.subplot(1,1,1)
    plt.title(chartName)
    plt.plot(series, pot, label=f'Unmodified')
    plt.plot(series, shiftedPot, label=f'Shifted')
    plt.xlabel('distance (sigmas)')
    plt.ylabel('force')
    plt.legend()

    plt.savefig(f'./fig/{filename}.jpg')
    plt.show()
def eulerCromer(p, n, dt, particles, eps, sig):
    scaleBy = 24
    acc_vec = np.array([0.0, 0.0, 0.0])
    pot = 0.
    for op in particles:
        if op is p:
            continue

        distvec = np.subtract(p.x[n], op.x[n])
        dist = np.sqrt(distvec[0]**2 + distvec[1]**2 + distvec[2]**2)
        forcescalar = 2 * (dist**-12) - dist**-6
        acc_vec += forcescalar * (distvec / dist**2.0)
        pot += MDFunctions.LennardJonesPotential(dist, eps, sig)

    p.p[n + 1] = pot
    p.a[n + 1] = scaleBy * acc_vec
    p.v[n + 1] = p.v[n] + dt * p.a[n + 1]
    p.x[n + 1] = p.x[n] + dt * p.v[n + 1]
    return p
def euler(p, n, dt, particles, eps, sig):
    scaleBy = 24
    acc_vec = np.array([0.0, 0.0, 0.0])
    pot = 0.
    #for op in particles:
    plen = len(particles)
    for op in particles:
        if op is p:
            continue

        distvec = np.subtract(p.x[n], op.x[n])
        dist = np.sqrt(distvec[0]**2 + distvec[1]**2 + distvec[2]**2)
        # pointTo = np.linalg.norm(distvec)
        forcescalar = 2 * (dist**-12) - dist**-6
        acc_vec = forcescalar * (distvec / dist**2)
        pot = MDFunctions.LennardJonesPotential(dist, eps, sig)

        #Initial particle
        p.p[n + 1] += pot
        p.a[n + 1] += scaleBy * acc_vec
        p.v[n + 1] += p.v[n] + dt * p.a[n + 1]
        p.x[n + 1] += p.x[n] + dt * p.v[n]

    p.swap(n + 1)