add separators

LMP_VAR_EQUAL = 0

LMP_VAR_ATOM  = 1

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

def get_ctypes_int(size):

  if size == 4:

    return c_int32

    return c_int64

  return c_int

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

class MPIAbortException(Exception):

  def __init__(self, message):

    self.message = message

  def __str__(self):

    return repr(self.message)

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

class NeighList:

    """This is a wrapper class that exposes the contents of a neighbor list.

        for ii in range(inum):

            yield self.get(ii)

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

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

class lammps(object):

  """Create an instance of the LAMMPS Python class.

  :type  comm: MPI_Comm

  """

  # create instance of LAMMPS

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

  # create an instance of LAMMPS

  def __init__(self,name='',cmdargs=None,ptr=None,comm=None):

    self.comm = comm

    self.lib.lammps_set_fix_external_callback.argtypes = [c_void_p, c_char_p, self.FIX_EXTERNAL_CALLBACK_FUNC, py_object]

    self.lib.lammps_set_fix_external_callback.restype = None

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

  # shut-down LAMMPS instance

  def __del__(self):

      self.lib.lammps_close(self.lmp)

      self.opened = 0

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

  @property

  def numpy(self):

    "Convert between ctypes arrays and numpy arrays"

      self._numpy = LammpsNumpyWrapper(self)

    return self._numpy

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

  def close(self):

    """Explicitly delete a LAMMPS instance through the C-library interface.

    self.lmp = None

    self.opened = 0

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

  def finalize(self):

    """Shut down the MPI communication through the library interface by calling :cpp:func:`lammps_finalize`.

    """

    self.opened = 0

    self.lib.lammps_finalize()

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

  def version(self):

    """Return a numerical representation of the LAMMPS version in use.

    """

    return self.lib.lammps_version(self.lmp)

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

  def file(self,file):

    """Read LAMMPS commands from a file.

    else: return

    self.lib.lammps_file(self.lmp,file)

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

  def command(self,cmd):

    """Process a single LAMMPS input command from a string.

        raise MPIAbortException(error_msg)

      raise Exception(error_msg)

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

  def commands_list(self,cmdlist):

    """Process multiple LAMMPS input commands from a list of strings.

    self.lib.lammps_commands_list.argtypes = [c_void_p, c_int, c_char_p * narg]

    self.lib.lammps_commands_list(self.lmp,narg,args)

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

  def commands_string(self,multicmd):

    """Process a block of LAMMPS input commands from a string.

    if type(multicmd) is str: multicmd = multicmd.encode()

    self.lib.lammps_commands_string(self.lmp,c_char_p(multicmd))

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

  def get_natoms(self):

    """Get the total number of atoms in the LAMMPS instance.

    """

    return self.lib.lammps_get_natoms(self.lmp)

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

  def extract_box(self):

    """Extract simulation box parameters

    return boxlo,boxhi,xy,yz,xz,periodicity,box_change

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

  def reset_box(self,boxlo,boxhi,xy,yz,xz):

    """Reset simulation box parameters

    cboxhi = (3*c_double)(*boxhi)

    self.lib.lammps_reset_box(self.lmp,cboxlo,cboxhi,xy,yz,xz)

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

  def get_thermo(self,name):

    """Get current value of a thermo keyword

    self.lib.lammps_get_thermo.restype = c_double

    return self.lib.lammps_get_thermo(self.lmp,name)

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

  def extract_setting(self, name):

    """Query LAMMPS about global settings that can be expressed as an integer.

    self.lib.lammps_extract_setting.restype = c_int

    return int(self.lib.lammps_extract_setting(self.lmp,name))

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

  # extract global info

  def extract_global(self, name, type):

    if ptr: return ptr[0]

    else: return None

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

  # extract per-atom info

  # NOTE: need to insure are converting to/from correct Python type

  #   e.g. for Python list or NumPy or ctypes

    else:   return None

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

  def extract_compute(self,id,style,type):

    """Retrieve data from a LAMMPS compute

    return None

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

  # extract fix info

  # in case of global data, free memory for 1 double via lammps_free()

  # double was allocated by library interface function

    else:

      return None

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

  # extract variable info

  # free memory for 1 double or 1 vector of doubles via lammps_free()

  # for vector, must copy nlocal returned values to local c_double vector

      return result

    return None

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

  def set_variable(self,name,value):

    """Set a new value for a LAMMPS string style variable

    else: return -1

    return self.lib.lammps_set_variable(self.lmp,name,value)

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

  # return vector of atom properties gathered across procs

  # 3 variants to match src/library.cpp

  # name = atom property recognized by LAMMPS in atom->extract()

    else: return None

    return data

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

  def gather_atoms_concat(self,name,type,count):

    if name: name = name.encode()

    natoms = self.lib.lammps_get_natoms(self.lmp)

    else: return None

    return data

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

  # scatter vector of atom properties across procs

  # 2 variants to match src/library.cpp

  # name = atom property recognized by LAMMPS in atom->extract()

    if name: name = name.encode()

    self.lib.lammps_scatter_atoms(self.lmp,name,type,count,data)

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

  def scatter_atoms_subset(self,name,type,count,ndata,ids,data):

    if name: name = name.encode()

    self.lib.lammps_scatter_atoms_subset(self.lmp,name,type,count,ndata,ids,data)

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

  def encode_image_flags(self,ix,iy,iz):

    """ convert 3 integers with image flags for x-, y-, and z-direction

    into a single integer like it is used internally in LAMMPS

    self.lib.lammps_encode_image_flags.restype = self.c_imageint

    return self.lib.lammps_encode_image_flags(ix,iy,iz)

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

  def decode_image_flags(self,image):

    """ Convert encoded image flag integer into list of three regular integers.

    return [int(i) for i in flags]

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

  # create N atoms on all procs

  # N = global number of atoms

  # id = ID of each atom (optional, can be None)

                                     POINTER(self.c_imageint*n), c_int]

    return self.lib.lammps_create_atoms(self.lmp,n,id_lmp,type_lmp,x_lmp,v_lmp,img_lmp,se_lmp)

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

  @property

  def has_mpi_support(self):

    """ Report whether the LAMMPS shared library was compiled with a

    """

    return self.lib.lammps_config_has_mpi_support() != 0

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

  @property

  def has_exceptions(self):

    """ Report whether the LAMMPS shared library was compiled with C++

    """

    return self.lib.lammps_config_has_exceptions() != 0

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

  @property

  def has_gzip_support(self):

    """ Report whether the LAMMPS shared library was compiled with support

    """

    return self.lib.lammps_config_has_gzip_support() != 0

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

  @property

  def has_png_support(self):

    """ Report whether the LAMMPS shared library was compiled with support

    """

    return self.lib.lammps_config_has_png_support() != 0

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

  @property

  def has_jpeg_support(self):

    """ Report whether the LAMMPS shared library was compiled with support

    """

    return self.lib.lammps_config_has_jpeg_support() != 0

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

  @property

  def has_ffmpeg_support(self):

    """ State of support for writing movies with ``ffmpeg`` in the LAMMPS shared library

    """

    return self.lib.lammps_config_has_ffmpeg_support() != 0

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

  @property

  def installed_packages(self):

    """ List of the names of enabled packages in the LAMMPS shared library

        self._installed_packages.append(sb.value.decode())

    return self._installed_packages

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

  def has_style(self, category, name):

    """Returns whether a given style name is available in a given category

    """

    return self.lib.lammps_has_style(self.lmp, category.encode(), name.encode()) != 0

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

  def available_styles(self, category):

    """Returns a list of styles available for a given category

        self._available_styles[category].append(sb.value.decode())

    return self._available_styles[category]

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

  def set_fix_external_callback(self, fix_name, callback, caller=None):

    import numpy as np

    def _ctype_to_numpy_int(ctype_int):

          if ctype_int == c_int32:

            return np.int32

    self.callback[fix_name] = { 'function': cFunc, 'caller': caller }

    self.lib.lammps_set_fix_external_callback(self.lmp, fix_name.encode(), cFunc, cCaller)

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

  def get_neighlist(self, idx):

    """Returns an instance of :class:`NeighList` which wraps access to the neighbor list with the given index

        return None

    return NeighList(self, idx)

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

  def find_pair_neighlist(self, style, exact=True, nsub=0, request=0):

    """Find neighbor list index of pair style neighbor list

    idx = self.lib.lammps_find_pair_neighlist(self.lmp, style, exact, nsub, request)

    return self.get_neighlist(idx)

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

  def find_fix_neighlist(self, fixid, request=0):

    """Find neighbor list index of fix neighbor list

    idx = self.lib.lammps_find_fix_neighlist(self.lmp, fixid, request)

    return self.get_neighlist(idx)

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

  def find_compute_neighlist(self, computeid, request=0):

    """Find neighbor list index of compute neighbor list

    idx = self.lib.lammps_find_compute_neighlist(self.lmp, computeid, request)

    return self.get_neighlist(idx)

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

  def get_neighlist_size(self, idx):

    """Return the number of elements in neighbor list with the given index

     """

    return self.lib.lammps_neighlist_num_elements(self.lmp, idx)

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

  def get_neighlist_element_neighbors(self, idx, element):

    """Return data of neighbor list entry

  def output(self):

    return self.read_pipe(self.stdout_pipe_read)

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

class Variable(object):

  def __init__(self, lammps_wrapper_instance, name, style, definition):

      except ValueError:

        return value

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

class AtomList(object):

  def __init__(self, lammps_wrapper_instance):

        return Atom2D(self.lmp, index + 1)

    return Atom(self.lmp, index + 1)

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

class Atom(object):

  def __init__(self, lammps_wrapper_instance, index):

  def charge(self):

    return self.lmp.eval("q[%d]" % self.index)

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

class Atom2D(Atom):

  def __init__(self, lammps_wrapper_instance, index):

    return (self.lmp.eval("fx[%d]" % self.index),

            self.lmp.eval("fy[%d]" % self.index))

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

class variable_set:

    def __init__(self, name, variable_dict):

    def __repr__(self):

        return self.__str__()

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

def get_thermo_data(output):

    """ traverse output of runs and extract thermo data columns """

    return runs

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

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

class PyLammps(object):

  """

  More Python-like wrapper for LAMMPS (e.g., for IPython)