From b93f2bffc47a3a2b234bbcbdd8afe5b73e10f35d Mon Sep 17 00:00:00 2001
From: Adam Fekete <fekad@fekad-work.local>
Date: Mon, 5 Sep 2016 02:23:20 +0100
Subject: [PATCH] new lammps classes
---
parser/parser-lammps/LAMMPS/AngleStyle.py | 37 +
parser/parser-lammps/LAMMPS/Atom.py | 320 ++++++++
parser/parser-lammps/LAMMPS/AtomStyle.py | 199 +++++
parser/parser-lammps/LAMMPS/BaseClasses.py | 333 ++++++++
parser/parser-lammps/LAMMPS/BondStyle.py | 42 +
parser/parser-lammps/LAMMPS/DihedralStyle.py | 42 +
parser/parser-lammps/LAMMPS/Domain.py | 19 +
parser/parser-lammps/LAMMPS/GroupStyle.py | 66 ++
parser/parser-lammps/LAMMPS/ImproperStyle.py | 27 +
parser/parser-lammps/LAMMPS/Input.py | 567 +++++++++++++
parser/parser-lammps/LAMMPS/KSpaceStyle.py | 92 +++
parser/parser-lammps/LAMMPS/Lattice.py | 55 ++
parser/parser-lammps/LAMMPS/NeighborStyle.py | 24 +
parser/parser-lammps/LAMMPS/PairStyle.py | 562 +++++++++++++
parser/parser-lammps/LAMMPS/Region.py | 61 ++
parser/parser-lammps/LAMMPS/Units.py | 755 ++++++++++++++++++
parser/parser-lammps/LAMMPS/__init__.py | 2 +
parser/parser-lammps/LAMMPS/data_file.py | 122 +++
parser/parser-lammps/LAMMPS/lammps.py | 40 +
parser/parser-lammps/LAMMPS/read_data.py | 94 +++
.../parser-lammps/LAMMPS/test_array_append.py | 78 ++
parser/parser-lammps/LAMMPS/test_atoms.py | 32 +
parser/parser-lammps/LAMMPS/variable.py | 132 +++
23 files changed, 3701 insertions(+)
create mode 100644 parser/parser-lammps/LAMMPS/AngleStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/Atom.py
create mode 100644 parser/parser-lammps/LAMMPS/AtomStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/BaseClasses.py
create mode 100644 parser/parser-lammps/LAMMPS/BondStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/DihedralStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/Domain.py
create mode 100644 parser/parser-lammps/LAMMPS/GroupStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/ImproperStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/Input.py
create mode 100644 parser/parser-lammps/LAMMPS/KSpaceStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/Lattice.py
create mode 100644 parser/parser-lammps/LAMMPS/NeighborStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/PairStyle.py
create mode 100644 parser/parser-lammps/LAMMPS/Region.py
create mode 100644 parser/parser-lammps/LAMMPS/Units.py
create mode 100644 parser/parser-lammps/LAMMPS/__init__.py
create mode 100644 parser/parser-lammps/LAMMPS/data_file.py
create mode 100644 parser/parser-lammps/LAMMPS/lammps.py
create mode 100644 parser/parser-lammps/LAMMPS/read_data.py
create mode 100644 parser/parser-lammps/LAMMPS/test_array_append.py
create mode 100644 parser/parser-lammps/LAMMPS/test_atoms.py
create mode 100644 parser/parser-lammps/LAMMPS/variable.py
diff --git a/parser/parser-lammps/LAMMPS/AngleStyle.py b/parser/parser-lammps/LAMMPS/AngleStyle.py
new file mode 100644
index 0000000..639cec0
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/AngleStyle.py
@@ -0,0 +1,37 @@
+from LAMMPS.BaseClasses import AngleStyle
+
+
+# class none(AngleStyle):
+# name = 'none'
+# pass
+
+
+class Hybrid(AngleStyle):
+ name = 'hybrid'
+ pass
+
+
+class Charmm(AngleStyle):
+ name = 'charmm'
+ pass
+
+
+class Class2(AngleStyle):
+ name = 'class2'
+ pass
+
+
+class Cosine(AngleStyle):
+ name = 'cosine'
+ pass
+
+
+class CosineSquared(AngleStyle):
+ name = 'cosine/squared'
+ pass
+
+
+class Harmonic(AngleStyle):
+ name = 'harmonic'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/Atom.py b/parser/parser-lammps/LAMMPS/Atom.py
new file mode 100644
index 0000000..714e0bd
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Atom.py
@@ -0,0 +1,320 @@
+from abc import ABCMeta, abstractproperty
+from collections import OrderedDict
+import numpy as np
+
+from LAMMPS.BaseClasses import AtomStyle
+
+from enum import Enum, unique
+import unittest
+
+
+def read_atoms(atom_style, ):
+ pass
+
+
+class Angle(AtomStyle):
+ name = 'angle'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'x', 'y', 'z']
+
+class Atomic(AtomStyle):
+ name = 'atomic'
+ keys = ['atom_id', 'atom_type', 'x', 'y', 'z']
+
+ def __init__(self, n_atoms = 0):
+ self.n_atoms = n_atoms
+ self.data = dict()
+
+
+
+ def add_atom(self, atom_type, x, y, z):
+ pass
+
+
+ def __str__(self):
+ row_format ='{:>15} {}'
+
+ ret_str = '\n'.join([
+ "Atoms",
+ row_format.format('atom_style:', self.name),
+ row_format.format('# of atoms:', self.n_atoms)
+ ])
+ return ret_str
+
+class Body(AtomStyle):
+ name = 'body'
+ keys = ['atom_id', 'atom_type', 'bodyflag', 'mass', 'x', 'y', 'z']
+
+class Bond(AtomStyle):
+ name = 'bond'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'x', 'y', 'z']
+
+class Charge(AtomStyle):
+ name = 'charge'
+ keys = ['atom_id', 'atom_type', 'q', 'x', 'y', 'z']
+
+class Dipole(AtomStyle):
+ name = 'dipole'
+ keys = ['atom_id', 'atom_type', 'q', 'x', 'y', 'z', 'mux', 'muy', 'muz']
+
+class Dpd(AtomStyle):
+ name = 'dpd'
+ keys = ['atom_id', 'atom_type', 'theta', 'x', 'y', 'z']
+
+class Electron(AtomStyle):
+ name = 'electron'
+ keys = ['atom_id', 'atom_type', 'q', 'spin', 'eradius', 'x', 'y', 'z']
+
+class Ellipsoid(AtomStyle):
+ name = 'ellipsoid'
+ keys = ['atom_id', 'atom_type', 'ellipsoidflag', 'density', 'x', 'y', 'z']
+
+class Full(AtomStyle):
+ name = 'full'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'q', 'x', 'y', 'z']
+
+class Line(AtomStyle):
+ name = 'line'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'lineflag', 'density', 'x', 'y', 'z']
+
+class Meso(AtomStyle):
+ name = 'meso'
+ keys = ['atom_id', 'atom_type', 'rho', 'e', 'cv', 'x', 'y', 'z']
+
+class Molecular(AtomStyle):
+ name = 'molecular'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'x', 'y', 'z']
+
+class Peri(AtomStyle):
+ name = 'peri'
+ keys = ['atom_id', 'atom_type', 'volume', 'density', 'x', 'y', 'z']
+
+class Smd(AtomStyle):
+ name = 'smd'
+ keys = ['atom_id', 'atom_type', 'molecule', 'volume', 'mass', 'kernel-radius', 'contact-radius', 'x', 'y', 'z']
+
+class Sphere(AtomStyle):
+ name = 'sphere'
+ keys = ['atom_id', 'atom_type', 'diameter', 'density', 'x', 'y', 'z']
+
+class Template(AtomStyle):
+ name = 'template'
+ keys = ['atom_id', 'molecule_id', 'template-index', 'template-atom', 'atom_type', 'x', 'y', 'z']
+
+class Tri(AtomStyle):
+ name = 'tri'
+ keys = ['atom_id', 'molecule_id', 'atom_type', 'triangleflag', 'density', 'x', 'y', 'z']
+
+class Wavepacket(AtomStyle):
+ name = 'wavepacket'
+ keys = ['atom_id', 'atom_type', 'charge', 'spin', 'eradius', 'etag', 'cs_re', 'cs_im', 'x', 'y', 'z']
+
+class Hybrid(AtomStyle):
+ name = 'hybrid'
+ keys = ['atom_id', 'atom_type', 'x', 'y', 'z']
+
+
+
+
+
+
+
+def atom_style(style, *args):
+ """Wrapper for atom_style command"""
+
+ if style == 'body':
+ return body(*args)
+
+ elif style == 'template':
+ return template(*args)
+
+ elif style == 'hybrid':
+
+ list = hybrid()
+ args_iter = args.__iter__()
+
+ while True:
+ try:
+ style = args_iter.__next__()
+
+ if style == 'body':
+ bstyle = args_iter.__next__()
+ nmin = args_iter.__next__()
+ nmax = args_iter.__next__()
+ list.append(body(bstyle, nmin, nmax))
+
+ elif style == 'template':
+ templat_id = args_iter.__next__()
+ list.append(template(templat_id))
+
+ else:
+ list.append(eval(style)())
+
+ except StopIteration:
+ break
+ return list
+ else:
+ return eval(style)()
+
+
+ # # return eval(style)(*args)
+ # cls = globals()[style]
+ # return cls(*args)
+
+ # # create an itarator
+ # args_iter = args.__iter__()
+ # while True:
+ # try:
+ # style = args_iter.__next__()
+ #
+ #
+ # except StopIteration:
+ # break
+ #
+
+
+class _atom_style(metaclass=ABCMeta):
+ """Abstract class for atom_style"""
+ pass
+
+class _body_style(metaclass=ABCMeta): pass
+class angle(_atom_style): pass
+class atomic(_atom_style): pass
+
+class body(_atom_style):
+ def __init__(self, bstyle, Nmin, Nmax):
+ self.bstyle = bstyle
+ self.nmin = Nmin
+ self.nmax = Nmax
+
+class bond(_atom_style): pass
+class charge(_atom_style): pass
+class dipole(_atom_style): pass
+class dpd(_atom_style): pass
+class electron(_atom_style): pass
+class ellipsoid(_atom_style): pass
+class full(_atom_style): pass
+class line(_atom_style): pass
+class meso(_atom_style): pass
+class molecular(_atom_style): pass
+class peri(_atom_style): pass
+class smd(_atom_style): pass
+class sphere(_atom_style): pass
+class tri(_atom_style): pass
+# class wavepacket(_atom_style): pass
+# not defined yet
+
+class template(_atom_style):
+ def __init__(self, id):
+ self.id = id
+
+
+class hybrid(_atom_style, list):
+ pass
+ # def __init__(self, *args):
+ #
+ # # self.list = []
+ #
+ # # create an itarator
+ # args_iter = args.__iter__()
+ # while True:
+ # try:
+ # style = args_iter.__next__()
+ #
+ # if style == 'body':
+ # bstyle = args_iter.__next__()
+ # nmin = args_iter.__next__()
+ # nmax = args_iter.__next__()
+ # self.list.append(body(bstyle, nmin, nmax))
+ # elif style == 'template':
+ # templat_id = args_iter.__next__()
+ # self.list.append(template(templat_id))
+ # else:
+ # self.list.append(eval(style))
+ #
+ # except StopIteration:
+ # break
+
+
+
+
+# class _Atoms(metaclass=ABCMeta):
+# """
+#
+# """
+# pass
+#
+# @unique
+# class _atom_styles(Enum):
+# angle = 1
+# atomic = 2
+# body = 3
+# bond = 4
+# charge = 5
+# dipole = 6
+# dpd = 7
+# electron = 8
+# ellipsoid = 9
+# full = 10
+# line = 11
+# meso = 12
+# molecular = 13
+# peri = 14
+# smd = 15
+# sphere = 16
+# tri = 17
+# template = 18
+# wavepacket = 19
+# hybrid = 20
+#
+#
+# class atom_style():
+# # STYLES = ['angle', 'atomic', 'body', 'bond', 'charge', 'dipole', 'dpd', 'electron', 'ellipsoid', 'full', 'line', 'meso', 'molecular', 'peri', 'smd', 'sphere', 'template', 'tri', 'wavepacket']
+#
+# def __init__(self, style, *args):
+# if style not in _atom_styles.__members__:
+# raise NameError('Wrong style type!')
+#
+# self.style = _atom_styles[style]
+#
+# if style is 'body':
+# self.bstyle = args[0]
+# self.bstyle_args = args[1:]
+#
+# self.args = args
+# # for arg in args:
+# # print(arg)
+#
+#
+#
+#
+# class s(_Atoms):
+# def __init__(self):
+# self.style = ''
+
+
+
+
+if __name__ == '__main__':
+
+ a = np.array([1,2,3])
+ print(a)
+
+
+ a = Atomic(10)
+ print(a)
+
+
+ pass
+
+ # atom_style('atomic')
+ # atom_style('bond')
+ # atom_style('full')
+ # a = atom_style('body', 'nparticle', 2, 10)
+ # print(a.bstyle)
+ # print(a.nmin)
+ # print(a.nmax)
+ #
+ # atom_style('hybrid', 'charge', 'bond')
+ # a = atom_style('hybrid', 'charge', 'body', 'nparticle', 2, 5)
+ # print(a.list)
+ # atom_style('template', 'myMols')
diff --git a/parser/parser-lammps/LAMMPS/AtomStyle.py b/parser/parser-lammps/LAMMPS/AtomStyle.py
new file mode 100644
index 0000000..03769f6
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/AtomStyle.py
@@ -0,0 +1,199 @@
+from LAMMPS.BaseClasses import AtomStyle
+import warnings
+
+ #
+ # if style == 'body':
+ # return body(*args)
+ #
+ # elif style == 'template':
+ # return template(*args)
+ #
+ # elif style == 'hybrid':
+ #
+ # list = hybrid()
+ # args_iter = args.__iter__()
+ #
+ # while True:
+ # try:
+ # style = args_iter.__next__()
+ #
+ # if style == 'body':
+ # bstyle = args_iter.__next__()
+ # nmin = args_iter.__next__()
+ # nmax = args_iter.__next__()
+ # list.append(body(bstyle, nmin, nmax))
+ #
+ # elif style == 'template':
+ # templat_id = args_iter.__next__()
+ # list.append(template(templat_id))
+ #
+ # else:
+ # list.append(eval(style)())
+ #
+ # except StopIteration:
+ # break
+ # return list
+ # else:
+ # return eval(style)()
+
+
+
+class Base(AtomStyle):
+ pass
+
+
+class Angle(AtomStyle):
+ name = 'angle'
+ pass
+
+class Atomic(AtomStyle):
+ name = 'atomic'
+
+class Angle(AtomStyle):
+ name = 'angle'
+ pass
+class Atomic(AtomStyle):
+ name = 'atomic'
+ pass
+
+class Body(AtomStyle):
+ name = 'body'
+
+ def __init__(self, bstyle, Nmin, Nmax):
+ self.bstyle = bstyle
+ self.nmin = Nmin
+ self.nmax = Nmax
+
+class Bond(AtomStyle):
+ name = 'bond'
+ pass
+class Charge(AtomStyle):
+ name = 'charge'
+ pass
+class Dipole(AtomStyle):
+ name = 'dipole'
+ pass
+class Dpd(AtomStyle):
+ name = 'dpd'
+ pass
+class Electron(AtomStyle):
+ name = 'electron'
+ pass
+class Ellipsoid(AtomStyle):
+ name = 'ellipsoid'
+ pass
+class Full(AtomStyle):
+ name = 'full'
+ pass
+class Line(AtomStyle):
+ name = 'line'
+ pass
+class Meso(AtomStyle):
+ name = 'meso'
+ pass
+class Molecular(AtomStyle):
+ name = 'molecular'
+ pass
+class Peri(AtomStyle):
+ name = 'peri'
+ pass
+class Smd(AtomStyle):
+ name = 'smd'
+ pass
+class Sphere(AtomStyle):
+ name = 'sphere'
+ pass
+class Tri(AtomStyle):
+ name = 'tri'
+ pass
+
+class Wavepacket(AtomStyle):
+ pass
+
+class Template(AtomStyle):
+ name = 'template'
+
+ def __init__(self, id):
+ self.id = id
+
+
+class Hybrid(AtomStyle):
+ name = 'hybrid'
+
+ def __init__(self, *args):
+ pass
+ # super().__init__()
+ # self.list = []
+ #
+ # # create an itarator
+ # args_iter = args.__iter__()
+ # while True:
+ # try:
+ # style = args_iter.__next__()
+ #
+ # if style == 'body':
+ # bstyle = args_iter.__next__()
+ # nmin = args_iter.__next__()
+ # nmax = args_iter.__next__()
+ # self.list.append(body(bstyle, nmin, nmax))
+ # elif style == 'template':
+ # templat_id = args_iter.__next__()
+ # self.list.append(template(templat_id))
+ # else:
+ # self.list.append(eval(style))
+ #
+ # except StopIteration:
+ # break
+
+_STYLE_DICT = {
+ 'angle': Angle,
+ 'atomic': Atomic,
+ 'body': Body,
+ 'bond': Bond,
+ 'charge': Charge,
+ 'dipole': Dipole,
+ 'dpd': Dpd,
+ 'electron': Electron,
+ 'ellipsoid': Ellipsoid,
+ 'full': Full,
+ 'line': Line,
+ 'meso': Meso,
+ 'molecular': Molecular,
+ 'peri': Peri,
+ 'smd': Smd,
+ 'sphere': Sphere,
+ 'tri': Tri,
+ 'wavepacket': Wavepacket,
+ 'template': Template,
+ 'hybrid': Hybrid,
+}
+
+
+def atom_style(style, *args):
+
+ cls = _STYLE_DICT.get(style, None)
+
+ if not cls:
+ print("Unsupported atom_style: {}".format(style))
+ return None
+
+ return cls(*args)
+
+
+
+
+if __name__ == '__main__':
+ a = Bond()
+ print(a)
+
+ a = atom_style('atomic')
+ print(a)
+
+ a = atom_style('bond')
+ print(a)
+
+ atom_style('full')
+ atom_style('body', 'nparticle', 2, 10)
+ atom_style('hybrid', 'charge', 'bond')
+ atom_style('hybrid', 'charge', 'body', 'nparticle', 2, 5)
+ atom_style('template', 'myMols')
\ No newline at end of file
diff --git a/parser/parser-lammps/LAMMPS/BaseClasses.py b/parser/parser-lammps/LAMMPS/BaseClasses.py
new file mode 100644
index 0000000..5732d6d
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/BaseClasses.py
@@ -0,0 +1,333 @@
+from abc import ABCMeta, abstractproperty
+
+
+# Class hierarchy in LAMMPS source code:
+# LAMMPS
+# - Memory
+# - Error
+# - Universe
+# - Input
+# - Variable
+# - Command
+# - Finish
+# - Special
+# - Atom
+# - AtomVec
+# - Update
+# - Integrate
+# - Min
+# - Neighbor
+# - NeighList
+# - NeighRequest
+# - Comm
+# - Irregular
+# - Domain
+# - Region
+# - Lattice
+# - Force
+# - Pair
+# - Bond
+# - Angle
+# - Dihedral
+# - Improper
+# - KSpace
+# - FFT3D
+# - Remap
+# - Modify
+# - Fix
+# - Compute
+# - Group
+# - Output
+# - Thermo
+# - Dump
+# - WriteRestart
+# - Timer
+
+
+# Build a class hierarchy for easier operator handling
+
+class Lammps(metaclass=ABCMeta):
+ """Abstract superclass of all Lammps related classes"""
+ _row_format = '{:>15} {}'
+ pass
+
+
+class Data(Lammps):
+ def __init__(self):
+ from LAMMPS.Domain import Domain
+ from LAMMPS.Atom import AtomAtomic
+ self.domain = Domain() # simulation box
+ self.atom = AtomAtomic()
+
+ self.system = None
+ self.communication = None
+ self.computes = None
+ self.dumps = None
+ self.fixes = None
+ self.groups = None
+ self.variables = None
+
+ # def __str__(self):
+ # return self._row_format.format('Units:', self.style)
+
+ def info(self):
+ out = (
+ "\n"
+ "LAMMPS object:\n"
+ "Domain:\n==============\n{domain}\n").format(
+ domain=self.domain)
+ return out
+
+
+class Lattice(Lammps):
+ """Define a lattice for use by other commands. In LAMMPS, a lattice is simply a set of points in space, determined by a unit cell with basis atoms, that is replicated infinitely in all dimensions. The arguments of the lattice command can be used to define a wide variety of crystallographic lattices."""
+ pass
+
+
+class Region(Lammps):
+ pass
+
+
+class Group(Lammps):
+ pass
+
+
+class Neighbor(Lammps):
+ """This command sets parameters that affect the building of pairwise neighbor lists. All atom pairs within a neighbor cutoff distance equal to the their force cutoff plus the skin distance are stored in the list. """
+ pass
+
+
+class Units(Lammps):
+ @abstractproperty
+ def style(self): pass
+
+ @abstractproperty
+ def mass(self): pass
+
+ @abstractproperty
+ def distance(self): pass
+
+ @abstractproperty
+ def time(self): pass
+
+ @abstractproperty
+ def energy(self): pass
+
+ @abstractproperty
+ def velocity(self): pass
+
+ @abstractproperty
+ def force(self): pass
+
+ @abstractproperty
+ def torque(self): pass
+
+ @abstractproperty
+ def temperature(self): pass
+
+ @abstractproperty
+ def pressure(self): pass
+
+ @abstractproperty
+ def dynamic_viscosity(self): pass
+
+ @abstractproperty
+ def charge(self): pass
+
+ @abstractproperty
+ def dipole(self): pass
+
+ @abstractproperty
+ def electric_field(self): pass
+
+ @abstractproperty
+ def density(self, dim): pass
+
+ def __str__(self):
+ return self._row_format.format('Units:', self.style)
+
+ def info(self):
+ out = (
+ "\n"
+ "Unit sytle: {style} \n"
+ " mass: {mass:.6e} \n"
+ " distance: {distance:.6e} \n"
+ " time: {time:.6e} \n"
+ " energy: {energy:.6e} \n"
+ " velocity: {velocity:.6e} \n"
+ " force: {force:.6e} \n"
+ " torque: {torque:.6e} \n"
+ " temperature: {temperature:.6e} \n"
+ " pressure: {pressure:.6e} \n"
+ " dynamic_viscosity: {dynamic_viscosity:.6e} \n"
+ " charge: {charge:.6e} \n"
+ " dipole: {dipole:.6e} \n"
+ " electric_field: {electric_field:.6e} \n"
+ " density: {density:.6e} \n").format(
+ style=self.style,
+ mass=self.mass,
+ distance=self.distance,
+ time=self.time,
+ energy=self.energy,
+ velocity=self.velocity,
+ force=self.force,
+ torque=self.torque,
+ temperature=self.temperature,
+ pressure=self.pressure,
+ dynamic_viscosity=self.dynamic_viscosity,
+ charge=self.charge,
+ dipole=self.dipole,
+ electric_field=self.electric_field,
+ density=self.density)
+ return out
+
+
+###################################################
+# Force fields:
+###################################################
+
+
+class AtomStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Atom style:', self.name)
+
+
+class PairStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Pair style:', self.name)
+
+
+class BondStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Bond style:', self.name)
+
+
+class AngleStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Angle style:', self.name)
+
+
+class DihedralStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Dihedral style:', self.name)
+
+
+class ImproperStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('Improper style:', self.name)
+
+
+class KSpaceStyle(Lammps):
+ @abstractproperty
+ def name(self): pass
+
+ def __str__(self):
+ return self._row_format.format('KSpace style:', self.name)
+
+
+class SpetialBonds(Lammps):
+ pass
+
+
+###################################################
+# Abstract class hierarchy:
+###################################################
+
+class Input(Lammps):
+ """The Input class reads an input script, stores variables,
+ and invokes stand- alone commands that are child classes
+ of the Command class"""
+ pass
+
+
+class Variable(Input):
+ """The Command class is a parent class for certain input script
+ commands that perform a one-time operation before/after/between
+ simulations or which invoke a simulation."""
+ pass
+
+
+class Command(Input):
+ """The Command class is a parent class for certain input script
+ commands that perform a one-time operation before/after/between
+ simulations or which invoke a simulation."""
+ pass
+
+
+class Finish(Command):
+ """The Finish class is instantiated to print statistics to the screen
+ after a simulation is performed, by commands like run and minimize."""
+ pass
+
+
+class Special(Command):
+ """The Special class walks the bond topology of a molecular system to
+ find 1st, 2nd, 3rd neighbors of each atom. It is invoked by several commands,
+ like read data, read restart, and replicate."""
+ pass
+
+
+class Atom(Lammps):
+ """The Atom class stores all per-atom arrays.
+ More precisely, they are allo- cated and stored by the AtomVec class,
+ and the Atom class simply stores a pointer to them.
+ The AtomVec class is a parent class for atom styles,
+ defined by the atom style command."""
+ pass
+
+
+class Neighbor(Lammps):
+ """The Neighbor class builds and stores neighbor lists. The NeighList class stores
+ a single list (for all atoms). The NeighRequest class is called by pair, fix, or
+ compute styles when they need a particular kind of neighbor list."""
+ pass
+
+
+class Domain(Lammps):
+ """The Domain class stores the simulation box geometry, as well as geometric Regions
+ and any user definition of a Lattice. The latter are defined by region and
+ lattice commands in an input script."""
+ pass
+
+
+class Modify(Lammps):
+ """The Modify class stores lists of Fix and Compute classes, both of which are parent styles."""
+ pass
+
+
+class Group(Lammps):
+ """The Group class manipulates groups that atoms are assigned to via the group command.
+ It also computes various attributes of groups of atoms."""
+ pass
+
+
+class Output(Lammps):
+ """The Output class is used to generate 3 kinds of output from a LAMMPS simulation:
+ thermodynamic information printed to the screen and log file, dump file snapshots, and restart files.
+ These correspond to the Thermo, Dump, and WriteRestart classes respectively.
+ The Dump class is a parent style."""
+ pass
+
+
+if __name__ == '__main__':
+ lmp = Data()
+ print(lmp)
+ print(lmp.info())
diff --git a/parser/parser-lammps/LAMMPS/BondStyle.py b/parser/parser-lammps/LAMMPS/BondStyle.py
new file mode 100644
index 0000000..7bd137e
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/BondStyle.py
@@ -0,0 +1,42 @@
+from LAMMPS.BaseClasses import BondStyle
+
+
+# class Hybrid(BondStyle):
+# name = 'hybrid'
+# pass
+
+
+class Class2(BondStyle):
+ name = 'class2'
+ pass
+
+
+class Fene(BondStyle):
+ name = 'fene'
+ pass
+
+
+class FeneExpand(BondStyle):
+ name = 'fene/expand'
+ pass
+
+
+class Harmonic(BondStyle):
+ name = 'harmonic'
+ pass
+
+
+class Morse(BondStyle):
+ name = 'morse'
+ pass
+
+
+class Nonlinear(BondStyle):
+ name = 'nonlinear'
+ pass
+
+
+class Quartic(BondStyle):
+ name = 'quartic'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/DihedralStyle.py b/parser/parser-lammps/LAMMPS/DihedralStyle.py
new file mode 100644
index 0000000..0c4e773
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/DihedralStyle.py
@@ -0,0 +1,42 @@
+from LAMMPS.BaseClasses import DihedralStyle
+
+# class none(DihedralStyle):
+# name = 'none'
+# pass
+
+
+class Hybrid(DihedralStyle):
+ name = 'hybrid'
+ pass
+
+
+class Charmm(DihedralStyle):
+ name = 'charmm'
+ pass
+
+
+class Class2(DihedralStyle):
+ name = 'class2'
+ pass
+
+
+class Harmonic(DihedralStyle):
+ name = 'harmonic'
+ pass
+
+
+class Helix(DihedralStyle):
+ name = 'helix'
+ pass
+
+
+class MultiHarmonic(DihedralStyle):
+ name = 'multi/harmonic'
+ pass
+
+
+class Opls(DihedralStyle):
+ name = 'opls'
+ pass
+
+
diff --git a/parser/parser-lammps/LAMMPS/Domain.py b/parser/parser-lammps/LAMMPS/Domain.py
new file mode 100644
index 0000000..ee46298
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Domain.py
@@ -0,0 +1,19 @@
+from LAMMPS.BaseClasses import Domain as AbsDomain
+
+
+class Domain(AbsDomain):
+
+ def __init__(self, dimension=3):
+ self.dimension = dimension
+ self.periodicity = None
+ self.boundary = None
+
+ self.minxlo = 0.0
+ self.minxhi = 0.0
+ self.minylo = 0.0
+ self.minyhi = 0.0
+ self.minzlo = 0.0
+ self.minzhi = 0.0
+
+if __name__ == '__main__':
+ pass
diff --git a/parser/parser-lammps/LAMMPS/GroupStyle.py b/parser/parser-lammps/LAMMPS/GroupStyle.py
new file mode 100644
index 0000000..c5109cd
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/GroupStyle.py
@@ -0,0 +1,66 @@
+from LAMMPS.BaseClasses import Group
+
+# Default
+#
+# All atoms belong to the “all†group.
+
+
+class Delete(Group):
+ name = 'delete'
+ pass
+
+
+class Region(Group):
+ name = 'region'
+ pass
+
+
+class Type(Group):
+ name = 'type'
+ pass
+
+
+class Id(Group):
+ name = 'id'
+ pass
+
+
+class Molecule(Group):
+ name = 'molecule'
+ pass
+
+
+class Variable(Group):
+ name = 'variable'
+ pass
+
+
+class Include(Group):
+ name = 'include'
+ pass
+
+
+class Subtract(Group):
+ name = 'subtract'
+ pass
+
+
+class Union(Group):
+ name = 'union'
+ pass
+
+
+class Intersect(Group):
+ name = 'intersect'
+ pass
+
+
+class Dynamic(Group):
+ name = 'dynamic'
+ pass
+
+
+class Static(Group):
+ name = 'static'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/ImproperStyle.py b/parser/parser-lammps/LAMMPS/ImproperStyle.py
new file mode 100644
index 0000000..c9ad14c
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/ImproperStyle.py
@@ -0,0 +1,27 @@
+from LAMMPS.BaseClasses import ImproperStyle
+
+
+# class none(ImproperStyle):
+# name = 'none'
+# pass
+
+
+class Hybrid(ImproperStyle):
+ name = 'hybrid'
+ pass
+
+
+class Class2(ImproperStyle):
+ name = 'class2'
+ pass
+
+
+class Cvff(ImproperStyle):
+ name = 'cvff'
+ pass
+
+
+class Harmonic(ImproperStyle):
+ name = 'harmonic'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/Input.py b/parser/parser-lammps/LAMMPS/Input.py
new file mode 100644
index 0000000..74accfb
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Input.py
@@ -0,0 +1,567 @@
+from abc import ABCMeta
+from LAMMPS import BaseClasses
+
+
+
+class AtomVec(metaclass=ABCMeta):
+ pass
+
+
+
+
+class Atom(object):
+ def __init__(self, atom_style, ):
+ self.atom_style = atom_style
+
+
+
+
+class AtomStyle(metaclass=ABCMeta):
+ pass
+
+
+class AtomStyleAngle(AtomStyle):
+ pass
+
+
+class Commands(BaseClasses.Command):
+
+ def __init__(self):
+ self.CMD_DICT={
+
+ # input script commands
+ 'clear': self.clear,
+ 'echo': self.echo,
+ 'ifthenelse': self.ifthenelse,
+ 'include': self.include,
+ 'jump': self.jump,
+ 'label': self.label,
+ 'log': self.log,
+ 'next_command': self.next_command,
+ 'partition': self.partition,
+ 'print': self.print_cmd,
+ 'python': self.python,
+ 'quit': self.quit,
+ 'shell': self.shell,
+ 'variable_command': self.variable_command,
+
+ # LAMMPS commands
+ 'angle_coeff': self.angle_coeff,
+ 'angle_style': self.angle_style,
+ 'atom_modify': self.atom_modify,
+ 'atom_style': self.atom_style,
+ 'bond_coeff': self.bond_coeff,
+ 'bond_style': self.bond_style,
+ 'bond_write': self.bond_write,
+ 'boundary': self.boundary,
+ 'box': self.box,
+ 'comm_modify': self.comm_modify,
+ 'comm_style': self.comm_style,
+ 'compute': self.compute,
+ 'compute_modify': self.compute_modify,
+ 'dielectric': self.dielectric,
+ 'dihedral_coeff': self.dihedral_coeff,
+ 'dihedral_style': self.dihedral_style,
+ 'dimension': self.dimension,
+ 'dump': self.dump,
+ 'dump_modify': self.dump_modify,
+ 'fix': self.fix,
+ 'fix_modify': self.fix_modify,
+ 'group_command': self.group_command,
+ 'improper_coeff': self.improper_coeff,
+ 'improper_style': self.improper_style,
+ 'kspace_modify': self.kspace_modify,
+ 'kspace_style': self.kspace_style,
+ 'lattice': self.lattice,
+ 'mass': self.mass,
+ 'min_modify': self.min_modify,
+ 'min_style': self.min_style,
+ 'molecule': self.molecule,
+ 'neigh_modify': self.neigh_modify,
+ 'neighbor_command': self.neighbor_command,
+ 'newton': self.newton,
+ 'package': self.package,
+ 'pair_coeff': self.pair_coeff,
+ 'pair_modify': self.pair_modify,
+ 'pair_style': self.pair_style,
+ 'pair_write': self.pair_write,
+ 'processors': self.processors,
+ 'region': self.region,
+ 'reset_timestep': self.reset_timestep,
+ 'restart': self.restart,
+ 'run_style': self.run_style,
+ 'special_bonds': self.special_bonds,
+ 'suffix': self.suffix,
+ 'thermo': self.thermo,
+ 'thermo_modify': self.thermo_modify,
+ 'thermo_style': self.thermo_style,
+ 'timestep': self.timestep,
+ 'timer_command': self.timer_command,
+ 'uncompute': self.uncompute,
+ 'undump': self.undump,
+ 'unfix': self.unfix,
+ 'units': self.units,
+ }
+
+
+ def parse(self, line):
+ pass
+
+
+ # input script commands
+ def clear(self, *args):
+ print(args)
+ pass
+ def echo(self, *args):
+ print(args)
+ pass
+
+ def ifthenelse(self, *args):
+ print(args)
+ pass
+
+ def include(self, *args):
+ print(args)
+ pass
+
+ def jump(self, *args):
+ print(args)
+ pass
+
+ def label(self, *args):
+ print(args)
+ pass
+
+ def log(self, *args):
+ print(args)
+ pass
+
+ def next_command(self, *args):
+ print(args)
+ pass
+
+ def partition(self, *args):
+ print(args)
+ pass
+
+ def print_cmd(self, *args):
+ print(args)
+ pass
+
+ def python(self, *args):
+ print(args)
+ pass
+
+ def quit(self, *args):
+ print(args)
+ pass
+
+ def shell(self, *args):
+ print(args)
+ pass
+
+ def variable_command(self, *args):
+ print(args)
+ pass
+
+
+ # LAMMPS commands
+
+
+
+
+ def angle_coeff(self, *args):
+ print(args)
+ pass
+
+ def angle_style(self, *args):
+ print(args)
+ pass
+
+ def atom_modify(self, *args):
+ print(args)
+ pass
+
+ def atom_style(self, *args):
+ print(args)
+ pass
+
+ def bond_coeff(self, *args):
+ print(args)
+ pass
+
+ def bond_style(self, *args):
+ print(args)
+ pass
+
+ def bond_write(self, *args):
+ print(args)
+ pass
+
+ def boundary(self, *args):
+ print(args)
+ pass
+
+ def box(self, *args):
+ print(args)
+ pass
+
+ def comm_modify(self, *args):
+ print(args)
+ pass
+
+ def comm_style(self, *args):
+ print(args)
+ pass
+
+ def compute(self, *args):
+ print(args)
+ pass
+
+ def compute_modify(self, *args):
+ print(args)
+ pass
+
+ def dielectric(self, *args):
+ print(args)
+ pass
+
+ def dihedral_coeff(self, *args):
+ print(args)
+ pass
+
+ def dihedral_style(self, *args):
+ print(args)
+ pass
+
+ def dimension(self, *args):
+ print(args)
+ pass
+
+ def dump(self, *args):
+ print(args)
+ pass
+
+ def dump_modify(self, *args):
+ print(args)
+ pass
+
+ def fix(self, *args):
+ print(args)
+ pass
+
+ def fix_modify(self, *args):
+ print(args)
+ pass
+
+ def group_command(self, *args):
+ print(args)
+ pass
+
+ def improper_coeff(self, *args):
+ print(args)
+ pass
+
+ def improper_style(self, *args):
+ print(args)
+ pass
+
+ def kspace_modify(self, *args):
+ print(args)
+ pass
+
+ def kspace_style(self, *args):
+ print(args)
+ pass
+
+ def lattice(self, *args):
+ print(args)
+ pass
+
+ def mass(self, *args):
+ print(args)
+ pass
+
+ def min_modify(self, *args):
+ print(args)
+ pass
+
+ def min_style(self, *args):
+ print(args)
+ pass
+
+ def molecule(self, *args):
+ print(args)
+ pass
+
+ def neigh_modify(self, *args):
+ print(args)
+ pass
+
+ def neighbor_command(self, *args):
+ print(args)
+ pass
+
+ def newton(self, *args):
+ print(args)
+ pass
+
+ def package(self, *args):
+ print(args)
+ pass
+
+ def pair_coeff(self, *args):
+ print(args)
+ pass
+
+ def pair_modify(self, *args):
+ print(args)
+ pass
+
+ def pair_style(self, *args):
+ print(args)
+ pass
+
+ def pair_write(self, *args):
+ print(args)
+ pass
+
+ def processors(self, *args):
+ print(args)
+ pass
+
+ def region(self, *args):
+ print(args)
+ pass
+
+ def reset_timestep(self, *args):
+ print(args)
+ pass
+
+ def restart(self, *args):
+ print(args)
+ pass
+
+ def run_style(self, *args):
+ print(args)
+ pass
+
+ def special_bonds(self, *args):
+ print(args)
+ pass
+
+ def suffix(self, *args):
+ print(args)
+ pass
+
+ def thermo(self, *args):
+ print(args)
+ pass
+
+ def thermo_modify(self, *args):
+ print(args)
+ pass
+
+ def thermo_style(self, *args):
+ print(args)
+ pass
+
+ def timestep(self, *args):
+ print(args)
+ pass
+
+ def timer_command(self, *args):
+ print(args)
+ pass
+
+ def uncompute(self, *args):
+ print(args)
+ pass
+
+ def undump(self, *args):
+ print(args)
+ pass
+
+ def unfix(self, *args):
+ print(args)
+ pass
+
+ def units(self, *args):
+ print(args)
+ pass
+
+ def parse(self, line):
+
+ line_list = line.split()
+
+ if len(line_list) > 0:
+ cmd = line_list[0]
+ else:
+ return
+
+ if len(line_list) > 1:
+ args = line_list[1:]
+ else:
+ args = []
+
+ cmd_fn = self.CMD_DICT.get(cmd, None)
+
+ if cmd_fn is None:
+ return
+
+ cmd_fn(args)
+
+ # if cmd == "clear":
+ # self.clear(self, *args)
+ # elif cmd == "echo":
+ # self.echo(self, *args)
+ # elif cmd == "if":
+ # self.ifthenelse(self, *args)
+ # elif cmd == "include":
+ # self.include(self, *args)
+ # elif cmd == "jump":
+ # self.jump(self, *args)
+ # elif cmd == "label":
+ # self.label(self, *args)
+ # elif cmd == "log":
+ # self.log(self, *args)
+ # elif cmd == "next":
+ # self.next_command(self, *args)
+ # elif cmd == "partition":
+ # self.partition(self, *args)
+ # elif cmd == "print":
+ # self.print_cmd(self, *args)
+ # elif cmd == "python":
+ # self.python(self, *args)
+ # elif cmd == "quit":
+ # self.quit(self, *args)
+ # elif cmd == "shell":
+ # self.shell(self, *args)
+ # elif cmd == "variable":
+ # self.variable_command(self, *args)
+ #
+ # elif cmd == "angle_coeff":
+ # self.angle_coeff(self, *args)
+ # elif cmd == "angle_style":
+ # self.angle_style(self, *args)
+ # elif cmd == "atom_modify":
+ # self.atom_modify(self, *args)
+ # elif cmd == "atom_style":
+ # self.atom_style(self, *args)
+ # elif cmd == "bond_coeff":
+ # self.bond_coeff(self, *args)
+ # elif cmd == "bond_style":
+ # self.bond_style(self, *args)
+ # elif cmd == "bond_write":
+ # self.bond_write(self, *args)
+ # elif cmd == "boundary":
+ # self.boundary(self, *args)
+ # elif cmd == "box": self.box(self, *args)
+ # elif cmd == "comm_modify":
+ # self.comm_modify(self, *args)
+ # elif cmd == "comm_style":
+ # self.comm_style(self, *args)
+ # elif cmd == "compute":
+ # self.compute(self, *args)
+ # elif cmd == "compute_modify":
+ # self.compute_modify(self, *args)
+ # elif cmd == "dielectric":
+ # self.dielectric(self, *args)
+ # elif cmd == "dihedral_coeff":
+ # self.dihedral_coeff(self, *args)
+ # elif cmd == "dihedral_style":
+ # self.dihedral_style(self, *args)
+ # elif cmd == "dimension":
+ # self.dimension(self, *args)
+ # elif cmd == "dump":
+ # self.dump(self, *args)
+ # elif cmd == "dump_modify":
+ # self.dump_modify(self, *args)
+ # elif cmd == "fix":
+ # self.fix(self, *args)
+ # elif cmd == "fix_modify":
+ # self.fix_modify(self, *args)
+ # elif cmd == "group":
+ # self.group_command(self, *args)
+ # elif cmd == "improper_coeff":
+ # self.improper_coeff(self, *args)
+ # elif cmd == "improper_style":
+ # self.improper_style(self, *args)
+ # elif cmd == "kspace_modify":
+ # self.kspace_modify(self, *args)
+ # elif cmd == "kspace_style":
+ # self.kspace_style(self, *args)
+ # elif cmd == "lattice":
+ # self.lattice(self, *args)
+ # elif cmd == "mass":
+ # self.mass(self, *args)
+ # elif cmd == "min_modify":
+ # self.min_modify(self, *args)
+ # elif cmd == "min_style":
+ # self.min_style(self, *args)
+ # elif cmd == "molecule":
+ # self.molecule(self, *args)
+ # elif cmd == "neigh_modify":
+ # self.neigh_modify(self, *args)
+ # elif cmd == "neighbor":
+ # self.neighbor_command(self, *args)
+ # elif cmd == "newton":
+ # self.newton(self, *args)
+ # elif cmd == "package":
+ # self.package(self, *args)
+ # elif cmd == "pair_coeff":
+ # self.pair_coeff(self, *args)
+ # elif cmd == "pair_modify":
+ # self.pair_modify(self, *args)
+ # elif cmd == "pair_style":
+ # self.pair_style(self, *args)
+ # elif cmd == "pair_write":
+ # self.pair_write(self, *args)
+ # elif cmd == "processors":
+ # self.processors(self, *args)
+ # elif cmd == "region":
+ # self.region(self, *args)
+ # elif cmd == "reset_timestep":
+ # self.reset_timestep(self, *args)
+ # elif cmd == "restart":
+ # self.restart(self, *args)
+ # elif cmd == "run_style":
+ # self.run_style(self, *args)
+ # elif cmd == "special_bonds":
+ # self.special_bonds(self, *args)
+ # elif cmd == "suffix":
+ # self.suffix(self, *args)
+ # elif cmd == "thermo":
+ # self.thermo(self, *args)
+ # elif cmd == "thermo_modify":
+ # self.thermo_modify(self, *args)
+ # elif cmd == "thermo_style":
+ # self.thermo_style(self, *args)
+ # elif cmd == "timestep":
+ # self.timestep(self, *args)
+ # elif cmd == "timer":
+ # self.timer_command(self, *args)
+ # elif cmd == "uncompute":
+ # self.uncompute(self, *args)
+ # elif cmd == "undump":
+ # self.undump(self, *args)
+ # elif cmd == "unfix":
+ # self.unfix(self, *args)
+ # elif cmd == "units":
+ # self.units(self, *args)
+
+ print(cmd)
+
+
+if __name__ == '__main__':
+
+ input = Commands()
+ file_name = '../test/methane/input.methane_nvt_thermo_style_one'
+
+
+ with open(file_name) as file:
+ for line in file.readlines():
+
+ input.parse(line)
+
+ print(line)
diff --git a/parser/parser-lammps/LAMMPS/KSpaceStyle.py b/parser/parser-lammps/LAMMPS/KSpaceStyle.py
new file mode 100644
index 0000000..8dfb13c
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/KSpaceStyle.py
@@ -0,0 +1,92 @@
+from LAMMPS.BaseClasses import KSpaceStyle
+
+
+class none(KSpaceStyle):
+ name = 'none'
+ pass
+
+
+class Ewald(KSpaceStyle):
+ name = 'ewald'
+ pass
+
+
+class EwaldDisp(KSpaceStyle):
+ name = 'ewald/disp'
+ pass
+
+
+class EwaldOmp(KSpaceStyle):
+ name = 'ewald/omp'
+ pass
+
+
+class Pppm(KSpaceStyle):
+ name = 'pppm'
+ pass
+
+
+class PppmCg(KSpaceStyle):
+ name = 'pppm/cg'
+ pass
+
+
+class PppmDisp(KSpaceStyle):
+ name = 'pppm/disp'
+ pass
+
+
+class PppmTip4p(KSpaceStyle):
+ name = 'pppm/tip4p'
+ pass
+
+
+class PppmStagger(KSpaceStyle):
+ name = 'pppm/stagger'
+ pass
+
+
+class PppmDispTip4p(KSpaceStyle):
+ name = 'pppm/disp/tip4p'
+ pass
+
+
+class PppmGpu(KSpaceStyle):
+ name = 'pppm/gpu'
+ pass
+
+
+class PppmOmp(KSpaceStyle):
+ name = 'pppm/omp'
+ pass
+
+
+class PppmCgOmp(KSpaceStyle):
+ name = 'pppm/cg/omp'
+ pass
+
+
+class PppmTip4pOmp(KSpaceStyle):
+ name = 'pppm/tip4p/omp'
+ pass
+
+
+class Msm(KSpaceStyle):
+ name = 'msm'
+ pass
+
+
+class MsmCg(KSpaceStyle):
+ name = 'msm/cg'
+ pass
+
+
+class MsmOmp(KSpaceStyle):
+ name = 'msm/omp'
+ pass
+
+
+class MsmCgOmp(KSpaceStyle):
+ name = 'msm/cg/omp'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/Lattice.py b/parser/parser-lammps/LAMMPS/Lattice.py
new file mode 100644
index 0000000..520fc52
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Lattice.py
@@ -0,0 +1,55 @@
+from LAMMPS.BaseClasses import Lattice
+
+
+# Default
+# lattice none 1.0
+
+# class none(Lattice):
+# name = 'none'
+# pass
+
+
+class Sc(Lattice):
+ name = 'sc'
+ pass
+
+
+class Bcc(Lattice):
+ name = 'bcc'
+ pass
+
+
+class Fcc(Lattice):
+ name = 'fcc'
+ pass
+
+
+class Hcp(Lattice):
+ name = 'hcp'
+ pass
+
+
+class Diamond(Lattice):
+ name = 'diamond'
+ pass
+
+
+class Sq(Lattice):
+ name = 'sq'
+ pass
+
+
+class sq2(Lattice):
+ name = 'sq2'
+ pass
+
+
+class hex(Lattice):
+ name = 'hex'
+ pass
+
+
+class custom(Lattice):
+ name = 'custom'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/NeighborStyle.py b/parser/parser-lammps/LAMMPS/NeighborStyle.py
new file mode 100644
index 0000000..04748c1
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/NeighborStyle.py
@@ -0,0 +1,24 @@
+from LAMMPS.BaseClasses import Neighbor
+
+# Default
+#
+# 0.3 bin for units = lj, skin = 0.3 sigma
+# 2.0 bin for units = real or metal, skin = 2.0 Angstroms
+# 0.001 bin for units = si, skin = 0.001 meters = 1.0 mm
+# 0.1 bin for units = cgs, skin = 0.1 cm = 1.0 mm
+
+
+class Bin(Neighbor):
+ name = 'bin'
+ pass
+
+
+class Nsq(Neighbor):
+ name = 'nsq'
+ pass
+
+
+class Multi(Neighbor):
+ name = 'multi'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/PairStyle.py b/parser/parser-lammps/LAMMPS/PairStyle.py
new file mode 100644
index 0000000..d861c6b
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/PairStyle.py
@@ -0,0 +1,562 @@
+from LAMMPS.BaseClasses import PairStyle
+
+
+# class None(PairStyle):
+# name = 'none'
+# pass
+
+
+class Hybrid(PairStyle):
+ name = 'hybrid'
+ pass
+
+
+class HybridOverlay(PairStyle):
+ name = 'hybrid/overlay'
+ pass
+
+
+class Zero(PairStyle):
+ name = 'zero'
+ pass
+
+
+class Adp(PairStyle):
+ name = 'adp'
+ pass
+
+
+class Airebo(PairStyle):
+ name = 'airebo'
+ pass
+
+
+class AireboMorse(PairStyle):
+ name = 'airebo/morse'
+ pass
+
+
+class Beck(PairStyle):
+ name = 'beck'
+ pass
+
+
+class Body(PairStyle):
+ name = 'body'
+ pass
+
+
+class Bop(PairStyle):
+ name = 'bop'
+ pass
+
+
+class Born(PairStyle):
+ name = 'born'
+ pass
+
+
+class BornCoulLong(PairStyle):
+ name = 'born/coul/long'
+ pass
+
+
+class BornCoulLongCs(PairStyle):
+ name = 'born/coul/long/cs'
+ pass
+
+
+class BornCoulMsm(PairStyle):
+ name = 'born/coul/msm'
+ pass
+
+
+class BornCoulWolf(PairStyle):
+ name = 'born/coul/wolf'
+ pass
+
+
+class Brownian(PairStyle):
+ name = 'brownian'
+ pass
+
+
+class BrownianPoly(PairStyle):
+ name = 'brownian/poly'
+ pass
+
+
+class Buck(PairStyle):
+ name = 'buck'
+ pass
+
+
+class BuckCoulCut(PairStyle):
+ name = 'buck/coul/cut'
+ pass
+
+
+class BuckCoulLong(PairStyle):
+ name = 'buck/coul/long'
+ pass
+
+
+class BuckCoulLongCs(PairStyle):
+ name = 'buck/coul/long/cs'
+ pass
+
+
+class BuckCoulMsm(PairStyle):
+ name = 'buck/coul/msm'
+ pass
+
+
+class BuckLongCoulLong(PairStyle):
+ name = 'buck/long/coul/long'
+ pass
+
+
+class Colloid(PairStyle):
+ name = 'colloid'
+ pass
+
+
+class Comb(PairStyle):
+ name = 'comb'
+ pass
+
+
+class Comb3(PairStyle):
+ name = 'comb3'
+ pass
+
+
+class CoulCut(PairStyle):
+ name = 'coul/cut'
+ pass
+
+
+class CoulDebye(PairStyle):
+ name = 'coul/debye'
+ pass
+
+
+class CoulDsf(PairStyle):
+ name = 'coul/dsf'
+ pass
+
+
+class CoulLong(PairStyle):
+ name = 'coul/long'
+ pass
+
+
+class CoulLongCs(PairStyle):
+ name = 'coul/long/cs'
+ pass
+
+
+class CoulMsm(PairStyle):
+ name = 'coul/msm'
+ pass
+
+
+class CoulStreitz(PairStyle):
+ name = 'coul/streitz'
+ pass
+
+
+class CoulWolf(PairStyle):
+ name = 'coul/wolf'
+ pass
+
+
+class Dpd(PairStyle):
+ name = 'dpd'
+ pass
+
+
+class DpdTstat(PairStyle):
+ name = 'dpd/tstat'
+ pass
+
+
+class Dsmc(PairStyle):
+ name = 'dsmc'
+ pass
+
+
+class Eam(PairStyle):
+ name = 'eam'
+ pass
+
+
+class EamAlloy(PairStyle):
+ name = 'eam/alloy'
+ pass
+
+
+class EamFs(PairStyle):
+ name = 'eam/fs'
+ pass
+
+
+class Eim(PairStyle):
+ name = 'eim'
+ pass
+
+
+class Gauss(PairStyle):
+ name = 'gauss'
+ pass
+
+
+class Gayberne(PairStyle):
+ name = 'gayberne'
+ pass
+
+
+class GranHertzHistory(PairStyle):
+ name = 'gran/hertz/history'
+ pass
+
+
+class GranHooke(PairStyle):
+ name = 'gran/hooke'
+ pass
+
+
+class GranHookeHistory(PairStyle):
+ name = 'gran/hooke/history'
+ pass
+
+
+class HbondDreidingLj(PairStyle):
+ name = 'hbond/dreiding/lj'
+ pass
+
+
+class HbondDreidingMorse(PairStyle):
+ name = 'hbond/dreiding/morse'
+ pass
+
+
+class Kim(PairStyle):
+ name = 'kim'
+ pass
+
+
+class Lcbop(PairStyle):
+ name = 'lcbop'
+ pass
+
+
+class LineLj(PairStyle):
+ name = 'line/lj'
+ pass
+
+
+class LjCharmmCoulCharmm(PairStyle):
+ name = 'lj/charmm/coul/charmm'
+ pass
+
+
+class LjCharmmCoulCharmmImplicit(PairStyle):
+ name = 'lj/charmm/coul/charmm/implicit'
+ pass
+
+
+class LjCharmmCoulLong(PairStyle):
+ name = 'lj/charmm/coul/long'
+ pass
+
+
+class LjCharmmCoulMsm(PairStyle):
+ name = 'lj/charmm/coul/msm'
+ pass
+
+
+class LjClass2(PairStyle):
+ name = 'lj/class2'
+ pass
+
+
+class LjClass2CoulCut(PairStyle):
+ name = 'lj/class2/coul/cut'
+ pass
+
+
+class LjClass2CoulLong(PairStyle):
+ name = 'lj/class2/coul/long'
+ pass
+
+
+class LjCubic(PairStyle):
+ name = 'lj/cubic'
+ pass
+
+
+class LjCut(PairStyle):
+ name = 'lj/cut'
+ pass
+
+
+class LjCutCoulCut(PairStyle):
+ name = 'lj/cut/coul/cut'
+ pass
+
+
+class LjCutCoulDebye(PairStyle):
+ name = 'lj/cut/coul/debye'
+ pass
+
+
+class LjCutCoulDsf(PairStyle):
+ name = 'lj/cut/coul/dsf'
+ pass
+
+
+class LjCutCoulLong(PairStyle):
+ name = 'lj/cut/coul/long'
+ pass
+
+
+class LjCutCoulLongCs(PairStyle):
+ name = 'lj/cut/coul/long/cs'
+ pass
+
+
+class LjCutCoulMsm(PairStyle):
+ name = 'lj/cut/coul/msm'
+ pass
+
+
+class LjCutDipoleCut(PairStyle):
+ name = 'lj/cut/dipole/cut'
+ pass
+
+
+class LjCutDipoleLong(PairStyle):
+ name = 'lj/cut/dipole/long'
+ pass
+
+
+class LjCutTip4pCut(PairStyle):
+ name = 'lj/cut/tip4p/cut'
+ pass
+
+
+class LjCutTip4pLong(PairStyle):
+ name = 'lj/cut/tip4p/long'
+ pass
+
+
+class LjExpand(PairStyle):
+ name = 'lj/expand'
+ pass
+
+
+class LjGromacs(PairStyle):
+ name = 'lj/gromacs'
+ pass
+
+
+class LjGromacsCoulGromacs(PairStyle):
+ name = 'lj/gromacs/coul/gromacs'
+ pass
+
+
+class LjLongCoulLong(PairStyle):
+ name = 'lj/long/coul/long'
+ pass
+
+
+class LjLongDipoleLong(PairStyle):
+ name = 'lj/long/dipole/long'
+ pass
+
+
+class LjLongTip4pLong(PairStyle):
+ name = 'lj/long/tip4p/long'
+ pass
+
+
+class LjSmooth(PairStyle):
+ name = 'lj/smooth'
+ pass
+
+
+class LjSmoothLinear(PairStyle):
+ name = 'lj/smooth/linear'
+ pass
+
+
+class Lj96Cut(PairStyle):
+ name = 'lj96/cut'
+ pass
+
+
+class Lubricate(PairStyle):
+ name = 'lubricate'
+ pass
+
+
+class LubricatePoly(PairStyle):
+ name = 'lubricate/poly'
+ pass
+
+
+class LubricateU(PairStyle):
+ name = 'lubricate/u'
+ pass
+
+
+class LubricateUPoly(PairStyle):
+ name = 'lubricate/u/poly'
+ pass
+
+
+class Meam(PairStyle):
+ name = 'meam'
+ pass
+
+
+class MieCut(PairStyle):
+ name = 'mie/cut'
+ pass
+
+
+class Morse(PairStyle):
+ name = 'morse'
+ pass
+
+
+class Nb3bHarmonic(PairStyle):
+ name = 'nb3b/harmonic'
+ pass
+
+
+class NmCut(PairStyle):
+ name = 'nm/cut'
+ pass
+
+
+class NmCutCoulCut(PairStyle):
+ name = 'nm/cut/coul/cut'
+ pass
+
+
+class NmCutCoulLong(PairStyle):
+ name = 'nm/cut/coul/long'
+ pass
+
+
+class PeriEps(PairStyle):
+ name = 'peri/eps'
+ pass
+
+
+class PeriLps(PairStyle):
+ name = 'peri/lps'
+ pass
+
+
+class PeriPmb(PairStyle):
+ name = 'peri/pmb'
+ pass
+
+
+class PeriVes(PairStyle):
+ name = 'peri/ves'
+ pass
+
+
+class Polymorphic(PairStyle):
+ name = 'polymorphic'
+ pass
+
+
+class Reax(PairStyle):
+ name = 'reax'
+ pass
+
+
+class Rebo(PairStyle):
+ name = 'rebo'
+ pass
+
+
+class Resquared(PairStyle):
+ name = 'resquared'
+ pass
+
+
+class Snap(PairStyle):
+ name = 'snap'
+ pass
+
+
+class Soft(PairStyle):
+ name = 'soft'
+ pass
+
+
+class Sw(PairStyle):
+ name = 'sw'
+ pass
+
+
+class Table(PairStyle):
+ name = 'table'
+ pass
+
+
+class Tersoff(PairStyle):
+ name = 'tersoff'
+ pass
+
+
+class TersoffMod(PairStyle):
+ name = 'tersoff/mod'
+ pass
+
+
+class TersoffZbl(PairStyle):
+ name = 'tersoff/zbl'
+ pass
+
+
+class Tip4pCut(PairStyle):
+ name = 'tip4p/cut'
+ pass
+
+
+class Tip4pLong(PairStyle):
+ name = 'tip4p/long'
+ pass
+
+
+class TriLj(PairStyle):
+ name = 'tri/lj'
+ pass
+
+
+class Vashishta(PairStyle):
+ name = 'vashishta'
+ pass
+
+
+class Yukawa(PairStyle):
+ name = 'yukawa'
+ pass
+
+
+class YukawaColloid(PairStyle):
+ name = 'yukawa/colloid'
+ pass
+
+
+class Zbl(PairStyle):
+ name = 'zbl'
+ pass
+
diff --git a/parser/parser-lammps/LAMMPS/Region.py b/parser/parser-lammps/LAMMPS/Region.py
new file mode 100644
index 0000000..960cd1e
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Region.py
@@ -0,0 +1,61 @@
+from LAMMPS.BaseClasses import Region
+
+
+class Block(Region):
+ name = 'block'
+
+ def __init__(self, *args):
+ pass
+
+
+class Cone(Region):
+ name = 'cone'
+
+ def __init__(self, *args):
+ pass
+
+
+class Cylinder(Region):
+ name = 'cylinder'
+
+ def __init__(self, *args):
+ pass
+
+
+class Plane(Region):
+ name = 'plane'
+
+ def __init__(self, *args):
+ pass
+
+
+class Prism(Region):
+ name = 'prism'
+
+ def __init__(self, *args):
+ pass
+
+
+class Sphere(Region):
+ name = 'sphere'
+
+ def __init__(self, *args):
+ pass
+
+
+class Union(Region):
+ name = 'union'
+
+ def __init__(self, *args):
+ pass
+
+
+class Intersect(Region):
+ name = 'intersect'
+
+ def __init__(self, *args):
+ pass
+
+
+if __name__ == '__main__':
+ pass
diff --git a/parser/parser-lammps/LAMMPS/Units.py b/parser/parser-lammps/LAMMPS/Units.py
new file mode 100644
index 0000000..699e095
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/Units.py
@@ -0,0 +1,755 @@
+import logging
+from LAMMPS.BaseClasses import Units
+
+logger = logging.getLogger(__name__)
+
+
+# """
+# The units command also sets the timestep size and neighbor skin distance to default values for each style:
+# For style lj these are dt = 0.005 tau and skin = 0.3 sigma.
+# For style real these are dt = 1.0 fmsec and skin = 2.0 Angstroms.
+# For style metal these are dt = 0.001 psec and skin = 2.0 Angstroms.
+# For style si these are dt = 1.0e-8 sec and skin = 0.001 meters.
+# For style cgs these are dt = 1.0e-8 sec and skin = 0.1 cm.
+# For style electron these are dt = 0.001 fmsec and skin = 2.0 Bohr.
+# For style micro these are dt = 2.0 microsec and skin = 0.1 micrometers.
+# For style nano these are dt = 0.00045 nanosec and skin = 0.1 nanometers.
+# """
+
+def units(style, parent=None):
+ """Wrapper for unit style command"""
+ if not parent:
+ print("hehe")
+
+
+class _units(object):
+ # According Lammps soucre code the physical constants from:
+ # http://physics.nist.gov/cuu/Constants/Table/allascii.txt
+ # using thermochemical calorie = 4.184 J
+
+ # constants
+ mole = 6.022140857e23 # Avogadro constant [mol^-1]
+ Kb = 1.38064852e-23 # Boltzmann constant [J K^-1]
+ perm0 = 8.854187817e-12 # vacuum permittivity / electric constant [F m^-1]
+
+ # mass [kilograms]
+ kilogram = 1.
+ gram = 1e-3
+ picogram = 1e-15
+ attogram = 1e-21
+ atomicmass = 1.660539040e-27 # atomic mass units [kg]
+
+ # distance [meters]
+ meter = 1.
+ cm = 1e-2
+ micrometer = 1e-6
+ nanometer = 1e-9
+ Angstrom = 1.00001495e-10
+ Bohr = 0.52917721067e-10 # Bohr radius [m]
+
+ # time [seconds]
+ second = 1.
+ microsecond = 1e-6
+ nanosecond = 1e-9
+ picosecond = 1e-12
+ femtosecond = 1e-15
+ atomictime = 2.418884326509e-17 # 1.03275e-15 # atomic time units
+
+ # energy [Joules]
+ Joule = 1.
+ Kcal = 4.184 # Thermochemical calorie
+ ergs = 1e-7
+ eV = 1.6021766208e-19 # electron volt [J]
+ Hartree = 4.359744650e-18 # Hartree energy [J]
+
+
+ # velocity [meters/second]
+
+
+ # force [Newtons]
+ Newton = 1.
+ dyne = 1e-5
+
+ # torque [Newton-meters]
+
+ # temperature [Kelvin]
+ Kelvin = 1.
+
+ # pressure [Pascals]
+ Pascal = 1.
+ atmosphere = 101325.
+ bar = 1e5
+
+ # dynamic_viscosity [Pascal*second]
+ Poise = 0.1
+
+ # charge [Coulombs (1.6021765e-19 is a proton)]
+ Coulomb = 1.
+ picocoulomb = 1e-6
+ charge_e = 1.6021766208e-19
+ statcoulomb = 1/2997924580 # statcoulomb (statC) or franklin (Fr) or electrostatic unit of charge (esu)
+
+ # dipole [Coulombs*meters]
+ # electric_field [volts/meter]
+ volt = 1.
+ statvolt = 299.792458
+ Debye = 1/299792458 * 1e-21
+
+ # density [kilograms/meter^dim]
+
+
+
+
+
+class lj(Units):
+ """For style lj, all quantities are unitless. Without loss of generality, LAMMPS sets the fundamental quantities mass, sigma, epsilon, and the Boltzmann constant = 1. The masses, distances, energies you specify are multiples of these fundamental values. The formulas relating the reduced or unitless quantity (with an asterisk) to the same quantity with units is also given. Thus you can use the mass & sigma & epsilon values for a specific material and convert the results from a unitless LJ simulation into physical quantities.
+ - mass = mass or m
+ - distance = sigma, where x* = x / sigma
+ - time = tau, where t* = t (epsilon / m / sigma^2)^1/2
+ - energy = epsilon, where E* = E / epsilon
+ - velocity = sigma/tau, where v* = v tau / sigma
+ - force = epsilon/sigma, where f* = f sigma / epsilon
+ - torque = epsilon, where t* = t / epsilon
+ - temperature = reduced LJ temperature, where T* = T Kb / epsilon
+ - pressure = reduced LJ pressure, where P* = P sigma^3 / epsilon
+ - dynamic viscosity = reduced LJ viscosity, where eta* = eta sigma^3 / epsilon / tau
+ - charge = reduced LJ charge, where q* = q / (4 pi perm0 sigma epsilon)^1/2
+ - dipole = reduced LJ dipole, moment where *mu = mu / (4 pi perm0 sigma^3 epsilon)^1/2
+ - electric field = force/charge, where E* = E (4 pi perm0 sigma epsilon)^1/2 sigma / epsilon
+ - density = mass/volume, where rho* = rho sigma^dim"""
+
+ style = "lj"
+
+ def __init__(self, mass=1., sigma=1., epsilon=1.):
+ self._mass = mass
+ self._sigma = sigma
+ self._epsilon = epsilon
+
+ @property
+ def _tau(self):
+ from math import sqrt
+ return self._sigma * sqrt(self.mass/self._epsilon)
+
+ @property
+ def mass(self):
+ return self._mass
+
+ @property
+ def distance(self):
+ return self._sigma
+
+ @property
+ def time(self):
+ return self._tau
+
+ @property
+ def energy(self):
+ return self._epsilon
+
+ @property
+ def velocity(self):
+ return self._sigma/self._tau
+
+ @property
+ def force(self):
+ return self._epsilon/self._sigma
+
+ @property
+ def torque(self):
+ return self._epsilon
+
+ @property
+ def temperature(self):
+ return self._epsilon/_units.Kb
+
+ @property
+ def pressure(self):
+ return self._epsilon/self._sigma**3
+
+ @property
+ def dynamic_viscosity(self):
+ return self._tau * self._epsilon / self._sigma**3
+
+ @property
+ def charge(self):
+ from math import pi, sqrt
+ return sqrt(4 * pi * _units.perm0 * self._sigma * self._epsilon)
+
+ @property
+ def dipole(self):
+ from math import pi, sqrt
+ return sqrt(4 * pi * _units.perm0 * self._sigma**3 * self._epsilon)
+
+ @property
+ def electric_field(self):
+ from math import pi, sqrt
+ return self._epsilon / self._sigma / sqrt(4 * pi * _units.perm0 * self._sigma * self._epsilon)
+
+ @property
+ def density(self, dim=3):
+ return self._mass / self._sigma**dim
+
+ def parse(selfs):
+ logger.warn("NOT SUPPORTED: For LJ style all quantities are unitless")
+
+class real(Units):
+ """For style real, these are the units:
+ - mass = grams/mole
+ - distance = Angstroms
+ - time = femtoseconds
+ - energy = Kcal/mole
+ - velocity = Angstroms/femtosecond
+ - force = Kcal/mole-Angstrom
+ - torque = Kcal/mole
+ - temperature = Kelvin
+ - pressure = atmospheres
+ - dynamic viscosity = Poise
+ - charge = multiple of electron charge (1.0 is a proton)
+ - dipole = charge*Angstroms
+ - electric field = volts/Angstrom
+ - density = gram/cm^dim"""
+
+ style = "real"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.gram/_units.mole
+
+ @property
+ def distance(self):
+ return _units.Angstrom
+
+ @property
+ def time(self):
+ return _units.femtosecond
+
+ @property
+ def energy(self):
+ return _units.Kcal / _units.mole
+
+ @property
+ def velocity(self):
+ return _units.Angstrom / _units.femtosecond
+
+ @property
+ def force(self):
+ return _units.Kcal / _units.mole / _units.Angstrom
+
+ @property
+ def torque(self):
+ return _units.Kcal / _units.mole
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.atmosphere
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.Poise
+
+ @property
+ def charge(self):
+ return _units.charge_e
+
+ @property
+ def dipole(self):
+ return _units.charge_e * _units.Angstrom
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.Angstrom
+
+ @property
+ def density(self, dim=3):
+ return _units.gram / _units.cm**dim
+
+class metal(Units):
+ """For style metal, these are the units:
+ - mass = grams/mole
+ - distance = Angstroms
+ - time = picoseconds
+ - energy = eV
+ - velocity = Angstroms/picosecond
+ - force = eV/Angstrom
+ - torque = eV
+ - temperature = Kelvin
+ - pressure = bars
+ - dynamic viscosity = Poise
+ - charge = multiple of electron charge (1.0 is a proton)
+ - dipole = charge*Angstroms
+ - electric field = volts/Angstrom
+ - density = gram/cm^dim"""
+
+ style = "metal"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.gram/_units.mole
+
+ @property
+ def distance(self):
+ return _units.Angstrom
+
+ @property
+ def time(self):
+ return _units.picosecond
+
+ @property
+ def energy(self):
+ return _units.eV
+
+ @property
+ def velocity(self):
+ return _units.Angstrom / _units.picosecond
+
+ @property
+ def force(self):
+ return _units.eV / _units.Angstrom
+
+ @property
+ def torque(self):
+ return _units.eV
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.bar
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.Poise
+
+ @property
+ def charge(self):
+ return _units.charge_e
+
+ @property
+ def dipole(self):
+ return _units.charge_e * _units.Angstrom
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.Angstrom
+
+ @property
+ def density(self, dim=3):
+ return _units.gram / _units.cm**dim
+
+
+class si(Units):
+ """For style si, these are the units:
+ - mass = kilograms
+ - distance = meters
+ - time = seconds
+ - energy = Joules
+ - velocity = meters/second
+ - force = Newtons
+ - torque = Newton-meters
+ - temperature = Kelvin
+ - pressure = Pascals
+ - dynamic viscosity = Pascal*second
+ - charge = Coulombs (1.6021765e-19 is a proton)
+ - dipole = Coulombs*meters
+ - electric field = volts/meter
+ - density = kilograms/meter^dim"""
+
+ style = "si"
+
+ def __init__(self):
+ pass
+
+
+ @property
+ def mass(self):
+ return _units.kilogram
+
+ @property
+ def distance(self):
+ return _units.meter
+
+ @property
+ def time(self):
+ return _units.second
+
+ @property
+ def energy(self):
+ return _units.Joule
+
+ @property
+ def velocity(self):
+ return _units.meter / _units.second
+
+ @property
+ def force(self):
+ return _units.Newton
+
+ @property
+ def torque(self):
+ return _units.Newton * _units.meter
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.Pascal
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.Pascal * _units.second
+
+ @property
+ def charge(self):
+ return _units.Coulomb
+
+ @property
+ def dipole(self):
+ return _units.Coulomb * _units.meter
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.meter
+
+ @property
+ def density(self, dim=3):
+ return _units.kilogram / _units.meter**dim
+
+
+class cgs(Units):
+ """For style cgs, these are the units:
+ - mass = grams
+ - distance = centimeters
+ - time = seconds
+ - energy = ergs
+ - velocity = centimeters/second
+ - force = dynes
+ - torque = dyne-centimeters
+ - temperature = Kelvin
+ - pressure = dyne/cm^2 or barye = 1.0e-6 bars
+ - dynamic viscosity = Poise
+ - charge = statcoulombs or esu (4.8032044e-10 is a proton)
+ - dipole = statcoul-cm = 10^18 debye
+ - electric field = statvolt/cm or dyne/esu
+ - density = grams/cm^dim"""
+
+ style = "cgs"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.gram
+
+ @property
+ def distance(self):
+ return _units.cm
+
+ @property
+ def time(self):
+ return _units.second
+
+ @property
+ def energy(self):
+ return _units.ergs
+
+ @property
+ def velocity(self):
+ return _units.cm/_units.second
+
+ @property
+ def force(self):
+ return _units.dyne
+
+ @property
+ def torque(self):
+ return _units.dyne * _units.cm
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.dyne/_units.cm**2
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.Poise
+
+ @property
+ def charge(self):
+ return _units.statcoulomb
+
+ @property
+ def dipole(self):
+ return _units.statcoulomb * _units.cm
+
+ @property
+ def electric_field(self):
+ return _units.statvolt/_units.cm
+
+ @property
+ def density(self, dim=3):
+ return _units.gram/_units.cm**dim
+
+class electron(Units):
+ """For style electron, these are the units:
+ - mass = atomic mass units
+ - distance = Bohr
+ - time = femtoseconds
+ - energy = Hartrees
+ - velocity = Bohr/atomic time units [1.03275e-15 seconds]
+ - force = Hartrees/Bohr
+ - temperature = Kelvin
+ - pressure = Pascals
+ - charge = multiple of electron charge (1.0 is a proton)
+ - dipole moment = Debye
+ - electric field = volts/cm"""
+
+ style = "electron"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.atomicmass
+
+ @property
+ def distance(self):
+ return _units.Bohr
+
+ @property
+ def time(self):
+ return _units.femtosecond
+
+ @property
+ def energy(self):
+ return _units.Hartree
+
+ @property
+ def velocity(self):
+ return _units.Bohr / _units.atomictime
+
+ @property
+ def force(self):
+ return _units.Hartree / _units.Bohr
+
+ @property
+ def torque(self):
+ return _units.Hartree
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.Pascal
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.Poise
+
+ @property
+ def charge(self):
+ return _units.charge_e
+
+ @property
+ def dipole(self):
+ return _units.Debye
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.cm
+
+ @property
+ def density(self, dim=3):
+ return _units.gram / _units.cm**dim
+
+class micro(Units):
+ """For style micro, these are the units:
+ - mass = picograms
+ - distance = micrometers
+ - time = microseconds
+ - energy = picogram-micrometer^2/microsecond^2
+ - velocity = micrometers/microsecond
+ - force = picogram-micrometer/microsecond^2
+ - torque = picogram-micrometer^2/microsecond^2
+ - temperature = Kelvin
+ - pressure = picogram/(micrometer-microsecond^2)
+ - dynamic viscosity = picogram/(micrometer-microsecond)
+ - charge = picocoulombs (1.6021765e-7 is a proton)
+ - dipole = picocoulomb-micrometer
+ - electric field = volt/micrometer
+ - density = picograms/micrometer^dim"""
+
+ style = "micro"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.picogram
+
+ @property
+ def distance(self):
+ return _units.micrometer
+
+ @property
+ def time(self):
+ return _units.microsecond
+
+ @property
+ def energy(self):
+ return _units.picogram * _units.micrometer**2 / _units.microsecond**2
+
+ @property
+ def velocity(self):
+ return _units.micrometer / _units.microsecond
+
+ @property
+ def force(self):
+ return _units.picogram * _units.micrometer / _units.microsecond**2
+
+ @property
+ def torque(self):
+ return _units.picogram * _units.micrometer**2 / _units.microsecond**2
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.picogram / (_units.micrometer * _units.microsecond**2)
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.picogram / (_units.micrometer * _units.microsecond)
+
+ @property
+ def charge(self):
+ return _units.picocoulomb
+
+ @property
+ def dipole(self):
+ return _units.picocoulomb * _units.micrometer
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.micrometer
+
+ @property
+ def density(self, dim=3):
+ return _units.picogram / _units.micrometer**dim
+
+class nano(Units):
+ """For style nano, these are the units:
+ - mass = attograms
+ - distance = nanometers
+ - time = nanoseconds
+ - energy = attogram-nanometer^2/nanosecond^2
+ - velocity = nanometers/nanosecond
+ - force = attogram-nanometer/nanosecond^2
+ - torque = attogram-nanometer^2/nanosecond^2
+ - temperature = Kelvin
+ - pressure = attogram/(nanometer-nanosecond^2)
+ - dynamic viscosity = attogram/(nanometer-nanosecond)
+ - charge = multiple of electron charge (1.0 is a proton)
+ - dipole = charge-nanometer
+ - electric field = volt/nanometer
+ - density = attograms/nanometer^dim"""
+
+ style = "nano"
+
+ def __init__(self):
+ pass
+
+ @property
+ def mass(self):
+ return _units.attogram
+
+ @property
+ def distance(self):
+ return _units.nanometer
+
+ @property
+ def time(self):
+ return _units.nanometer
+
+ @property
+ def energy(self):
+ return _units.attogram * _units.nanometer**2 / _units.nanosecond**2
+
+ @property
+ def velocity(self):
+ return _units.nanometer / _units.nanosecond
+
+ @property
+ def force(self):
+ return _units.attogram * _units.nanometer / _units.nanosecond**2
+
+ @property
+ def torque(self):
+ return _units.attogram * _units.nanometer**2 / _units.nanosecond**2
+
+ @property
+ def temperature(self):
+ return _units.Kelvin
+
+ @property
+ def pressure(self):
+ return _units.attogram / (_units.nanometer * _units.nanosecond**2)
+
+ @property
+ def dynamic_viscosity(self):
+ return _units.attogram / (_units.nanometer * _units.nanosecond)
+
+ @property
+ def charge(self):
+ return _units.charge_e
+
+ @property
+ def dipole(self):
+ return _units.charge_e * _units.nanometer
+
+ @property
+ def electric_field(self):
+ return _units.volt / _units.nanometer
+
+ @property
+ def density(self, dim=3):
+ return _units.attogram / _units.nanometer**dim
+
+
+if __name__ == '__main__':
+
+ # u = lj()
+ # u.parse()
+ # print(u)
+ # print(u.info())
+
+ styles = ['lj', 'real', 'metal', 'si', 'cgs', 'electron', 'micro', 'nano']
+
+ for style in styles:
+ u = eval(style)()
+ print(u)
+ print(u.info())
+
diff --git a/parser/parser-lammps/LAMMPS/__init__.py b/parser/parser-lammps/LAMMPS/__init__.py
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/__init__.py
@@ -0,0 +1,2 @@
+
+
diff --git a/parser/parser-lammps/LAMMPS/data_file.py b/parser/parser-lammps/LAMMPS/data_file.py
new file mode 100644
index 0000000..4e9ca29
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/data_file.py
@@ -0,0 +1,122 @@
+import logging
+from collections import UserDict, OrderedDict
+from abc import ABCMeta
+import numpy as np
+
+# logging.basicConfig()
+logger = logging.getLogger(__name__)
+
+
+class AtomType(OrderedDict):
+ pass
+
+
+class Atoms:
+ def __init__(self):
+ self.data = []
+ self.atom_id = {}
+ self.molecule_id = {}
+
+ def add(self, id, values):
+ self.data.append(values)
+ self.atom_id[id] = values
+
+
+ # def __hash__(self):
+ # return hash(self.atom_id)
+
+
+class AtomStyle(metaclass=ABCMeta):
+ pass
+
+
+class AtomStyleFull(AtomStyle):
+ name = 'full'
+
+ # atom-ID molecule-ID atom-type q x y z
+ def __init__(self, tom_id, molecule_id, atom_type, q, x, y, z):
+ super(AtomStyleFull, self).__init__()
+
+ self.tom_id = tom_id
+ self.molecule_id = molecule_id
+ self.atom_type = atom_type
+ self.q = q
+ self.x = x
+ self.y = y
+ self.z = z
+
+
+ # @property
+ # def x(self):
+ # return self.x
+
+
+"""TODO
+filereader
+data numpy? dict? class?
+
+"""
+
+class DataFile(object):
+ def __init__(self, filename):
+ self.filereader = filename
+
+
+ @property
+ def filereader(self):
+ return self._filereader
+
+ @filereader.setter
+ def filereader(self, filename):
+ self._filereader = filename
+
+
+
+if __name__ == '__main__':
+
+ logger.info("Start Datafile module")
+ print("hello")
+
+ data = DataFile("data.methene")
+
+ a = Atoms()
+ a.add(1,[1,2,3])
+ a.add(2,[11,22,33])
+ print(a.data)
+ print(a.atom_id)
+
+ a.atom_id[1][2]=11111
+ print(a.data)
+ print(a.atom_id)
+
+
+ atom_type = AtomType()
+ atom_type[2] = {'mass': 1}
+ atom_type[1] = {'mass': 11}
+
+ print(atom_type)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ pass
diff --git a/parser/parser-lammps/LAMMPS/lammps.py b/parser/parser-lammps/LAMMPS/lammps.py
new file mode 100644
index 0000000..cde508f
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/lammps.py
@@ -0,0 +1,40 @@
+import LAMMPS.AtomStyle as Atom
+from LAMMPS.AtomStyle import atom_style
+from LAMMPS import Units
+from LAMMPS.BaseClasses import Lammps, AtomStyle
+
+
+class LAMMPS(Lammps):
+
+ def __init__(self):
+ self.atom_style = Atom.Atomic()
+ self.units = Units.lj()
+
+ @property
+ def atom_style(self):
+ return self.__atom_style
+
+ @atom_style.setter
+ def atom_style(self, atom_style):
+ if isinstance(atom_style, AtomStyle):
+ self.__atom_style = atom_style
+ else:
+ print("wrong")
+
+
+ def __str__(self):
+
+ ret_str = '\n'.join([
+ self._row_format.format('Program name:', 'LAMMPS'),
+ str(self.atom_style),
+ str(self.units)
+ ])
+
+ return ret_str
+
+
+if __name__ == '__main__':
+ l = LAMMPS()
+ l.atom_style = atom_style('bond')
+
+ print(l)
\ No newline at end of file
diff --git a/parser/parser-lammps/LAMMPS/read_data.py b/parser/parser-lammps/LAMMPS/read_data.py
new file mode 100644
index 0000000..68176d4
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/read_data.py
@@ -0,0 +1,94 @@
+from LAMMPS.BaseClasses import abstract_cmd, abstract_cmd_arg
+
+
+def read_data(filename, *args):
+ """Wrapper for read_data command"""
+
+
+ class add(abstract_cmd_arg):
+ """add arg = append or Nstart or merge
+ append = add new atoms with IDs appended to current IDs
+ Nstart = add new atoms with IDs starting with Nstart
+ merge = add new atoms with their IDs unchanged"""
+
+ def __init__(self, arg):
+ self.arg = arg
+
+ class offset(abstract_cmd_arg):
+ """offset args = toff boff aoff doff ioff
+ toff = offset to add to atom types
+ boff = offset to add to bond types
+ aoff = offset to add to angle types
+ doff = offset to add to dihedral types
+ ioff = offset to add to improper types"""
+
+ def __init__(self, toff, boff, aoff, doff, ioff):
+ self.toff = toff
+ self.boff = boff
+ self.aoff = aoff
+ self.doff = doff
+ self.ioff = ioff
+
+ class shift(abstract_cmd_arg):
+ """shift args = Sx Sy Sz
+ Sx,Sy,Sz = distance to shift atoms when adding to system (distance units)"""
+
+ def __init__(self, Sx, Sy, Sz):
+ self.Sx = Sx
+ self.Sy = Sy
+ self.Sz = Sz
+
+ class group(abstract_cmd_arg):
+ """group args = groupID
+ groupID = add atoms in data file to this group"""
+ def __init__(self, group_id):
+ self.group_id = group_id
+
+ class nocoeff(abstract_cmd_arg):
+ """nocoeff = ignore force field parameters"""
+
+ class fix(abstract_cmd_arg):
+ """fix args = fix-ID header-string section-string
+ fix-ID = ID of fix to process header lines and sections of data file
+ header-string = header lines containing this string will be passed to fix
+ section-string = section names with this string will be passed to fix"""
+
+ def __init__(self, id, header, section):
+ self.id = id
+ self.header = header
+ self.section = section
+
+
+ class extra_atom_types(abstract_cmd_arg):
+ """extra/atom/types arg = # of extra atom types"""
+ pass
+
+ class extra_bond_types(abstract_cmd_arg):
+ """extra/bond/types arg = # of extra bond types"""
+ pass
+
+ class extra_angle_types(abstract_cmd_arg):
+ """extra/angle/types arg = # of extra angle types"""
+ pass
+
+ class extra_dihedral_types(abstract_cmd_arg):
+ """extra/dihedral/types arg = # of extra dihedral types"""
+ pass
+
+ class extra_improper_types(abstract_cmd_arg):
+ """extra/improper/types arg = # of extra improper types"""
+ pass
+
+
+if __name__ == '__main__':
+
+ read_data('data.lj')
+ read_data('../run7/data.polymer.gz')
+ read_data('data.protein', 'fix', 'mycmap', 'crossterm' 'CMAP')
+ read_data('data.water', 'add', 'append', 'offset', 3, 1, 1, 1, 1, 'shift', 0.0, 0.0, 50.0)
+ # data = read_data('data.water')
+ # data.add('append')
+ # data.offset(3, 1, 1, 1, 1)
+ # data.shift( 0.0, 0.0, 50.0)
+
+ read_data('data.water', 'add', 'merge', 1, 'group', 'solvent')
diff --git a/parser/parser-lammps/LAMMPS/test_array_append.py b/parser/parser-lammps/LAMMPS/test_array_append.py
new file mode 100644
index 0000000..735a0bd
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/test_array_append.py
@@ -0,0 +1,78 @@
+import numpy as np
+
+class A:
+ def __init__(self):
+ self.data = np.array([])
+
+ def update(self, row):
+ self.data = np.append(self.data, row)
+
+ def finalize(self):
+ return np.reshape(self.data, newshape=(self.data.shape[0]/5, 5))
+
+
+
+class B:
+
+ def __init__(self):
+ self.data = []
+
+ def update(self, row):
+ for r in row:
+ self.data.append(r)
+
+ def finalize(self):
+ return np.reshape(self.data, newshape=(len(self.data)/5, 5))
+
+
+class C:
+
+ def __init__(self):
+ self.data = np.zeros((100,))
+ self.capacity = 100
+ self.size = 0
+
+ def update(self, row):
+ for r in row:
+ self.add(r)
+
+ def add(self, x):
+ if self.size == self.capacity:
+ self.capacity *= 4
+ newdata = np.zeros((self.capacity,))
+ newdata[:self.size] = self.data
+ self.data = newdata
+
+ self.data[self.size] = x
+ self.size += 1
+
+ def finalize(self):
+ data = self.data[:self.size]
+ return np.reshape(data, newshape=(len(data)/5, 5))
+
+
+
+if __name__ == '__main__':
+ from timeit import timeit
+ def test1():
+ x = A()
+ for i in range(10000):
+ x.update([i])
+
+
+ print(timeit(test1, number=1))
+
+ def test2():
+ x = B()
+ for i in range(10000):
+ x.update([i])
+
+ print(timeit(test2, number=1))
+
+ def test3():
+ x = C()
+ for i in range(10000):
+ x.update([i])
+
+ print(timeit(test3, number=1))
+
diff --git a/parser/parser-lammps/LAMMPS/test_atoms.py b/parser/parser-lammps/LAMMPS/test_atoms.py
new file mode 100644
index 0000000..09279ba
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/test_atoms.py
@@ -0,0 +1,32 @@
+import unittest
+
+class TestAtomStyles(unittest.TestCase):
+
+ def test_style_atomic(self):
+ style_atom = atom_style('atomic')
+ self.assertIsInstance(style_atom, atom_style)
+
+ def test_style_bond(self):
+ style_bond = atom_style('bond')
+ self.assertIsInstance(style_bond, atom_style)
+
+ def test_style_full(self):
+ style_full = atom_style('full')
+ self.assertIsInstance(style_full, atom_style)
+
+ def test_style_body(self):
+ style_body = atom_style('body', 'nparticle', 2, 10)
+ self.assertIsInstance(style_body, atom_style)
+
+ def test_style_hybrid(self):
+ style_hybrid = atom_style('hybrid', 'charge', 'bond')
+ self.assertIsInstance(style_hybrid, atom_style)
+
+ def test_style_hybrid(self):
+ style_hybrid = atom_style('hybrid', 'charge', 'body', 'nparticle', 2, 5)
+ self.assertIsInstance(style_hybrid, atom_style)
+
+ def test_style_template(self):
+ style_template = atom_style('template', 'myMols')
+ self.assertIsInstance(style_template, atom_style)
+
diff --git a/parser/parser-lammps/LAMMPS/variable.py b/parser/parser-lammps/LAMMPS/variable.py
new file mode 100644
index 0000000..3aa6d2a
--- /dev/null
+++ b/parser/parser-lammps/LAMMPS/variable.py
@@ -0,0 +1,132 @@
+from LAMMPS.BaseClasses import AbsVariable
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Variable(AbsVariable):
+ """Variables: This command assigns one or more strings to a variable name for evaluation later in the input script or during a simulation.
+ - name (string) can only contain alphanumeric characters and underscores
+ - value (“stringâ€) can be simple text, it can contain other variables, or it can be a formula.
+
+ equal-style variable VS internal-style variable
+
+ The variables can NOT be re-defined in an input script. There are two exceptions to this rule:
+ - First, variables of style string, getenv, internal, equal, vector, atom, and python ARE redefined each time the command is encountered.
+ - Second, as described below, if a variable is iterated on to the end of its list of strings via the next command, it is removed from the list of active variables, and is thus available to be re-defined in a subsequent variable command. The delete style does the same thing.
+
+ - the next command can be used to increment which string is assigned to the variable
+ - equal: store a formula which when evaluated produces a single numeric value
+ - vector: store a formula which produces a vector of such values
+ - atom: store a formula which when evaluated produces one numeric value per atom
+ - atomfile: can be used anywhere in an input script that atom-style variables are used; they get their per-atom values from a file rather than from a formula
+ - python: can be hooked to Python functions using code you provide, so that the variable gets its value from the evaluation of the Python code
+ - internal: are used by a few commands which set their value directly
+ """
+ names = {}
+
+ def __init__(self, *args, **kwargs):
+ pass
+
+ def parse(self, name, style, *args):
+ pass
+
+ def delete(self, name):
+ """delete = no args
+ :param name: name of variable to define
+ :return:
+ """
+ if name in self.names:
+ del self.names[name]
+
+
+ def index(self, name, args):
+ """index
+ :param name: name of variable to define
+ :param args: one or more strings
+ :return:
+ """
+ self.names[name] = args
+
+ def loop(self, name, *args):
+ """ loop args = N
+ N = integer size of loop, loop from 1 to N inclusive
+ loop args = N pad
+ N = integer size of loop, loop from 1 to N inclusive
+ pad = all values will be same length, e.g. 001, 002, ..., 100
+ loop args = N1 N2
+ N1,N2 = loop from N1 to N2 inclusive
+ loop args = N1 N2 pad
+ N1,N2 = loop from N1 to N2 inclusive
+ pad = all values will be same length, e.g. 050, 051, ..., 100
+ :param name: name of variable to define
+ :param N: integer size of loop, loop from 1 to N inclusive
+ """
+
+ if len(args) == 1:
+ self.names[name] = [x for x in range(1, N+1)]
+ elif len(args) == 2:
+ pass
+ elif len(args) == 3:
+ pass
+ else:
+ pass
+
+
+ def world(self, *args, **kwargs):
+ logger.warn("Variable style of {} is not supported yet.".format("word"))
+ pass
+
+ def universe(self, *args, **kwargs):
+ pass
+
+ def uloop(self, *args, **kwargs):
+ pass
+
+ def string(self, *args, **kwargs):
+ pass
+
+ def format(self, *args, **kwargs):
+ pass
+
+ def getenv(self, *args, **kwargs):
+ pass
+
+ def file(self, *args, **kwargs):
+ pass
+
+ def atomfile(self, *args, **kwargs):
+ pass
+
+ def python(self, *args, **kwargs):
+ pass
+
+ def equal(self, *args, **kwargs):
+ pass
+
+ def vector(self, *args, **kwargs):
+ pass
+
+ def atom(self, *args, **kwargs):
+ pass
+
+
+
+
+
+if __name__ == '__main__':
+ pass
+ v = Variable()
+
+ str="a b c"
+ v.index('a', str.split())
+
+ v.delete('a')
+
+ v.world('a')
+
+ # v.loop('b', 3)
+
+
+ logger.warn("Not supported yet.")
+ print(v.names)
--
GitLab