#
#
#

"""Functions for running a simple MD simulation on a structure"""
__author__ = "Magdalena A. Jonikas"
__version__ = "1.0"

import os, sys
import math
import getopt
import glob
import time
import sha
import socket
import random

import LinearAlgebra

import nast.deltaTime as deltaTime
import nast.gomodelRNAmaj2 as gomodel
import nast.md.gosim as gosim
import nast.version
import NASTbase2 as base
import nast.geom as geom

def parseCommandLine():
    opts, args_proper = getopt.getopt(sys.argv[1:], 'hp:o:r:')
    pValue = ''
    oValue = 'test'
    rValue = 100
    for option, parameter in opts:
        if option=='-h': usageError()
        if option=='-p': pValue = parameter #params file to use
        if option=='-o': oValue = parameter #output name
        if option=='-r': rValue = int(parameter)
    return (args_proper, pValue, oValue, rValue)

def usageError():
    print 'usage: %s [-p paramModule] [-o outputName] startingStructure' % os.path.basename(sys.argv[0])
    sys.exit(1)

if __name__=='__main__':
    deltaTime = deltaTime.dTime()
    startTime = time.time()

    (args_proper, paramModule, outputFilename, runs) = parseCommandLine()


    if paramModule:
        params = __import__(paramModule)
    else:
        import params

    try:
        startStructure = args_proper[0]
    except IndexError:
        usageError()

    primarySequence = params.primarySequence
    predictedSecondary = params.predictedSecondary
    predictedTertiary = params.predictedTertiary
    knownStructure = params.knownStructure
    crystalStructure = params.crystalStructure

    print ' '

    print 'buildNum = %d' % nast.version.buildNum
    print "Center Atom: %s" % params.centerAtomName
    print "temp0: %.1f" % (params.temp0)
    print "numStepsTemp: %d" % params.numStepsTemp
    print '\nBuilding Go-Model'


    sim = base.Structure(params)
    sim.pdbInitFilename = startStructure
    sim.processPrimary(primarySequence)
    sim.outputFilename = outputFilename
    sim.startStructure = open(startStructure).readlines()
    if knownStructure:
        sim.processKnown(knownStructure, crystalStructure)
    else:
        sim.ksList = []
#    if predictedSecondary:
#        sim.processSecondary(predictedSecondary)
#    else:
#        sim.psList = []
    if predictedTertiary:
        sim.processTertiary(predictedTertiary)
    else:
        sim.ptList = []
    sim.setupStart()
#    sim.equilibrate()
    sim.setgModel()
    if sim.ksList:
        sim.setKS()
#    if sim.psList:
#        sim.setPS()
    if sim.ptList:
        sim.setPT()
    sim.setgSim()
    for iRun in range(runs):
        sim.rungSim()
        #if sim.ranWithNoErrors and iRun%100==0:
        if sim.ranWithNoErrors:
            sim.gSim.writePDBFile('%s-trace.pdb' % outputFilename, append=True)
    if sim.ranWithNoErrors:
        sim.gSim.writePDBFile('%s.pdb' % outputFilename, append=False)
        sim.gModel.makePSF('%s.psf' % outputFilename)

    endTime = time.time()
    print endTime-startTime