amber-mden-analyzer.py

#!/usr/bin/python
#***************************************************************************
#    amber_mden_analyzer.py
#	- Python script for the transformation of mden to a XY file for
#                 graphic display
#                             -------------------
#    begin                : Wed Mar 21 2007
#    copyright            : (C) 2004 by Nelson Fonseca
#    email                : nfonseca@dq.ua.pt
# ***************************************************************************/

#/***************************************************************************
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU General Public License as published by  *
# *   the Free Software Foundation; either version 2 of the License, or     *
# *   (at your option) any later version.                                   *
# *                                                                         *
# ***************************************************************************/
#V0.1 21/03/2007


############################
#	import modules	   #
############################

import string			# import string module
import re			# import regular expression module
from array import *		# import everything from array module

###########################
#	input		  #
###########################



mden=raw_input("Enter Input File Name: ")
timestep=float(raw_input("Enter the Time Step: "))	# time step used in the MD
ntwe=int(raw_input("Enter the Value of ntwe: "))	# output frequency of the mden file


file_input=open(mden)

lines=file_input.read()		# loads the entire file in one list of strings

lines_split=lines.split()	# splits the list in multiple strings with space delimiter by default

del lines_split[0:51]		# remove headers lines


####################################
# FILES FROM OUTPUT RESULTS	   #
####################################

Nsteps_file=open("Nsteps.txt","w")
Nsteps_file.write("#""\t""Nsteps""\t\t""time (ps)""\n")

Etot_file=open("Etot.txt","w")
Etot_file.write("#""\t""time (ps)""\t""Etot (kcal/mol""\t\t""<Etot>""\n")

EKinetic_file=open("EKinetic.txt","w")
EKinetic_file.write("#""\t""time (ps)""\t""EKinetic (kcal/mmol)""\t\t""<EKinetic>""\n")

Temp_file=open("Temp.txt","w")
Temp_file.write("#""\t""time (ps)""\t""Temp (K)""\t\t\t""<Temp>""\n")

T_solute_file=open("T_solute.txt","w")
T_solute_file.write("#""\t""time (ps)""\t""T_solute (K)""\t\t""<T_solute>""\n")

T_solv_file=open("T_solv.txt","w")
T_solv_file.write("#""\t""time (ps)""\t""T_solv (K)""\t\t\t""<T_solv>""\n")

Pres_scal_solu_file=open("Pres_scal_solu.txt","w")
Pres_scal_solu_file.write("#""\t""time (ps)""\t""Pres_scal_solu""\t\t""<Pres_scal_solu>""\n")

Pres_scal_solv_file=open("Pres_scal_solv.txt","w")
Pres_scal_solv_file.write("#""\t""time (ps)""\t""Pres_scal_solv""\t\t""<Pres_scal_solv>""\n")

BoxX_file=open("BoxX.txt","w")
BoxX_file.write("#""\t""time (ps)""\t""BoxX""\t\t\t""<BoxX>""\n")

BoxY_file=open("BoxY.txt","w")
BoxY_file.write("#""\t""time (ps)""\t""BoxY""\t\t\t""<BoxY>""\n")

BoxZ_file=open("BoxZ.txt","w")
BoxZ_file.write("#""\t""time (ps)""\t""BoxZ""\t\t\t""<BoxZ>""\n")

volume_file=open("volume.txt","w")
volume_file.write("#""\t""time (ps)""\t""volume (A^3)""\t\t""<volume>""\n")

pres_X_file=open("pres_X.txt","w")
pres_X_file.write("#""\t""time (ps)""\t""pres_X""\t\t\t""<pres_X>""\n")

pres_Y_file=open("pres_Y.txt","w")
pres_Y_file.write("#""\t""time (ps)""\t""pres_Y""\t\t\t""<pres_Y>""\n")

pres_Z_file=open("pres_Z.txt","w")
pres_Z_file.write("#""\t""time (ps)""\t""pres_Z""\t\t\t""<pres_Z>""\n")

Pressure_file=open("Pressure.txt","w")
Pressure_file.write("#""\t""time (ps)""\t""Pressure""\t\t""<Pressure>""\n")

EKCoM_x_file=open("EKCoM_x.txt","w")
EKCoM_x_file.write("#""\t""time (ps)""\t""EKCoM_x""\t\t\t""<EKCoM_x>""\n")

EKCoM_y_file=open("EKCoM_y.txt","w")
EKCoM_y_file.write("#""\t""time (ps)""\t""EKCoM_y""\t\t\t""<EKCoM_y>""\n")

EKCoM_z_file=open("EKCoM_z.txt","w")
EKCoM_z_file.write("#""\t""time (ps)""\t""EKCoM_z""\t\t\t""<EKCoM_z>""\n")

EKComTot_file=open("EKComTot.txt","w")
EKComTot_file.write("#""\t""time (ps)""\t""EKComTot""\t\t""<EKComTot>""\n")

VIRIAL_x_file=open("VIRIAL_x.txt","w")
VIRIAL_x_file.write("#""\t""time (ps)""\t""VIRIAL_x""\t\t""<VIRIAL_x>""\n")

VIRIAL_y_file=open("VIRIAL_y.txt","w")
VIRIAL_y_file.write("#""\t""time (ps)""\t""VIRIAL_y""\t\t""<VIRIAL_y>""\n")

VIRIAL_z_file=open("VIRIAL_z.txt","w")
VIRIAL_z_file.write("#""\t""time (ps)""\t""VIRIAL_z""\t\t""<VIRIAL_z>""\n")

VIRIAL_tot_file=open("VIRIAL_tot.txt","w")
VIRIAL_tot_file.write("#""\t""time (ps)""\t""VIRIAL_tot""\t\t""<VIRIAL_tot>""\n")

E_pot_file=open("E_pot.txt","w")
E_pot_file.write("#""\t""time (ps)""\t""E_pot (kcal/mol)""\t\t""<E_pot>""\n")

E_vdw_file=open("E_vdw.txt","w")
E_vdw_file.write("#""\t""time (ps)""\t""E_vdw (kcal/mol)""\t\t""<E_vdw>""\n")

E_el_file=open("E_el.txt","w")
E_el_file.write("#""\t""time (ps)""\t""E_el (kcal/mol)""\t\t\t""<E_el>""\n")

E_hbon_file=open("E_hbon.txt","w")
E_hbon_file.write("#""\t""time (ps)""\t""E_hbon (kcal/mol)""\t\t""<E_hbon>""\n")

E_bon_file=open("E_bon.txt","w")
E_bon_file.write("#""\t""time (ps)""\t""E_bon (kcal/mol)""\t\t""<E_bon>""\n")

E_angle_file=open("E_angle.txt","w")
E_angle_file.write("#""\t""time (ps)""\t""E_angle (kcal/mol)""\t\t""<E_angle>""\n")

E_dih_file=open("E_dih.txt","w")
E_dih_file.write("#""\t""time (ps)""\t""E_dih (kcal/mol)""\t\t""<E_dih>""\n")

E_14vdw_file=open("E_14vdw.txt","w")
E_14vdw_file.write("#""\t""time (ps)""\t""E_14vdw (kcal/mol)""\t\t""<E_14vdw>""\n")

E_14el_file=open("E_14el.txt","w")
E_14el_file.write("#""\t""time (ps)""\t""E_14el (kcal/mol)""\t\t""<E_14el>""\n")

E_const_file=open("E_const.txt","w")
E_const_file.write("#""\t""time (ps)""\t""E_const (kcal/mol)""\t\t""<E_const>""\n")

E_pol_file=open("E_pol.txt","w")
E_pol_file.write("#""\t""time (ps)""\t""E_pol (kcal/mol)""\t\t""<E_pol>""\n")

AV_permMoment_file=open("AV_permMoment.txt","w")
AV_permMoment_file.write("#""\t""time (ps)""\t""AV_permMoment""\t\t""<AV_permMoment>""\n")

AV_indMoment_file=open("AV_indMoment.txt","w")
AV_indMoment_file.write("#""\t""time (ps)""\t""AV_indMoment""\t\t""<AV_indMoment>""\n")

AV_totMoment_file=open("AV_totMoment.txt","w")
AV_totMoment_file.write("#""\t""time (ps)""\t""AV_totMoment""\t\t""<AV_totMoment>""\n")

Density_file=open("Density.txt","w")
Density_file.write("#""\t""time (ps)""\t""Density (g/cm^3)""\t\t""<Density>""\n")

dV_dlambda_file=open("dV_dlambda.txt","w")
dV_dlambda_file.write("#""\t""time (ps)""\t""dV/dlambda""\t\t""<dV/dlambda>""\n")


###########################
#			  #
#	Loops over file   #
###########################

j=0	# time counter
i=0	# Nstep counter
step=0	# initialize step

while i < len(lines_split) or j < len(lines_split):


    Nsteps=lines_split[i]
    time=lines_split[j]


    timetemp=timestep*ntwe*step

    i=i+51
    j=j+51

    Nsteps_file.write("\t" + str(step) + "\t" + str(timetemp) + "\n")

    step=step+1

print "\nOutputing..."

j=2	# reinitialize time counter
k=3	# set Etot counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_Etot=array("f")
while j<len(lines_split) or k<len(lines_split) :


    time=float(lines_split[j])
    Etot=float(lines_split[k])
    matrix_Etot.append(Etot)
    sum=sum+Etot
    average=sum/len(matrix_Etot)

    timetemp=timestep*ntwe*step

    Etot_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Etot) + "\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    k=k+51
    step=step+1


print "Outputing..."

j=2	# reinitialize time counter
l=4	# EKinetic counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step


matrix_EKinetic=array("f")
while j<len(lines_split) or l<len(lines_split) :


    time=float(lines_split[j])
    EKinetic=float(lines_split[l])
    matrix_EKinetic.append(EKinetic)
    sum=sum+EKinetic
    average=sum/len(matrix_EKinetic)

    timetemp=timestep*ntwe*step

    EKinetic_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%EKinetic) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    l=l+51


print "Outputing..."

j=2	# reinitialize time counter
m=6	# Temp counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_Temp=array("f")
while j<len(lines_split) or m<len(lines_split) :


    time=float(lines_split[j])
    Temp=float(lines_split[m])
    matrix_Temp.append(Temp)
    sum=sum+Temp
    average=sum/len(matrix_Temp)

    timetemp=timestep*ntwe*step

    Temp_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Temp) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    m=m+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
n=7	# T_solute counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_T_solute=array("f")
while j<len(lines_split) or n<len(lines_split) :


    time=float(lines_split[j])
    T_solute=float(lines_split[n])
    matrix_T_solute.append(T_solute)
    sum=sum+T_solute
    average=sum/len(matrix_T_solute)
    timetemp=timestep*ntwe*step

    T_solute_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%T_solute) + "\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    n=n+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
o=8	# T_solv counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_T_solv=array("f")
while j<len(lines_split) or o<len(lines_split) :


    time=float(lines_split[j])
    T_solv=float(lines_split[o])
    matrix_T_solv.append(T_solv)
    sum=sum+T_solv
    average=sum/len(matrix_T_solv)

    timetemp=timestep*ntwe*step

    T_solv_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%T_solv) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    o=o+51
    step=step+1

print "Outputing..."


j=2	# reinitialize time counter
p=9	# Pres_scal_solu counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step


matrix_Pres_scal_solu=array("f")
while j<len(lines_split) or p<len(lines_split) :


    time=float(lines_split[j])
    Pres_scal_solu=float(lines_split[p])
    matrix_Pres_scal_solu.append(Pres_scal_solu)
    sum=sum+Pres_scal_solu
    average=sum/len(matrix_Pres_scal_solu)
    timetemp=timestep*ntwe*step

    Pres_scal_solu_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Pres_scal_solu) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    p=p+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
q=11	# Pres_scal_solv counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_Pres_scal_solv=array("f")
while j<len(lines_split) or q<len(lines_split) :


    time=float(lines_split[j])
    Pres_scal_solv=float(lines_split[q])
    matrix_Pres_scal_solv.append(Pres_scal_solv)
    sum=sum+Pres_scal_solv
    average=sum/len(matrix_Pres_scal_solv)
    timetemp=timestep*ntwe*step

    Pres_scal_solv_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Pres_scal_solv) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    q=q+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
r=12	# BoxX counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_BoxX=array("f")
while j<len(lines_split) or r<len(lines_split) :


    time=float(lines_split[j])
    BoxX=float(lines_split[r])
    matrix_BoxX.append(BoxX)
    sum=sum+BoxX
    average=sum/len(matrix_BoxX)
    timetemp=timestep*ntwe*step

    BoxX_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%BoxX) + "\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    r=r+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
s=13	# BoxY counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_BoxY=array("f")
while j<len(lines_split) or s<len(lines_split) :


    time=float(lines_split[j])
    BoxY=float(lines_split[s])
    matrix_BoxY.append(BoxY)
    sum=sum+BoxY
    average=sum/len(matrix_BoxY)
    timetemp=timestep*ntwe*step

    BoxY_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%BoxY) +"\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    s=s+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
t=14	# BoxZ counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_BoxZ=array("f")
while j<len(lines_split) or t<len(lines_split) :


    time=float(lines_split[j])
    BoxZ=float(lines_split[t])
    matrix_BoxZ.append(BoxZ)
    sum=sum+BoxZ
    average=sum/len(matrix_BoxZ)
    timetemp=timestep*ntwe*step

    BoxZ_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%BoxZ) + "\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    t=t+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
u=16	# volume counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_volume=array("f")
while j<len(lines_split) or u<len(lines_split) :


    time=float(lines_split[j])
    volume=float(lines_split[u])
    matrix_volume.append(volume)
    sum=sum+volume
    average=sum/len(matrix_volume)
    timetemp=timestep*ntwe*step

    volume_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%volume) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    u=u+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
v=17	# pres_X counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_pres_X=array("f")
while j<len(lines_split) or v<len(lines_split) :


    time=float(lines_split[j])
    pres_X=float(lines_split[v])
    matrix_pres_X.append(pres_X)
    sum=sum+pres_X
    average=sum/len(matrix_pres_X)
    timetemp=timestep*ntwe*step

    pres_X_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%pres_X) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    v=v+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
w=18	# pres_Y counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_pres_Y=array("f")
while j<len(lines_split) or w<len(lines_split) :


    time=float(lines_split[j])
    pres_Y=float(lines_split[w])
    matrix_pres_Y.append(pres_Y)
    sum=sum+pres_Y
    average=sum/len(matrix_pres_Y)
    timetemp=timestep*ntwe*step


    pres_Y_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%pres_Y) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    w=w+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
y=19	# pres_Z counter
sum=0.0 # initial sum counter for averages
step=0	# initialize step

matrix_pres_Z=array("f")
while j<len(lines_split) or y<len(lines_split) :


    time=float(lines_split[j])
    pres_Z=float(lines_split[y])
    matrix_pres_Z.append(pres_Z)
    sum=sum+pres_Z
    average=sum/len(matrix_pres_Z)
    timetemp=timestep*ntwe*step

    pres_Z_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%pres_Z) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    y=y+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
z=21	# Pressure counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_Pressure=array("f")
while j<len(lines_split) or z<len(lines_split) :


    time=float(lines_split[j])
    Pressure=float(lines_split[z])
    matrix_Pressure.append(Pressure)
    sum=sum+Pressure
    average=sum/len(matrix_Pressure)
    timetemp=timestep*ntwe*step


    Pressure_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Pressure) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    z=z+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
kk=22	# EKCoM_x counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_EKCoM_x=array("f")
while j<len(lines_split) or kk<len(lines_split) :


    time=float(lines_split[j])
    EKCoM_x=float(lines_split[kk])
    matrix_EKCoM_x.append(EKCoM_x)
    sum=sum+EKCoM_x
    average=sum/len(matrix_EKCoM_x)
    timetemp=timestep*ntwe*step

    EKCoM_x_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%EKCoM_x) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    kk=kk+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
ll=23	# EKCoM_y counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_EKCoM_y=array("f")
while j<len(lines_split) or ll<len(lines_split) :


    time=float(lines_split[j])
    EKCoM_y=float(lines_split[ll])
    matrix_EKCoM_y.append(EKCoM_y)
    sum=sum+EKCoM_y
    average=sum/len(matrix_EKCoM_y)
    timetemp=timestep*ntwe*step

    EKCoM_y_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%EKCoM_y) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    ll=ll+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
mm=24	# EKCoM_Z counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_EKCoM_z=array("f")
while j<len(lines_split) or mm<len(lines_split) :


    time=float(lines_split[j])
    EKCoM_z=float(lines_split[mm])
    matrix_EKCoM_z.append(EKCoM_z)
    sum=sum+EKCoM_z
    average=sum/len(matrix_EKCoM_z)
    timetemp=timestep*ntwe*step

    EKCoM_z_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%EKCoM_z) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    mm=mm+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
nn=26	# EKComTot counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_EKComTot=array("f")
while j<len(lines_split) or nn<len(lines_split) :


    time=float(lines_split[j])
    EKComTot=float(lines_split[nn])
    matrix_EKComTot.append(EKComTot)
    sum=sum+EKComTot
    average=sum/len(matrix_EKComTot)
    timetemp=timestep*ntwe*step


    EKComTot_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%EKComTot) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    nn=nn+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
oo=27	# VIRIAL_x counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_VIRIAL_x=array("f")
while j<len(lines_split) or oo<len(lines_split) :


    time=float(lines_split[j])
    VIRIAL_x=float(lines_split[oo])
    matrix_VIRIAL_x.append(VIRIAL_x)
    sum=sum+VIRIAL_x
    average=sum/len(matrix_VIRIAL_x)
    timetemp=timestep*ntwe*step

    VIRIAL_x_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%VIRIAL_x) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    oo=oo+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
pp=28	# VIRIAL_y counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_VIRIAL_y=array("f")
while j<len(lines_split) or pp<len(lines_split) :


    time=float(lines_split[j])
    VIRIAL_y=float(lines_split[pp])
    matrix_VIRIAL_y.append(VIRIAL_y)
    sum=sum+VIRIAL_y
    average=sum/len(matrix_VIRIAL_y)
    timetemp=timestep*ntwe*step

    VIRIAL_y_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%VIRIAL_y) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    pp=pp+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
qq=29	# VIRIAL_z counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_VIRIAL_z=array("f")
while j<len(lines_split) or qq<len(lines_split) :


    time=float(lines_split[j])
    VIRIAL_z=float(lines_split[qq])
    matrix_VIRIAL_z.append(VIRIAL_z)
    sum=sum+VIRIAL_z
    average=sum/len(matrix_VIRIAL_z)
    timetemp=timestep*ntwe*step

    VIRIAL_z_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%VIRIAL_z) +"\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    qq=qq+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
rr=31	# VIRIAL_tot counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_VIRIAL_tot=array("f")
while j<len(lines_split) or rr<len(lines_split) :


    time=float(lines_split[j])
    VIRIAL_tot=float(lines_split[rr])
    matrix_VIRIAL_tot.append(VIRIAL_tot)
    sum=sum+VIRIAL_tot
    average=sum/len(matrix_VIRIAL_tot)
    timetemp=timestep*ntwe*step

    VIRIAL_tot_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%VIRIAL_tot) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    rr=rr+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
ss=32	# E_pot counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_pot=array("f")
while j<len(lines_split) or ss<len(lines_split) :


    time=float(lines_split[j])
    E_pot=float(lines_split[ss])
    matrix_E_pot.append(E_pot)
    sum=sum+E_pot
    average=sum/len(matrix_E_pot)
    timetemp=timestep*ntwe*step

    E_pot_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_pot) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    ss=ss+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
tt=33	# E_vdw counterE_bon
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_vdw=array("f")
while j<len(lines_split) or tt<len(lines_split) :


    time=float(lines_split[j])
    E_vdw=float(lines_split[tt])
    matrix_E_vdw.append(E_vdw)
    sum=sum+E_vdw
    average=sum/len(matrix_E_vdw)
    timetemp=timestep*ntwe*step

    E_vdw_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_vdw) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    tt=tt+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
uu=34	# E_el counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_el=array("f")
while j<len(lines_split) or uu<len(lines_split) :


    time=float(lines_split[j])
    E_el=float(lines_split[uu])
    matrix_E_el.append(E_el)
    sum=sum+E_el
    average=sum/len(matrix_E_el)
    timetemp=timestep*ntwe*step

    E_el_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_el) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    uu=uu+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
vv=36	# E_hbon counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_hbon=array("f")
while j<len(lines_split) or vv<len(lines_split) :


    time=float(lines_split[j])
    E_hbon=float(lines_split[vv])
    matrix_E_hbon.append(E_hbon)
    sum=sum+E_hbon
    average=sum/len(matrix_E_hbon)
    timetemp=timestep*ntwe*step

    E_hbon_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_hbon) + "\t\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    vv=vv+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
ww=37	# E_bon counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_bon=array("f")
while j<len(lines_split) or ww<len(lines_split) :


    time=float(lines_split[j])
    E_bon=float(lines_split[ww])
    matrix_E_bon.append(E_bon)
    sum=sum+E_bon
    average=sum/len(matrix_E_bon)
    timetemp=timestep*ntwe*step

    E_bon_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_bon) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    ww=ww+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
yy=38	# E_angle counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_angle=array("f")
while j<len(lines_split) or yy<len(lines_split) :


    time=float(lines_split[j])
    E_angle=float(lines_split[yy])
    matrix_E_angle.append(E_angle)
    sum=sum+E_angle
    average=sum/len(matrix_E_angle)
    timetemp=timestep*ntwe*step

    E_angle_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_angle) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    yy=yy+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
zz=39	# E_dih counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_dih=array("f")
while j<len(lines_split) or zz<len(lines_split) :


    time=float(lines_split[j])
    E_dih=float(lines_split[zz])
    matrix_E_dih.append(E_dih)
    sum=sum+E_dih
    average=sum/len(matrix_E_dih)
    timetemp=timestep*ntwe*step

    E_dih_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_dih) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    zz=zz+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
kkk=41	# E_14vdw counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_14vdw=array("f")
while j<len(lines_split) or kkk<len(lines_split) :


    time=float(lines_split[j])
    E_14vdw=float(lines_split[kkk])
    matrix_E_14vdw.append(E_14vdw)
    sum=sum+E_14vdw
    average=sum/len(matrix_E_14vdw)
    timetemp=timestep*ntwe*step

    E_14vdw_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_14vdw) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    kkk=kkk+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
lll=42	# E_14el counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_14el=array("f")
while j<len(lines_split) or lll<len(lines_split) :


    time=float(lines_split[j])
    E_14el=float(lines_split[lll])
    matrix_E_14el.append(E_14el)
    sum=sum+E_14el
    average=sum/len(matrix_E_14el)
    timetemp=timestep*ntwe*step

    E_14el_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_14el) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    lll=lll+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
mmm=43	# E_const counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_const=array("f")
while j<len(lines_split) or mmm<len(lines_split) :


    time=float(lines_split[j])
    E_const=float(lines_split[mmm])
    matrix_E_const.append(E_const)
    sum=sum+E_const
    average=sum/len(matrix_E_const)
    timetemp=timestep*ntwe*step

    E_const_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_const) + "\t\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    mmm=mmm+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
nnn=44	# E_pol counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_E_pol=array("f")
while j<len(lines_split) or nnn<len(lines_split) :


    time=float(lines_split[j])
    E_pol=float(lines_split[nnn])
    matrix_E_pol.append(E_pol)
    sum=sum+E_pol
    average=sum/len(matrix_E_pol)
    timetemp=timestep*ntwe*step

    E_pol_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%E_pol) + "\t\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    nnn=nnn+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
ooo=46	# AV_permMoment counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_AV_permMoment=array("f")
while j<len(lines_split) or ooo<len(lines_split) :


    time=float(lines_split[j])
    AV_permMoment=float(lines_split[ooo])
    matrix_AV_permMoment.append(AV_permMoment)
    sum=sum+AV_permMoment
    average=sum/len(matrix_AV_permMoment)
    timetemp=timestep*ntwe*step

    AV_permMoment_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%AV_permMoment) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    ooo=ooo+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
ppp=47	# AV_indMoment counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_AV_indMoment=array("f")
while j<len(lines_split) or ppp<len(lines_split) :


    time=float(lines_split[j])
    AV_indMoment=float(lines_split[ppp])
    matrix_AV_indMoment.append(AV_indMoment)
    sum=sum+AV_indMoment
    average=sum/len(matrix_AV_indMoment)
    timetemp=timestep*ntwe*step

    AV_indMoment_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%AV_indMoment) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    ppp=ppp+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
qqq=48	# AV_totMoment counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_AV_totMoment=array("f")
while j<len(lines_split) or qqq<len(lines_split) :


    time=float(lines_split[j])
    AV_totMoment=float(lines_split[qqq])
    matrix_AV_totMoment.append(AV_totMoment)
    sum=sum+AV_totMoment
    average=sum/len(matrix_AV_totMoment)
    timetemp=timestep*ntwe*step

    AV_totMoment_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%AV_totMoment) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    qqq=qqq+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
rrr=49	# Density counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_Density=array("f")
while j<len(lines_split) or rrr<len(lines_split) :


    time=float(lines_split[j])
    Density=float(lines_split[rrr])
    matrix_Density.append(Density)
    sum=sum+Density
    average=sum/len(matrix_Density)
    timetemp=timestep*ntwe*step

    Density_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%Density) + "\t\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    rrr=rrr+51
    step=step+1

print "Outputing..."

j=2	# reinitialize time counter
sss=50	# dV/dlambda counter
sum=0.0	# initial sum counter for averages
step=0	# initialize step

matrix_dV_dlambda=array("f")
while j<len(lines_split) or sss<len(lines_split) :


    time=float(lines_split[j])
    dV_dlambda=float(lines_split[sss])
    matrix_dV_dlambda.append(dV_dlambda)
    sum=sum+dV_dlambda
    average=sum/len(matrix_dV_dlambda)
    timetemp=timestep*ntwe*step

    dV_dlambda_file.write("\t" + str(timetemp) + "\t\t" + str('%.3f'%dV_dlambda) + "\t\t\t" + str('%.3f'%average) + "\n")

    j=j+51
    sss=sss+51
    step=step+1

print "Outputing..."

print "\nFINISH! Now you can plot the data files."