#master anlysis script for Turbomole Simulations

from IO import IO

from Molecule import Molecule

from Properties import Properties

import argparse as ap

from documentation import analysis as doc

import os

import constants as consts

#Script arguemnts##################################################################

# By default, script will parse all simulations, and mdlogs, and last timestep in each mdlog

# will perform full fragment analysis

# and will present results to user

# -h: help, provide documetation on script

# -ss: int, starting simulation, sumulation to start from, defualt = 0

# -es: int, ending simulation, simulation to end from, defualt = max

# -sm: int, starting md log, md log to start from, defualt = 0

# -em: int, ending md log, md log to end form, defualt = max

# -st: int, all, first, last

# -et: int,

# -ip: list of lists, individual parsing, list of type [[s,m,t],[s1,m1,t1],...[sn,mn,tn]], where s = simulation int, m = md log int, t = struct int

# -ip: continued, s,m, and t can also be lists in themselves, ex. [ [ [1,2], [4,5,6], [1,2,3] ] ], would parse the first three data structures from the 4th, 5th, and 6th md logs of the first two simulations

# -ip: continued, default = not used

# -nf: t/f, new folder, save anlysis data to new folder, defualt = true

# -o: string of anlysis folder, overwrite, save anlysis data to existing data file, defualt = false

# -fn: string, folder name, name of anylysis folder, defualt = anlysisN, where n is the number of previous analyzations that have occured

# init global variables################################################################################

# main tool classes

io = IO()

molecule = Molecule()

#init script arguments

parser = ap.ArgumentParser(description = doc.overview)

parser.add_argument('-ss',metavar="startSimulation", type=int,help=doc.ss)

parser.add_argument('-es',metavar="endSimulation", type=int,help=doc.es)

#parser.add_argument('-sm',metavar="startMD",type=int, help=doc.sm)

#parser.add_argument('-em',metavar="endMD", type=int, help=doc.em)

parser.add_argument('-ts',metavar="timestep",default="last",type=str, help=doc.ts)

#parser.add_argument('-st',metavar="startStructure", help=doc.st)

#parser.add_argument('-et',metavar="endStructure",default="last", help=doc.et)

#parser.add_argument('-ip',metavar="indvidualParsing",default="[void]", help=doc.ip)

parser.add_argument('-f',metavar ="folderHead",default="b4500m", type=str, help=doc.f)

#parser.add_argument('-nf',metavar="nf", help=doc.nf)

#parser.add_argument('-ss',metavar="ss",default="0", help=doc.ss)

#parser.add_argument('-ss',metavar="ss",default="0", help=doc.ss)

args = parser.parse_args()

print(args.ss)

#init global functions###############################################################################

#create analysis folder and populate with specified MD log data

def initAnalysis(args):

populateAnalysisFolder(atoms,args.f,args.ts,simulationsToParse)

#calculate specified molecular properties

def calculateProperties(timestepData,atoms):

return timestepData

#present specified data to user

def viewResults():

return 0

#generates analysis folder structure and populates folders with MD data

def populateAnalysisFolder(atoms, folderHead, timestepsToParse, simulationsToParse = []):

molecule.createMolecule((folderHead + str(simulation + 1)),atoms,data)

#main code goes here#####################################################################################

#check if analysis folder already exists

if(os.path.exists("./analysis") == False):

#if not, create analysis folder and populate with simulation data

initAnalysis(args)