rmf/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.


# This wrapper is part of IMP,
# Copyright 2007-2024 IMP Inventors. All rights reserved.




from sys import version_info as _swig_python_version_info
import _IMP_rmf

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IMP_RMF_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_RMF_SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_rmf.delete_IMP_RMF_SwigPyIterator

    def value(self):
        r"""value(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_RMF_SwigPyIterator self, size_t n=1) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_RMF_SwigPyIterator self, size_t n=1) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_RMF_SwigPyIterator self) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator
        __sub__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_rmf.IMP_RMF_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_RMF_SwigPyIterator in _IMP_rmf:
_IMP_rmf.IMP_RMF_SwigPyIterator_swigregister(IMP_RMF_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_DEBUG = _IMP_rmf.IMP_DEBUG

IMP_RELEASE = _IMP_rmf.IMP_RELEASE

IMP_SILENT = _IMP_rmf.IMP_SILENT

IMP_PROGRESS = _IMP_rmf.IMP_PROGRESS

IMP_TERSE = _IMP_rmf.IMP_TERSE

IMP_VERBOSE = _IMP_rmf.IMP_VERBOSE

IMP_MEMORY = _IMP_rmf.IMP_MEMORY

IMP_NONE = _IMP_rmf.IMP_NONE

IMP_USAGE = _IMP_rmf.IMP_USAGE

IMP_INTERNAL = _IMP_rmf.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_rmf.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_rmf.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_rmf.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_rmf.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_rmf.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_rmf.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_rmf.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_rmf.IMPKERNEL_SHOW_WARNINGS


import sys
class _DirectorObjects:
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
# Do in two steps so the references are kept until the end of the
# function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    r"""Proxy of C++ std::ostream class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_rmf._ostream_write(self, osa_buf)

# Register _ostream in _IMP_rmf:
_IMP_rmf._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_rmf.IMP_C_OPEN_BINARY

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_rmf.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_rmf.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_rmf.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_rmf.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_rmf.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_rmf.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_rmf.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_rmf.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_rmf.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_rmf.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_STATISTICS_HAS_BOOST_SYSTEM

IMP_STATISTICS_HAS_CGAL = _IMP_rmf.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_rmf.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_rmf.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_rmf.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_rmf.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_rmf.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_rmf.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_rmf.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_rmf.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_rmf.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_rmf.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_SYSTEM

IMP_CONTAINER_HAS_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_rmf.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_rmf.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_rmf.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_rmf.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_rmf.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_rmf.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_rmf.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_rmf.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_rmf.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ATOM_HAS_BOOST_SYSTEM

IMP_ATOM_HAS_CGAL = _IMP_rmf.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_rmf.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_rmf.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_rmf.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_rmf.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_rmf.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_rmf.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_rmf.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_rmf.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_rmf.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_rmf.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_rmf.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_rmf.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_rmf.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_EM_HAS_BOOST_SYSTEM

IMP_EM_HAS_CGAL = _IMP_rmf.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_rmf.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_rmf.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_rmf.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_rmf.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_rmf.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_rmf.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_rmf.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_rmf.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_rmf.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_rmf.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_rmf.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_rmf.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_rmf.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_rmf.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_rmf.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_rmf.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_rmf.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_rmf.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ISD_HAS_BOOST_SYSTEM

IMP_ISD_HAS_CGAL = _IMP_rmf.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_rmf.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_rmf.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_rmf.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_rmf.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_RMF_HAS_IMP_CGAL = _IMP_rmf.IMP_RMF_HAS_IMP_CGAL

IMP_RMF_HAS_IMP_EM = _IMP_rmf.IMP_RMF_HAS_IMP_EM

IMP_RMF_HAS_IMP_SAXS = _IMP_rmf.IMP_RMF_HAS_IMP_SAXS

IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

IMP_RMF_HAS_IMP_STATISTICS = _IMP_rmf.IMP_RMF_HAS_IMP_STATISTICS

IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_FILESYSTEM

IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS

IMP_RMF_HAS_BOOST_RANDOM = _IMP_rmf.IMP_RMF_HAS_BOOST_RANDOM

IMP_RMF_HAS_BOOST_REGEX = _IMP_rmf.IMP_RMF_HAS_BOOST_REGEX

IMP_RMF_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_SYSTEM

IMP_RMF_HAS_CGAL = _IMP_rmf.IMP_RMF_HAS_CGAL

IMP_RMF_HAS_HDF5 = _IMP_rmf.IMP_RMF_HAS_HDF5

IMP_RMF_HAS_NUMPY = _IMP_rmf.IMP_RMF_HAS_NUMPY

IMP_RMF_HAS_PYTHON_IHM = _IMP_rmf.IMP_RMF_HAS_PYTHON_IHM

IMPRMF_SHOW_WARNINGS = _IMP_rmf.IMPRMF_SHOW_WARNINGS

import RMF

_object_types.append("SaveOptimizerState")


def _object_cast_to_SaveOptimizerState(o):
    r"""_object_cast_to_SaveOptimizerState(Object o) -> SaveOptimizerState"""
    return _IMP_rmf._object_cast_to_SaveOptimizerState(o)

_object_types.append("LoadLink")


def _object_cast_to_LoadLink(o):
    r"""_object_cast_to_LoadLink(Object o) -> LoadLink"""
    return _IMP_rmf._object_cast_to_LoadLink(o)

_object_types.append("SaveLink")


def _object_cast_to_SaveLink(o):
    r"""_object_cast_to_SaveLink(Object o) -> SaveLink"""
    return _IMP_rmf._object_cast_to_SaveLink(o)

_object_types.append("HierarchySaveLink")


def _object_cast_to_HierarchySaveLink(o):
    r"""_object_cast_to_HierarchySaveLink(Object o) -> HierarchySaveLink"""
    return _IMP_rmf._object_cast_to_HierarchySaveLink(o)

_object_types.append("HierarchyLoadLink")


def _object_cast_to_HierarchyLoadLink(o):
    r"""_object_cast_to_HierarchyLoadLink(Object o) -> HierarchyLoadLink"""
    return _IMP_rmf._object_cast_to_HierarchyLoadLink(o)
class LoadLink(IMP.Object):
    r"""Proxy of C++ IMP::rmf::LoadLink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def do_load(self, fh):
        r"""do_load(LoadLink self, FileConstHandle fh)"""
        return _IMP_rmf.LoadLink_do_load(self, fh)

    def __init__(self, name):
        r"""__init__(LoadLink self, std::string name) -> LoadLink"""
        if self.__class__ == LoadLink:
            _self = None
        else:
            _self = self
        _IMP_rmf.LoadLink_swiginit(self, _IMP_rmf.new_LoadLink(_self, name))

        if self.__class__ != LoadLink:
            _director_objects.register(self)




    def load(self, fh):
        r"""load(LoadLink self, FileConstHandle fh)"""
        return _IMP_rmf.LoadLink_load(self, fh)
    __swig_destroy__ = _IMP_rmf.delete_LoadLink

    def __str__(self):
        r"""__str__(LoadLink self) -> std::string"""
        return _IMP_rmf.LoadLink___str__(self)

    def __repr__(self):
        r"""__repr__(LoadLink self) -> std::string"""
        return _IMP_rmf.LoadLink___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_LoadLink(o)


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::rmf" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_LoadLink(o)

    def __disown__(self):
        self.this.disown()
        _IMP_rmf.disown_LoadLink(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(LoadLink self)"""
        return _IMP_rmf.LoadLink_do_destroy(self)

# Register LoadLink in _IMP_rmf:
_IMP_rmf.LoadLink_swigregister(LoadLink)
class SaveLink(IMP.Object):
    r"""Proxy of C++ IMP::rmf::SaveLink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def do_save(self, hf):
        r"""do_save(SaveLink self, FileHandle hf)"""
        return _IMP_rmf.SaveLink_do_save(self, hf)

    def __init__(self, name):
        r"""__init__(SaveLink self, std::string name) -> SaveLink"""
        if self.__class__ == SaveLink:
            _self = None
        else:
            _self = self
        _IMP_rmf.SaveLink_swiginit(self, _IMP_rmf.new_SaveLink(_self, name))

        if self.__class__ != SaveLink:
            _director_objects.register(self)




    def save(self, fh):
        r"""save(SaveLink self, FileHandle fh)"""
        return _IMP_rmf.SaveLink_save(self, fh)
    __swig_destroy__ = _IMP_rmf.delete_SaveLink

    def __str__(self):
        r"""__str__(SaveLink self) -> std::string"""
        return _IMP_rmf.SaveLink___str__(self)

    def __repr__(self):
        r"""__repr__(SaveLink self) -> std::string"""
        return _IMP_rmf.SaveLink___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_SaveLink(o)


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::rmf" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SaveLink(o)

    def __disown__(self):
        self.this.disown()
        _IMP_rmf.disown_SaveLink(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(SaveLink self)"""
        return _IMP_rmf.SaveLink_do_destroy(self)

# Register SaveLink in _IMP_rmf:
_IMP_rmf.SaveLink_swigregister(SaveLink)

def add_hierarchies(*args):
    r"""
    add_hierarchies(FileHandle fh, IMP::atom::Hierarchies const & hs)
    add_hierarchies(NodeHandle fh, IMP::atom::Hierarchies const & hs)
    """
    return _IMP_rmf.add_hierarchies(*args)

def add_hierarchy(fh, hs):
    r"""add_hierarchy(FileHandle fh, Hierarchy hs)"""
    return _IMP_rmf.add_hierarchy(fh, hs)

def create_hierarchies(fh, m):
    r"""create_hierarchies(FileConstHandle fh, Model m) -> IMP::atom::Hierarchies"""
    return _IMP_rmf.create_hierarchies(fh, m)

def link_hierarchies(fh, hs):
    r"""link_hierarchies(FileConstHandle fh, IMP::atom::Hierarchies const & hs)"""
    return _IMP_rmf.link_hierarchies(fh, hs)

def add_restraints(*args):
    r"""
    add_restraints(FileHandle fh, IMP::Restraints const & hs)
    add_restraints(NodeHandle fh, IMP::Restraints const & hs)
    """
    return _IMP_rmf.add_restraints(*args)

def add_restraint(fh, hs):
    r"""add_restraint(FileHandle fh, Restraint hs)"""
    return _IMP_rmf.add_restraint(fh, hs)

def create_restraints(fh, m):
    r"""create_restraints(FileConstHandle fh, Model m) -> IMP::Restraints"""
    return _IMP_rmf.create_restraints(fh, m)

def link_restraints(fh, hs):
    r"""link_restraints(FileConstHandle fh, IMP::Restraints const & hs)"""
    return _IMP_rmf.link_restraints(fh, hs)

def add_restraints_as_bonds(fh, rs):
    r"""add_restraints_as_bonds(FileHandle fh, IMP::Restraints const & rs)"""
    return _IMP_rmf.add_restraints_as_bonds(fh, rs)

def set_maximum_number_of_terms(fh, num):
    r"""set_maximum_number_of_terms(FileHandle fh, unsigned int num)"""
    return _IMP_rmf.set_maximum_number_of_terms(fh, num)

def add_particles(*args):
    r"""
    add_particles(FileHandle fh, IMP::ParticlesTemp const & hs)
    add_particles(NodeHandle fh, IMP::ParticlesTemp const & hs)
    """
    return _IMP_rmf.add_particles(*args)

def add_particle(fh, hs):
    r"""add_particle(FileHandle fh, Particle hs)"""
    return _IMP_rmf.add_particle(fh, hs)

def create_particles(fh, m):
    r"""create_particles(FileConstHandle fh, Model m) -> IMP::ParticlesTemp"""
    return _IMP_rmf.create_particles(fh, m)

def link_particles(fh, hs):
    r"""link_particles(FileConstHandle fh, IMP::ParticlesTemp const & hs)"""
    return _IMP_rmf.link_particles(fh, hs)

def add_geometries(*args):
    r"""
    add_geometries(FileHandle file, IMP::display::GeometriesTemp const & r)
    add_geometries(NodeHandle parent, IMP::display::GeometriesTemp const & r)
    """
    return _IMP_rmf.add_geometries(*args)

def add_static_geometries(parent, r):
    r"""add_static_geometries(FileHandle parent, IMP::display::GeometriesTemp const & r)"""
    return _IMP_rmf.add_static_geometries(parent, r)

def add_geometry(file, r):
    r"""add_geometry(FileHandle file, Geometry r)"""
    return _IMP_rmf.add_geometry(file, r)

def create_geometries(parent):
    r"""create_geometries(FileConstHandle parent) -> IMP::display::Geometries"""
    return _IMP_rmf.create_geometries(parent)

def link_geometries(parent, r):
    r"""link_geometries(FileConstHandle parent, IMP::display::GeometriesTemp const & r)"""
    return _IMP_rmf.link_geometries(parent, r)

def set_association(nh, o, overwrite=False):
    r"""set_association(NodeConstHandle nh, Object o, bool overwrite=False)"""
    return _IMP_rmf.set_association(nh, o, overwrite)

def get_node_from_association(*args):
    r"""
    get_node_from_association(FileConstHandle nh, Object oi) -> NodeConstHandle
    get_node_from_association(FileHandle nh, Object oi) -> NodeHandle
    """
    return _IMP_rmf.get_node_from_association(*args)

def get_has_associated_node(nh, oi):
    r"""get_has_associated_node(FileConstHandle nh, Object oi) -> bool"""
    return _IMP_rmf.get_has_associated_node(nh, oi)
class SaveOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::rmf::SaveOptimizerState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, m, fh):
        r"""__init__(SaveOptimizerState self, Model m, FileHandle fh) -> SaveOptimizerState"""
        _IMP_rmf.SaveOptimizerState_swiginit(self, _IMP_rmf.new_SaveOptimizerState(m, fh))
    def __get_hierarchies(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_hierarchies,  getfunc=self.get_hierarchy, erasefunc=self.erase_hierarchy,  appendfunc=self.add_hierarchy, extendfunc=self.add_hierarchies,  clearfunc=self.clear_hierarchies, indexfunc=self._python_index_hierarchy)  
    def __set_hierarchies(self, obj): IMP._list_util.set_varlist(self.hierarchies, obj)  
    def __del_hierarchies(self): IMP._list_util.del_varlist(self.hierarchies)       
    hierarchies = property(__get_hierarchies, __set_hierarchies, __del_hierarchies, doc="List of ##ucnames")  

    def remove_hierarchy(self, d):
        r"""remove_hierarchy(SaveOptimizerState self, Particle d)"""
        return _IMP_rmf.SaveOptimizerState_remove_hierarchy(self, d)

    def _python_index_hierarchy(self, d, start, stop):
        r"""_python_index_hierarchy(SaveOptimizerState self, Particle d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState__python_index_hierarchy(self, d, start, stop)

    def remove_hierarchies(self, d):
        r"""remove_hierarchies(SaveOptimizerState self, IMP::Particles const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_hierarchies(self, d)

    def set_hierarchies(self, ps):
        r"""set_hierarchies(SaveOptimizerState self, IMP::Particles const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_hierarchies(self, ps)

    def set_hierarchies_order(self, objs):
        r"""set_hierarchies_order(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_hierarchies_order(self, objs)

    def add_hierarchy(self, obj):
        r"""add_hierarchy(SaveOptimizerState self, Particle obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_hierarchy(self, obj)

    def add_hierarchies(self, objs):
        r"""add_hierarchies(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_hierarchies(self, objs)

    def clear_hierarchies(self):
        r"""clear_hierarchies(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_hierarchies(self)

    def get_number_of_hierarchies(self):
        r"""get_number_of_hierarchies(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_hierarchies(self)

    def get_has_hierarchies(self):
        r"""get_has_hierarchies(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_hierarchies(self)

    def get_hierarchy(self, i):
        r"""get_hierarchy(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_hierarchy(self, i)

    def get_hierarchies(self):
        r"""get_hierarchies(SaveOptimizerState self) -> IMP::Particles"""
        return _IMP_rmf.SaveOptimizerState_get_hierarchies(self)

    def erase_hierarchy(self, i):
        r"""erase_hierarchy(SaveOptimizerState self, unsigned int i)"""
        return _IMP_rmf.SaveOptimizerState_erase_hierarchy(self, i)

    def reserve_hierarchies(self, sz):
        r"""reserve_hierarchies(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_hierarchies(self, sz)
    def __get_restraints(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_restraints,  getfunc=self.get_restraint, erasefunc=self.erase_restraint,  appendfunc=self.add_restraint, extendfunc=self.add_restraints,  clearfunc=self.clear_restraints, indexfunc=self._python_index_restraint)  
    def __set_restraints(self, obj): IMP._list_util.set_varlist(self.restraints, obj)  
    def __del_restraints(self): IMP._list_util.del_varlist(self.restraints)       
    restraints = property(__get_restraints, __set_restraints, __del_restraints, doc="List of ##ucnames")  

    def remove_restraint(self, d):
        r"""remove_restraint(SaveOptimizerState self, Restraint d)"""
        return _IMP_rmf.SaveOptimizerState_remove_restraint(self, d)

    def _python_index_restraint(self, d, start, stop):
        r"""_python_index_restraint(SaveOptimizerState self, Restraint d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState__python_index_restraint(self, d, start, stop)

    def remove_restraints(self, d):
        r"""remove_restraints(SaveOptimizerState self, IMP::Restraints const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_restraints(self, d)

    def set_restraints(self, ps):
        r"""set_restraints(SaveOptimizerState self, IMP::Restraints const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_restraints(self, ps)

    def set_restraints_order(self, objs):
        r"""set_restraints_order(SaveOptimizerState self, IMP::Restraints const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_restraints_order(self, objs)

    def add_restraint(self, obj):
        r"""add_restraint(SaveOptimizerState self, Restraint obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_restraint(self, obj)

    def add_restraints(self, objs):
        r"""add_restraints(SaveOptimizerState self, IMP::Restraints const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_restraints(self, objs)

    def clear_restraints(self):
        r"""clear_restraints(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_restraints(self)

    def get_number_of_restraints(self):
        r"""get_number_of_restraints(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_restraints(self)

    def get_has_restraints(self):
        r"""get_has_restraints(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_restraints(self)

    def get_restraint(self, i):
        r"""get_restraint(SaveOptimizerState self, unsigned int i) -> Restraint"""
        return _IMP_rmf.SaveOptimizerState_get_restraint(self, i)

    def get_restraints(self):
        r"""get_restraints(SaveOptimizerState self) -> IMP::Restraints"""
        return _IMP_rmf.SaveOptimizerState_get_restraints(self)

    def erase_restraint(self, i):
        r"""erase_restraint(SaveOptimizerState self, unsigned int i)"""
        return _IMP_rmf.SaveOptimizerState_erase_restraint(self, i)

    def reserve_restraints(self, sz):
        r"""reserve_restraints(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_restraints(self, sz)
    def __get_particles(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_particles,  getfunc=self.get_particle, erasefunc=self.erase_particle,  appendfunc=self.add_particle, extendfunc=self.add_particles,  clearfunc=self.clear_particles, indexfunc=self._python_index_particle)  
    def __set_particles(self, obj): IMP._list_util.set_varlist(self.particles, obj)  
    def __del_particles(self): IMP._list_util.del_varlist(self.particles)       
    particles = property(__get_particles, __set_particles, __del_particles, doc="List of ##ucnames")  

    def remove_particle(self, d):
        r"""remove_particle(SaveOptimizerState self, Particle d)"""
        return _IMP_rmf.SaveOptimizerState_remove_particle(self, d)

    def _python_index_particle(self, d, start, stop):
        r"""_python_index_particle(SaveOptimizerState self, Particle d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState__python_index_particle(self, d, start, stop)

    def remove_particles(self, d):
        r"""remove_particles(SaveOptimizerState self, IMP::Particles const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_particles(self, d)

    def set_particles(self, ps):
        r"""set_particles(SaveOptimizerState self, IMP::Particles const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_particles(self, ps)

    def set_particles_order(self, objs):
        r"""set_particles_order(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_particles_order(self, objs)

    def add_particle(self, obj):
        r"""add_particle(SaveOptimizerState self, Particle obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_particle(self, obj)

    def add_particles(self, objs):
        r"""add_particles(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_particles(self, objs)

    def clear_particles(self):
        r"""clear_particles(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_particles(self)

    def get_number_of_particles(self):
        r"""get_number_of_particles(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_particles(self)

    def get_has_particles(self):
        r"""get_has_particles(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_particles(self)

    def get_particle(self, i):
        r"""get_particle(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_particle(self, i)

    def get_particles(self):
        r"""get_particles(SaveOptimizerState self) -> IMP::Particles"""
        return _IMP_rmf.SaveOptimizerState_get_particles(self)

    def erase_particle(self, i):
        r"""erase_particle(SaveOptimizerState self, unsigned int i)"""
        return _IMP_rmf.SaveOptimizerState_erase_particle(self, i)

    def reserve_particles(self, sz):
        r"""reserve_particles(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_particles(self, sz)
    def __get_geometries(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_geometries,  getfunc=self.get_geometry, erasefunc=self.erase_geometry,  appendfunc=self.add_geometry, extendfunc=self.add_geometries,  clearfunc=self.clear_geometries, indexfunc=self._python_index_geometry)  
    def __set_geometries(self, obj): IMP._list_util.set_varlist(self.geometries, obj)  
    def __del_geometries(self): IMP._list_util.del_varlist(self.geometries)       
    geometries = property(__get_geometries, __set_geometries, __del_geometries, doc="List of ##ucnames")  

    def remove_geometry(self, d):
        r"""remove_geometry(SaveOptimizerState self, Geometry d)"""
        return _IMP_rmf.SaveOptimizerState_remove_geometry(self, d)

    def _python_index_geometry(self, d, start, stop):
        r"""_python_index_geometry(SaveOptimizerState self, Geometry d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState__python_index_geometry(self, d, start, stop)

    def remove_geometries(self, d):
        r"""remove_geometries(SaveOptimizerState self, IMP::display::Geometries const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_geometries(self, d)

    def set_geometries(self, ps):
        r"""set_geometries(SaveOptimizerState self, IMP::display::Geometries const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_geometries(self, ps)

    def set_geometries_order(self, objs):
        r"""set_geometries_order(SaveOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_geometries_order(self, objs)

    def add_geometry(self, obj):
        r"""add_geometry(SaveOptimizerState self, Geometry obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_geometry(self, obj)

    def add_geometries(self, objs):
        r"""add_geometries(SaveOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_geometries(self, objs)

    def clear_geometries(self):
        r"""clear_geometries(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_geometries(self)

    def get_number_of_geometries(self):
        r"""get_number_of_geometries(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_geometries(self)

    def get_has_geometries(self):
        r"""get_has_geometries(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_geometries(self)

    def get_geometry(self, i):
        r"""get_geometry(SaveOptimizerState self, unsigned int i) -> Geometry"""
        return _IMP_rmf.SaveOptimizerState_get_geometry(self, i)

    def get_geometries(self):
        r"""get_geometries(SaveOptimizerState self) -> IMP::display::Geometries"""
        return _IMP_rmf.SaveOptimizerState_get_geometries(self)

    def erase_geometry(self, i):
        r"""erase_geometry(SaveOptimizerState self, unsigned int i)"""
        return _IMP_rmf.SaveOptimizerState_erase_geometry(self, i)

    def reserve_geometries(self, sz):
        r"""reserve_geometries(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_geometries(self, sz)

    def set_simulator(self, sim):
        r"""set_simulator(SaveOptimizerState self, Simulator sim)"""
        return _IMP_rmf.SaveOptimizerState_set_simulator(self, sim)

    def update_always(self, *args):
        r"""
        update_always(SaveOptimizerState self, std::string name)
        update_always(SaveOptimizerState self)
        """
        return _IMP_rmf.SaveOptimizerState_update_always(self, *args)

    def do_update(self, call_num):
        r"""do_update(SaveOptimizerState self, unsigned int call_num)"""
        return _IMP_rmf.SaveOptimizerState_do_update(self, call_num)

    def get_version_info(self):
        r"""get_version_info(SaveOptimizerState self) -> VersionInfo"""
        return _IMP_rmf.SaveOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_rmf.delete_SaveOptimizerState

    def __str__(self):
        r"""__str__(SaveOptimizerState self) -> std::string"""
        return _IMP_rmf.SaveOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(SaveOptimizerState self) -> std::string"""
        return _IMP_rmf.SaveOptimizerState___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_SaveOptimizerState(o)


# Register SaveOptimizerState in _IMP_rmf:
_IMP_rmf.SaveOptimizerState_swigregister(SaveOptimizerState)

def load_frame(file, frame):
    r"""load_frame(FileConstHandle file, FrameID frame)"""
    return _IMP_rmf.load_frame(file, frame)

def save_frame(*args):
    r"""save_frame(FileHandle file, std::string name="") -> FrameID"""
    return _IMP_rmf.save_frame(*args)
class _ParticleSaveLink(SaveLink):
    r"""Proxy of C++ IMP::rmf::SimpleSaveLink< IMP::Particle > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def add(self, parent, os):
        r"""add(_ParticleSaveLink self, NodeHandle parent, IMP::Vector< Pointer< IMP::Particle > > const & os)"""
        return _IMP_rmf._ParticleSaveLink_add(self, parent, os)
    __swig_destroy__ = _IMP_rmf.delete__ParticleSaveLink

# Register _ParticleSaveLink in _IMP_rmf:
_IMP_rmf._ParticleSaveLink_swigregister(_ParticleSaveLink)
class _ParticleLoadLink(LoadLink):
    r"""Proxy of C++ IMP::rmf::SimpleLoadLink< IMP::Particle > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def create(self, *args):
        r"""
        create(_ParticleLoadLink self, NodeConstHandle rt) -> IMP::Vector< Pointer< IMP::Particle > >
        create(_ParticleLoadLink self, NodeConstHandle rt, Model m) -> IMP::Vector< Pointer< IMP::Particle > >
        """
        return _IMP_rmf._ParticleLoadLink_create(self, *args)

    def link(self, rt, ps):
        r"""link(_ParticleLoadLink self, NodeConstHandle rt, IMP::Vector< Pointer< IMP::Particle > > const & ps)"""
        return _IMP_rmf._ParticleLoadLink_link(self, rt, ps)
    __swig_destroy__ = _IMP_rmf.delete__ParticleLoadLink

# Register _ParticleLoadLink in _IMP_rmf:
_IMP_rmf._ParticleLoadLink_swigregister(_ParticleLoadLink)
class HierarchyLoadLink(_ParticleLoadLink):
    r"""Proxy of C++ IMP::rmf::HierarchyLoadLink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, fh):
        r"""__init__(HierarchyLoadLink self, FileConstHandle fh) -> HierarchyLoadLink"""
        _IMP_rmf.HierarchyLoadLink_swiginit(self, _IMP_rmf.new_HierarchyLoadLink(fh))

    @staticmethod
    def get_name():
        r"""get_name() -> char const *"""
        return _IMP_rmf.HierarchyLoadLink_get_name()

    def get_version_info(self):
        r"""get_version_info(HierarchyLoadLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchyLoadLink_get_version_info(self)
    __swig_destroy__ = _IMP_rmf.delete_HierarchyLoadLink

    def __str__(self):
        r"""__str__(HierarchyLoadLink self) -> std::string"""
        return _IMP_rmf.HierarchyLoadLink___str__(self)

    def __repr__(self):
        r"""__repr__(HierarchyLoadLink self) -> std::string"""
        return _IMP_rmf.HierarchyLoadLink___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_HierarchyLoadLink(o)


# Register HierarchyLoadLink in _IMP_rmf:
_IMP_rmf.HierarchyLoadLink_swigregister(HierarchyLoadLink)
class HierarchySaveLink(_ParticleSaveLink):
    r"""Proxy of C++ IMP::rmf::HierarchySaveLink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, fh):
        r"""__init__(HierarchySaveLink self, FileHandle fh) -> HierarchySaveLink"""
        _IMP_rmf.HierarchySaveLink_swiginit(self, _IMP_rmf.new_HierarchySaveLink(fh))

    @staticmethod
    def get_name():
        r"""get_name() -> char const *"""
        return _IMP_rmf.HierarchySaveLink_get_name()

    def get_version_info(self):
        r"""get_version_info(HierarchySaveLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchySaveLink_get_version_info(self)
    __swig_destroy__ = _IMP_rmf.delete_HierarchySaveLink

    def __str__(self):
        r"""__str__(HierarchySaveLink self) -> std::string"""
        return _IMP_rmf.HierarchySaveLink___str__(self)

    def __repr__(self):
        r"""__repr__(HierarchySaveLink self) -> std::string"""
        return _IMP_rmf.HierarchySaveLink___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_HierarchySaveLink(o)


# Register HierarchySaveLink in _IMP_rmf:
_IMP_rmf.HierarchySaveLink_swigregister(HierarchySaveLink)

suffixes = [".rmf", ".rmfz"]


def get_module_version():
    r"""get_module_version() -> std::string const"""
    return _IMP_rmf.get_module_version()

def get_example_path(fname):
    r"""get_example_path(std::string fname) -> std::string"""
    return _IMP_rmf.get_example_path(fname)

def get_data_path(fname):
    r"""get_data_path(std::string fname) -> std::string"""
    return _IMP_rmf.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()