Chimie Théorique » QMX

#!/usr/bin/env python

# definition of STRUCTURES for qmx-setup

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

from qmxDEF import Definition

#-------------------------------------------------------------------------------

#--- STR DEFINITIONS -----------------------------------------------------------

#-------------------------------------------------------------------------------

class VASPStrDefinition(Definition):

    def __init__(self):

        self.name='VASP'

        self.keywords = {}

        self.keywords['import']='ase.io.vasp'

        self.keywords['class']='read_vasp'

        self.keywords['class.options']='POSCAR'

#-------------------------------------------------------------------------------

class TURBOMOLEStrDefintion(Definition):

    def __init__(self):

        self.name='TURBOMOLE'

        self.keywords = {}

        self.keywords['import']='ase.io.turbomole'

        self.keywords['class']='read_turbomole'

        self.keywords['class.options']='coord'

#-------------------------------------------------------------------------------

strDefinitions = [VASPStrDefinition(), TURBOMOLEStrDefintion()]

#!/usr/bin/env python

# definition of JOBS for qmx-setup

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

from qmxDEF import Definition

#-------------------------------------------------------------------------------

#--- JOB DEFINITIONS -----------------------------------------------------------

#-------------------------------------------------------------------------------

class QNJobDefintion(Definition):

    def __init__(self):

        self.name='QuasiNewton'

        self.keywords = {}

        self.keywords['import']='ase.optimize'

        self.keywords['class']= 'QuasiNewton'

        self.keywords['class.options']= 'trajectory="embed.traj"'

        self.keywords['method']='run'

        self.keywords['method.options']='fmax=0.01, steps=100'

#-------------------------------------------------------------------------------

jobDefinitions = [QNJobDefintion()]

#!/usr/bin/env python

# GRAPHICAL interface for setup of QMX calculations

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

import StringIO

def writeData(stream, definitions):

    stream.write("#!/usr/bin/env python\n")

    keys=['import']

    arrImports=[]

    for definition in definitions:

        strClass=definition.getValue('class')

        strImport=definition.getValue('import')

        if (strClass is not '' and strImport is not ''):

            s='from '+strImport+' import '+strClass+'\n'

            if not s in arrImports:

                stream.write(s)

                arrImports.append(s)

    stream.write("\n")

    for name in ['high-level', 'low-level', 'qmx']:

        for definition in definitions:

            if definition.system.lower() != name:

                continue

            strSystem=definition.system.lower().replace("-", "_")

            strClass=definition.getValue('class')

            strOptions=definition.getValue('class.options')

            if (strClass is not ''):

                stream.write(strSystem+'='+strClass+'('+strOptions+')\n')

    stream.write("\n")

    for name in ['system', 'cluster', 'embed']:

        for definition in definitions:

            if definition.system.lower() != name:

                continue

            strSystem=definition.system.lower()

            strClass=definition.getValue('class')

            strOptions=definition.getValue('class.options')

            if (strClass is not ''):

                stream.write(strSystem+'='+strClass+"('"+strOptions+"')\n")

            if name is 'embed':

                strMethod=definition.getValue('method')

                strOptions=definition.getValue('method.options')

                stream.write(strSystem+'.'+strMethod+'('+strOptions+')\n')

                strOptions=definition.getValue('calculator')

                stream.write(strSystem+'.set_calculator('+strOptions+')\n')

    stream.write("\n")

    for definition in definitions:

        if (definition.system.lower() == 'job'):

            strSystem=definition.system.lower()

            strClass=definition.getValue('class')

            strOptions=definition.getValue('class.options')

            if (strOptions is not ''):

                strOptions = ', ' + strOptions

            if (strClass is not ''):

                stream.write(strSystem+'='+strClass+'(embed'+strOptions+')\n')

            strSystem=definition.system.lower()

            strMethod=definition.getValue('method')

            strOptions=definition.getValue('method.options')

            stream.write(strSystem+'.'+strMethod+'('+strOptions+')\n')

#!/usr/bin/env python

# definition of EMBED for qmx-setup

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

from qmxDEF import Definition

#-------------------------------------------------------------------------------

#--- EMBED DEFINITIONS ---------------------------------------------------------

#-------------------------------------------------------------------------------

class EmbedDefinition(Definition):

    def __init__(self):

        self.name='Embed'

        self.system='Embed'

        self.keywords = {}

        self.keywords['import']='ase.embed'

        self.keywords['class']='Embed'

        self.keywords['class.options']='system, cluster, cell_cluster="Auto"'

        self.keywords['method']='embed'

        self.keywords['calculator']='qmx'

#-------------------------------------------------------------------------------

embedDefinitions = [EmbedDefinition()]

high-level.program : TURBOMOLE

high-level.options : opt

low-level.program : VASP

cluster.program : TURBOMOLE

cluster.options : clusterX

system.program : VASP

job.program : QuasiNewton 

#!/usr/bin/env python

import os, sys

from optparse import OptionParser

class Data:

    def __init__(self, name):

        self.__name__ = name

        self.str_option = ""

        self.str_import = None

        self.str_class  = None

        self.str_methods = []

        self.str_structure = None

    def __str__(self):

       return self.__name__

def getline(section, subsection, lines):

    nline = -1

    for iline in xrange(len(lines)):

        if lines[iline][0].strip() == subsection:

            if nline != -1:

                sys.stderr.write("section: <"+section+separator+subsection+"> has been definied more than once\n")

                sys.exit(1)

            nline = iline

    if nline == -1:

        return None

    return lines[nline][1].strip()

def analyzeAtoms(section, lines):

    data = Data(section)

    line = getline(section, "program", lines)

    if line is None:

        line=""

    if line.lower() == "turbomole":

        data.str_import = "from ase.io.turbomole import read_turbomole"

        data.str_class = "read_turbomole"

    elif line.lower() == "vasp":

        data.str_import = "from ase.io.vasp import read_vasp"

        data.str_class = "read_vasp"

    data.str_structure = getline(section, "structure", lines)

    return data

def analyzeCalculator(section, lines):

    data = Data(section)

    #read programs

    line = getline(section, "program", lines)

    if line.lower() == "turbomole":

        data.str_import = "from ase.calculators.turbomole import Turbomole"

        data.str_class = "Turbomole"

    elif line.lower() == "vasp":

        data.str_import = "from ase.calculators.vasp import Vasp"

        data.str_class = "Vasp"

    str = getline(section, "class", lines)

    if str is not None:

        data.str_class = str

    str = getline(section, "import", lines)

    if str is not None:

        data.str_import = str

    str = getline(section, "options", lines)

    if str is not None:

        data.str_option = str

    return data

def analyzeDynamics(section, lines):

    data = Data(section)

    line = getline(section, "method", lines)

    if line.lower() == "optimizer":

        data.str_import = "from ase.optimize import QuasiNewton"

        data.str_class = "QuasiNewton"

    return data

#--- setting default values ------------------------------------------------------------------------

#define separators

separator=":"

subseparator="."

lineseparator="\n"

#--- parse arguments -------------------------------------------------------------------------------

#parse arguments (python 2.6)

parser = OptionParser()

parser.add_option("-i", "--infile",  dest="inputFile",  help="specifies the input file", metavar="FILE", default="qmx.in")

parser.add_option("-o", "--outfile", dest="outputFile", help="specifies the output file", metavar="FILE")

parser.add_option("-f", action="store_true", dest="overwrite")

(options, args) = parser.parse_args()

file=open(options.inputFile, "r")

lines = file.readlines()

file.close()

#--- split intput file -----------------------------------------------------------------------------

#--- remove comments -------------------------------------------------------------------------------

for iline in xrange(len(lines)):

    lines[iline] = lines[iline].split("#")[0]    

#--- collect data in class -------------------------------------------------------------------------

data_collection=[]

#--- settings for QMX class ------------------------------------------------------------------------

data = Data("qmx")

data.str_class = "Qmx"

data.str_import = "from ase.calculators.qmx import Qmx"

data.str_option = "highLevel, lowLevel"

data_collection.append(data)

#--- settings for Embed class ----------------------------------------------------------------------

data = Data("embed")

data.str_class = "Embed"

data.str_import = "from ase.embed import Embed"

data.str_option = "system, cluster"

data.str_methods = ["embed()", "set_calculator(qmx)"]

data_collection.append(data)

#--- analyze the input file ------------------------------------------------------------------------

for section in "high-level", "low-level", "cluster", "system", "dynamics":

    #search lines for section

    lines_section=[]

    for line in lines:

        line = line.split(separator)

        if line[0].find(section) >= 0:

            line[0] = line[0].replace(section+subseparator, "")

            lines_section.append(line)

    #calculators

    if section == "high-level" or section == "low-level":

        data_collection.append(analyzeCalculator(section, lines_section))

    #systems

    if section == "cluster" or section == "system":

        data_collection.append(analyzeAtoms(section, lines_section))

    #dynamics

    if section == "dynamics":

        data_collection.append(analyzeDynamics(section, lines_section))

#--- write output file -----------------------------------------------------------------------------

if options.outputFile is not None and os.path.exists(options.outputFile) and not options.overwrite:

    sys.stderr.write(lineseparator+"the output file <"+options.outputFile+"> already exists"+lineseparator)

    sys.exit(1)

output = None

if options.outputFile is None:

    output=sys.stdout

else:

    output=open(options.outputFile, "w")

#--- write header ----------------------------------------------------------------------------------

output.write("#!/usr/bin/env python\n")

#--- write import lines ----------------------------------------------------------------------------

xlines=[]

for data in data_collection:

    value = data.str_import

    if value is None or value in xlines:

        continue

    xlines.append(value)

    output.write(value+lineseparator)

output.write(lineseparator)

#--- define the methods ----------------------------------------------------------------------------

for system in 'high', 'low':

    for data in data_collection:

        if data.__name__ == system+"-level":

            output.write(system+"Level = "+data.str_class+"("+data.str_option+")"+lineseparator)

output.write(lineseparator)

#--- qmx class (substraction scheme ----------------------------------------------------------------

for data in data_collection:

    if data.__name__ == "qmx":

        output.write("qmx = "+data.str_class+"("+data.str_option+")"+lineseparator)

output.write(lineseparator)

#--- read all the systems --------------------------------------------------------------------------

for system in "cluster", "system":

    for data in data_collection:

        if data.__name__ == system:

            if data.str_structure is None:

                continue

            output.write(system+" = "+data.str_class+"(\""+data.str_structure+"\")"+lineseparator)

output.write(lineseparator)

#--- embeding class --------------------------------------------------------------------------------

for data in data_collection:

    if data.__name__ == "embed":

        output.write("embed = "+data.str_class+"("+data.str_option+")"+lineseparator)

        for method in data.str_methods:

            output.write("embed."+method+lineseparator)

output.write(lineseparator)

#--- dynamics class --------------------------------------------------------------------------------

for data in data_collection:

    if data.__name__ == "dynamics":

        output.write("dyn="+data.str_class+"(embed)"+lineseparator)

        output.write("dyn.run("+data.str_option+")"+lineseparator)

output.close()

sys.exit(0)

#!/usr/bin/env python

# GRAPHICAL interface for setup of QMX calculations

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

#-------------------------------------------------------------------------------

#--- GENERAL -------------------------------------------------------------------

#-------------------------------------------------------------------------------

class Definition(object):

    def getValue(self, key):

        if self.keywords.__contains__(key):

            return self.keywords[key]

        return ''

#!/usr/bin/env python

from ase.embed import Embed

from ase.io.vasp import read_vasp

from ase.calculators.qmx import Qmx

from ase.calculators.vasp import Vasp

from ase.optimize import QuasiNewton

high_level=Vasp(write_input=False)

low_level=Vasp(write_input=False)

qmx=Qmx(high_level, low_level)

system=read_vasp('POSCAR')

cluster=read_vasp('POSCAR')

embed=Embed(system, cluster, cell_cluster="Auto")

embed.embed()

embed.set_calculator(qmx)

job=QuasiNewton(embed, trajectory="embed.traj")

job.run(fmax=0.01, steps=100)

#!/usr/bin/env python

# GRAPHICAL interface for setup of QMX calculations

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

#---------------------------------------------------------------------------------------------------

from Tkinter import *

from copy import deepcopy

import StringIO, os

#---------------------------------------------------------------------------------------------------

from qmxEMBED import embedDefinitions

from qmxJOB import jobDefinitions

from qmxSTR import strDefinitions

from qmxCALC import calcDefinitions, QmxCalcDefinition

from qmxWRITE import writeData

#---------------------------------------------------------------------------------------------------

#---------------------------------------------------------------------------------------------------

#---------------------------------------------------------------------------------------------------

class MyLabelFrame(LabelFrame):

    def __init__(self, mainWnd, master, title, def_list, extras):

        LabelFrame.__init__(self, master, text=title)

        self.mainWnd = mainWnd

        self.definitions=[]

        self.title = title

        for definition in def_list:

            definition_new = deepcopy(definition)

            definition_new.system = title

            self.definitions.append(definition_new)

        fields=['import', 'class', 'class.options']

        if extras is not None:

            for key in extras:

                fields.append(key)

        self.entries=[]

        for key in fields:

            text=StringVar()

            text.set('')

            self.entries.append((key, text, Entry(self, textvariable=text, width=15)))

    def grid(self, **arguments):

        LabelFrame.grid(self, arguments, sticky=(N+W+E))

        self.listbox.selection_set(first=0)

        self.select(None)

    def doLayout(self):

        irow=0

        for (key, text, textfield) in self.entries:

            Label(self, text=key, width=15, anchor=W).grid(row=irow)

            textfield.grid(row=irow, column=1)

            textfield.bind("<KeyRelease>", self.update)

            irow+=1

        scrollbar=Scrollbar(self, orient=VERTICAL)

        self.listbox=Listbox(self, yscrollcommand=scrollbar.set, height=0, width=15, selectmode=SINGLE)

        self.listbox.grid(row=0, column=2, rowspan=irow, columnspan=2, sticky=NS)

        self.listbox.bind('<ButtonRelease-1>', self.select)

        scrollbar.config(command=self.listbox.yview)

        scrollbar.grid(row=0, column=4, rowspan=irow, sticky=NS)

        for item in self.definitions:

            self.listbox.insert(END, item.name)

    def select(self, event):

        selection=self.listbox.curselection()

        if len(selection) == 1:

            self.curr_definition=deepcopy(self.definitions[int(selection[0])])

            for (key, text, textfield) in self.entries:

                text.set(self.curr_definition.getValue(key))

        self.mainWnd.preview()

    def getSelection(self):

        return self.curr_definition

    def update(self, event):

        for (key, text, textfield) in self.entries:

            self.curr_definition.keywords[key]=text.get()

        self.mainWnd.preview()

#---------------------------------------------------------------------------------------------------

class MainWindow(Frame):

    frames=[]

    text=None

    def __init__(self, master):

        Frame.__init__(self, master)

        #--- Structures ---

        bigFrame = LabelFrame(self, text='Structures')

        irow=0; icol=0

        def_list=embedDefinitions

        extras=['method', 'method.options', 'calculator']

        frame=MyLabelFrame(self, bigFrame, 'Embed', def_list, extras)

        frame.doLayout()

        frame.grid(row=irow, column=icol)

        self.frames.append(frame)

        icol+=1;

        for label in ['System', 'Cluster']:

            def_list=strDefinitions

            frame=MyLabelFrame(self, bigFrame, label, def_list, None)

            frame.doLayout()

            frame.grid(row=irow, column=icol)

            self.frames.append(frame)

            icol+=1

        bigFrame.grid(row=0, columnspan=3)

        #--- Methods ---

        bigFrame = LabelFrame(self, text='Methods')

        irow=0; icol=0

        def_list=[QmxCalcDefinition()]

        frame=MyLabelFrame(self, bigFrame, 'Qmx', def_list, None)

        frame.doLayout()

        frame.grid(row=irow, column=icol)

        self.frames.append(frame)

        icol+=1

        for label in ['High-Level', 'Low-Level']:

            def_list=calcDefinitions

            frame=MyLabelFrame(self, bigFrame, label, def_list, None)

            frame.doLayout()

            frame.grid(row=irow, column=icol)

            self.frames.append(frame)

            icol+=1

        bigFrame.grid(row=1, columnspan=3)

        #--- General ---

        bigFrame = LabelFrame(self, text='General')

        extras=['method', 'method.options']

        frame=MyLabelFrame(self, bigFrame, 'Job', jobDefinitions, extras)

        frame.doLayout()

        frame.grid()

        self.frames.append(frame)

        bigFrame.grid(row=2, sticky=NW)

        frame=LabelFrame(self, text="PREVIEW")

        scrollbar=Scrollbar(frame, orient=VERTICAL)

        scrollbar.set(0.0, 1.0)

        self.text=Text(frame, yscrollcommand=scrollbar.set, width=60, heigh=10, state=DISABLED)

        self.text.grid(sticky=(N+W+S+E))

        scrollbar.config(command=self.text.yview)

        scrollbar.grid(row=0, column=1, sticky=NS)        

        frame.grid(row=2, column=1)

        frame = Frame(self)

        image = PhotoImage(file="exit.gif")

        buttonExit=Button(frame, image=image, command=self.quit)

        buttonExit.image = image

        buttonExit.grid(row=1, column = 1, rowspan=2, sticky= W+E+N+S)

        buttonSave=Button(frame, text='save settings', state=DISABLED)

        buttonSave.grid(row=1, column = 2, sticky=(EW))

        buttonPrint=Button(frame, text='Write qmx.py input file', command=self.writeButton)

        buttonPrint.grid(row=2, column = 2, sticky=EW)

        frame.grid(row=2, column=2, sticky=SE)

        #--- MainWindow ---

        self.grid(sticky=(W+N+S+E))

        self.preview()

    def quit(self):

        quit()

    def writeButton(self):

        file = open("qmx.py","w")

        definitions=[]

        for frame in self.frames:

            definition = frame.getSelection()

            if definition is not None:

                definitions.append(definition)

        writeData(file, definitions)

        file.close()

        os.system("chmod u+x qmx.py")

    def preview(self):

        stream = StringIO.StringIO()

        definitions=[]

        for frame in self.frames:

            definition = frame.getSelection()

            if definition is not None:

                definitions.append(definition)

        writeData(stream, definitions)

        s = stream.getvalue()

        if self.text is not None:

            pos, end = self.text.yview()

            self.text.config(state=NORMAL)

            self.text.delete(1.0, END)

            self.text.insert(END, s)

            self.text.config(state=DISABLED)

            self.text.yview(MOVETO, pos)

#---------------------------------------------------------------------------------------------------

mainWnd=MainWindow(Tk())

mainWnd.mainloop()

#!/usr/bin/env python

# definition of CALCULATORS for qmx-setup

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

from qmxDEF import Definition

#-------------------------------------------------------------------------------

#--- PRG DEFINITIONS -----------------------------------------------------------

#-------------------------------------------------------------------------------

class VASPCalcDefinition(Definition):

    def __init__(self):

        self.name='VASP'

        self.keywords = {}

        self.keywords['import']='ase.calculators.vasp'

        self.keywords['class']='Vasp'

        self.keywords['class.options']='write_input=False'

#-------------------------------------------------------------------------------

class TURBOMOLECalcDefinition(Definition):

    def __init__(self):

        self.name='TURBOMOLE'

        self.keywords = {}

        self.keywords['import']='ase.calculators.turbomole'

        self.keywords['class']='Turbomole'

#-------------------------------------------------------------------------------

class MOPACCalcDefinition(Definition):

    def __init__(self):

        self.name='MOPAC'

        self.keywords = {}

        self.keywords['import']='ase.calculators.mopac'

        self.keywords['class']='Mopac'

        self.keywords['class.options']='functional="PM6"'

#-------------------------------------------------------------------------------

class QmxCalcDefinition(Definition):

    def __init__(self):

        self.name='QMX'

        self.system='Qmx'

        self.keywords = {}

        self.keywords['import']='ase.calculators.qmx'

        self.keywords['class']='Qmx'

        self.keywords['class.options']='high_level, low_level'

#-------------------------------------------------------------------------------

calcDefinitions = [VASPCalcDefinition(), TURBOMOLECalcDefinition(), MOPACCalcDefinition()]

#!/usr/bin/env python

# command line interface for setup of QMX calculations

#

# Torsten Kerber, ENS LYON: 2011, 07, 11

#

# This work is supported by Award No. UK-C0017, made by King Abdullah

# University of Science and Technology (KAUST)

#---------------------------------------------------------------------------------------------------

import os, sys

from copy import deepcopy

from optparse import OptionParser

#---------------------------------------------------------------------------------------------------

from qmxEMBED import embedDefinitions

from qmxJOB  import jobDefinitions

from qmxSTR  import strDefinitions

from qmxCALC import calcDefinitions, QmxCalcDefinition

from qmxWRITE import writeData

#---------------------------------------------------------------------------------------------------

#---------------------------------------------------------------------------------------------------

#---------------------------------------------------------------------------------------------------

def getline(section, subsection, lines):

    nline = -1

    for iline in xrange(len(lines)):

        if lines[iline][0].strip() == subsection:

            if nline != -1:

                sys.stderr.write("section: <"+section+separator+subsection+"> has been definied more than once\n")

                sys.exit(1)

            nline = iline

    if nline == -1:

        return None

    return lines[nline][1].strip()

#---------------------------------------------------------------------------------------------------

def analyzeSection(definitions, section, lines):

    line = getline(section, "program", lines)

    if line is None:

        print "section <" + section + "> does not contain program"

        sys.exit(1)

    myDefinition = None

    for definition in definitions:

        if definition.name == line:

            myDefinition = deepcopy(definition)

            break

    if myDefinition is None:

        print "the program <" + line + "> is not defined for the section <" + section + ">"

        sys.exit(1)

    myDefinition.system = section

    subsections = []

    for line in lines:

        subsections.append(line[0].strip().lower())

    for subsection in subsections:

        line = getline(section, subsection, lines)

        if line is None:

            print "input error in <"+section+"."+subsection+">"

            sys.exit(1)

        if subsection == "program":

            continue

        if subsection == "options":

            subsection = 'class.options'

        myDefinition.keywords[subsection] = line    

        print subsection, myDefinition.keywords[subsection]

    return myDefinition

#---------------------------------------------------------------------------------------------------

#--- setting default values ------------------------------------------------------------------------

#---------------------------------------------------------------------------------------------------

#define separators

separator=":"

subseparator="."

lineseparator="\n"

#--- parse arguments -------------------------------------------------------------------------------

#parse arguments (python 2.6)

parser = OptionParser()

parser.add_option("-i", "--infile",  dest="inputFile",  help="specifies the input file", metavar="FILE", default="qmx.in")

parser.add_option("-o", "--outfile", dest="outputFile", help="specifies the output file", metavar="FILE")

parser.add_option("-f", action="store_true", dest="overwrite")

(options, args) = parser.parse_args()

#--- check wether output file exists ---------------------------------------------------------------

if options.outputFile is not None and os.path.exists(options.outputFile) and not options.overwrite:

    sys.stderr.write(lineseparator+"the output file <"+options.outputFile+"> already exists"+lineseparator)

    sys.exit(1)

#--- read intput file ------------------------------------------------------------------------------

file=open(options.inputFile, "r")

lines = file.readlines()

file.close()

#--- remove comments -------------------------------------------------------------------------------

for iline in xrange(len(lines)):

    lines[iline] = lines[iline].split("#")[0]    

#--- collect data in class -------------------------------------------------------------------------

definitions=[]

definitions.append(QmxCalcDefinition())

#--- analyze the input file ------------------------------------------------------------------------

for section in "high-level", "low-level", "cluster", "system", "job":

    #search lines for section

    lines_section=[]

    for line in lines:

        line = line.split(separator)

        if line[0].find(section) >= 0:

            line[0] = line[0].replace(section+subseparator, "")

            lines_section.append(line)

    #calculators

    if section == "high-level" or section == "low-level":

        definitions.append(analyzeSection(calcDefinitions, section, lines_section))

    #structures (atoms)

    if section == "cluster" or section == "system":

        definitions.append(analyzeSection(strDefinitions, section, lines_section))

    #job

    if section == "job":

        definitions.append(analyzeSection(jobDefinitions, section, lines_section))

    #embed

    if section == "embed":

        definitions.append(analyzeSection(embedDefinitions, section, lines_section))

output = None

if options.outputFile is None:

    output=sys.stdout

else:

    output=open(options.outputFile, "w")

writeData(output, definitions)

output.close()

#

##--- write header ----------------------------------------------------------------------------------

#output.write("#!/usr/bin/env python\n")

#

##--- write import lines ----------------------------------------------------------------------------

#xlines=[]

#for data in data_collection:

#    value = data.str_import

#    if value is None or value in xlines:

#        continue

#    xlines.append(value)

#    output.write(value+lineseparator)

#output.write(lineseparator)

#

##--- define the methods ----------------------------------------------------------------------------

#for system in 'high', 'low':

#    for data in data_collection:

#        if data.__name__ == system+"-level":

#            output.write(system+"Level = "+data.str_class+"("+data.str_option+")"+lineseparator)

#output.write(lineseparator)

#

##--- qmx class (substraction scheme ----------------------------------------------------------------

#for data in data_collection:

#    if data.__name__ == "qmx":

#        output.write("qmx = "+data.str_class+"("+data.str_option+")"+lineseparator)

#output.write(lineseparator)

#

##--- read all the systems --------------------------------------------------------------------------

#for system in "cluster", "system":

#    for data in data_collection:

#        if data.__name__ == system:

#            if data.str_structure is None:

#                continue

#            output.write(system+" = "+data.str_class+"(\""+data.str_structure+"\")"+lineseparator)

#output.write(lineseparator)