diff --git a/Wrap/Swig/libBornAgainCore.i b/Wrap/Swig/libBornAgainCore.i
index b385bf19825f35dacc547f9b714a738131c7d3d6..9117949716f6ce902a96d746a5ed0cf48d3ad39e 100644
--- a/Wrap/Swig/libBornAgainCore.i
+++ b/Wrap/Swig/libBornAgainCore.i
@@ -28,8 +28,6 @@
%import(module="libBornAgainFit") ""
-%rename(setSampleBuilderCpp) ISimulation::setSampleBuilder;
-%rename(setSampleBuilderCpp) SpecularSimulation::setSampleBuilder;
%rename(addSimulationAndData_cpp) FitObjective::addSimulationAndData;
%rename(evaluate_residuals_cpp) FitObjective::evaluate_residuals;
%rename(evaluate_cpp) FitObjective::evaluate;
@@ -132,23 +130,6 @@
return - *($self); }
};
-// needed to prevent ownership problems with passed ISampleBuilder
-%extend ISimulation {
- %pythoncode %{
- def setSampleBuilder(self, ptr):
- self.samplebuilder = ptr
- self.setSampleBuilderCpp(ptr)
- %}
- };
-
-%extend SpecularSimulation {
- %pythoncode %{
- def setSampleBuilder(self, ptr):
- self.samplebuilder = ptr
- self.setSampleBuilderCpp(ptr)
- %}
- };
-
%pythoncode %{
class SimulationBuilderWrapper(PyBuilderCallback):
def __init__(self, f):
diff --git a/Wrap/Swig/libBornAgainSample.i b/Wrap/Swig/libBornAgainSample.i
index 5abf7fc3902b435ab75c0714275ee89006852207..7b488eb7b4dd4481ba61d151f48e4de8d8f9da2e 100644
--- a/Wrap/Swig/libBornAgainSample.i
+++ b/Wrap/Swig/libBornAgainSample.i
@@ -29,9 +29,6 @@
$result = SWIG_NewPointerObj(new $1_ltype(std::move($1)), $&1_descriptor, SWIG_POINTER_OWN);
%}
-%shared_ptr(ISampleBuilder)
-
-%feature("director") ISampleBuilder; // used in mesocrystal1.py
%feature("director") ISampleNode; // needed by IFormFactor
%feature("director") IFormFactor; // needed by IBornFF
%feature("director") IBornFF; // used in CustomFormFactor.py
@@ -91,7 +88,6 @@
#include "Sample/Particle/ParticleComposition.h"
#include "Sample/Particle/ParticleCoreShell.h"
#include "Sample/Particle/SlicedParticle.h"
-#include "Sample/SampleBuilderEngine/ISampleBuilder.h"
#include "Sample/Scattering/IFormFactorDecorator.h"
#include "Sample/Interface/LayerInterface.h"
#include "Sample/Interface/LayerRoughness.h"
@@ -212,8 +208,6 @@
%include "Sample/Lattice/Lattice2D.h"
%include "Sample/Lattice/BakeLattice.h"
-%include "Sample/SampleBuilderEngine/ISampleBuilder.h"
-
%extend BasicVector3D<double> {
BasicVector3D<double> __add__(const BasicVector3D<double>& rhs) const {
return *($self) + rhs; }
diff --git a/auto/Wrap/libBornAgainCore.py b/auto/Wrap/libBornAgainCore.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c8c851c07ba725cc0cb652db2fd258e156ac752
--- /dev/null
+++ b/auto/Wrap/libBornAgainCore.py
@@ -0,0 +1,4692 @@
+# This file was automatically generated by SWIG (http://www.swig.org).
+# Version 4.0.2
+#
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+if _swig_python_version_info < (2, 7, 0):
+ raise RuntimeError("Python 2.7 or later required")
+
+import _libBornAgainCore
+
+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 == "thisown":
+ self.this.own(value)
+ elif name == "this":
+ set(self, name, 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 SwigPyIterator(object):
+ r"""Proxy of C++ swig::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__ = _libBornAgainCore.delete_SwigPyIterator
+
+ def value(self):
+ r"""value(SwigPyIterator self) -> PyObject *"""
+ return _libBornAgainCore.SwigPyIterator_value(self)
+
+ def incr(self, n=1):
+ r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator_incr(self, n)
+
+ def decr(self, n=1):
+ r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator_decr(self, n)
+
+ def distance(self, x):
+ r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
+ return _libBornAgainCore.SwigPyIterator_distance(self, x)
+
+ def equal(self, x):
+ r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
+ return _libBornAgainCore.SwigPyIterator_equal(self, x)
+
+ def copy(self):
+ r"""copy(SwigPyIterator self) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator_copy(self)
+
+ def next(self):
+ r"""next(SwigPyIterator self) -> PyObject *"""
+ return _libBornAgainCore.SwigPyIterator_next(self)
+
+ def __next__(self):
+ r"""__next__(SwigPyIterator self) -> PyObject *"""
+ return _libBornAgainCore.SwigPyIterator___next__(self)
+
+ def previous(self):
+ r"""previous(SwigPyIterator self) -> PyObject *"""
+ return _libBornAgainCore.SwigPyIterator_previous(self)
+
+ def advance(self, n):
+ r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator_advance(self, n)
+
+ def __eq__(self, x):
+ r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
+ return _libBornAgainCore.SwigPyIterator___eq__(self, x)
+
+ def __ne__(self, x):
+ r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
+ return _libBornAgainCore.SwigPyIterator___ne__(self, x)
+
+ def __iadd__(self, n):
+ r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator___iadd__(self, n)
+
+ def __isub__(self, n):
+ r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator___isub__(self, n)
+
+ def __add__(self, n):
+ r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
+ return _libBornAgainCore.SwigPyIterator___add__(self, n)
+
+ def __sub__(self, *args):
+ r"""
+ __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
+ __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
+ """
+ return _libBornAgainCore.SwigPyIterator___sub__(self, *args)
+ def __iter__(self):
+ return self
+
+# Register SwigPyIterator in _libBornAgainCore:
+_libBornAgainCore.SwigPyIterator_swigregister(SwigPyIterator)
+
+SHARED_PTR_DISOWN = _libBornAgainCore.SHARED_PTR_DISOWN
+
+
+import warnings
+def deprecated(message):
+ def deprecated_decorator(func):
+ def deprecated_func(*args, **kwargs):
+ warnings.simplefilter('always', DeprecationWarning) # turn off filter
+ warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
+ category=DeprecationWarning,
+ stacklevel=2)
+ warnings.simplefilter('default', DeprecationWarning) # reset filter
+ return func(*args, **kwargs)
+ return deprecated_func
+ return deprecated_decorator
+
+class vdouble1d_t(object):
+ r"""Proxy of C++ std::vector< double > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vdouble1d_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vdouble1d_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vdouble1d_t self) -> bool"""
+ return _libBornAgainCore.vdouble1d_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vdouble1d_t self) -> bool"""
+ return _libBornAgainCore.vdouble1d_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vdouble1d_t self) -> std::vector< double >::size_type"""
+ return _libBornAgainCore.vdouble1d_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
+ return _libBornAgainCore.vdouble1d_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
+ __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
+ """
+ return _libBornAgainCore.vdouble1d_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
+ return _libBornAgainCore.vdouble1d_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
+ __delitem__(vdouble1d_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vdouble1d_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
+ """
+ return _libBornAgainCore.vdouble1d_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
+ """
+ return _libBornAgainCore.vdouble1d_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vdouble1d_t self) -> std::vector< double >::value_type"""
+ return _libBornAgainCore.vdouble1d_t_pop(self)
+
+ def append(self, x):
+ r"""append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
+ return _libBornAgainCore.vdouble1d_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vdouble1d_t self) -> bool"""
+ return _libBornAgainCore.vdouble1d_t_empty(self)
+
+ def size(self):
+ r"""size(vdouble1d_t self) -> std::vector< double >::size_type"""
+ return _libBornAgainCore.vdouble1d_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vdouble1d_t self, vdouble1d_t v)"""
+ return _libBornAgainCore.vdouble1d_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vdouble1d_t self) -> std::vector< double >::iterator"""
+ return _libBornAgainCore.vdouble1d_t_begin(self)
+
+ def end(self):
+ r"""end(vdouble1d_t self) -> std::vector< double >::iterator"""
+ return _libBornAgainCore.vdouble1d_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
+ return _libBornAgainCore.vdouble1d_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
+ return _libBornAgainCore.vdouble1d_t_rend(self)
+
+ def clear(self):
+ r"""clear(vdouble1d_t self)"""
+ return _libBornAgainCore.vdouble1d_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
+ return _libBornAgainCore.vdouble1d_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vdouble1d_t self)"""
+ return _libBornAgainCore.vdouble1d_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vdouble1d_t self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
+ erase(vdouble1d_t self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
+ """
+ return _libBornAgainCore.vdouble1d_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vdouble1d_t self) -> vdouble1d_t
+ __init__(vdouble1d_t self, vdouble1d_t other) -> vdouble1d_t
+ __init__(vdouble1d_t self, std::vector< double >::size_type size) -> vdouble1d_t
+ __init__(vdouble1d_t self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vdouble1d_t
+ """
+ _libBornAgainCore.vdouble1d_t_swiginit(self, _libBornAgainCore.new_vdouble1d_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vdouble1d_t self, std::vector< double >::value_type const & x)"""
+ return _libBornAgainCore.vdouble1d_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vdouble1d_t self) -> std::vector< double >::value_type const &"""
+ return _libBornAgainCore.vdouble1d_t_front(self)
+
+ def back(self):
+ r"""back(vdouble1d_t self) -> std::vector< double >::value_type const &"""
+ return _libBornAgainCore.vdouble1d_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vdouble1d_t self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
+ return _libBornAgainCore.vdouble1d_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vdouble1d_t self, std::vector< double >::size_type new_size)
+ resize(vdouble1d_t self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
+ """
+ return _libBornAgainCore.vdouble1d_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vdouble1d_t self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
+ insert(vdouble1d_t self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
+ """
+ return _libBornAgainCore.vdouble1d_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vdouble1d_t self, std::vector< double >::size_type n)"""
+ return _libBornAgainCore.vdouble1d_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vdouble1d_t self) -> std::vector< double >::size_type"""
+ return _libBornAgainCore.vdouble1d_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vdouble1d_t
+
+# Register vdouble1d_t in _libBornAgainCore:
+_libBornAgainCore.vdouble1d_t_swigregister(vdouble1d_t)
+
+class vdouble2d_t(object):
+ r"""Proxy of C++ std::vector< std::vector< double > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vdouble2d_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vdouble2d_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vdouble2d_t self) -> bool"""
+ return _libBornAgainCore.vdouble2d_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vdouble2d_t self) -> bool"""
+ return _libBornAgainCore.vdouble2d_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
+ return _libBornAgainCore.vdouble2d_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
+ return _libBornAgainCore.vdouble2d_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
+ __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
+ """
+ return _libBornAgainCore.vdouble2d_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
+ return _libBornAgainCore.vdouble2d_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
+ __delitem__(vdouble2d_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vdouble2d_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
+ """
+ return _libBornAgainCore.vdouble2d_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
+ """
+ return _libBornAgainCore.vdouble2d_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vdouble2d_t self) -> vdouble1d_t"""
+ return _libBornAgainCore.vdouble2d_t_pop(self)
+
+ def append(self, x):
+ r"""append(vdouble2d_t self, vdouble1d_t x)"""
+ return _libBornAgainCore.vdouble2d_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vdouble2d_t self) -> bool"""
+ return _libBornAgainCore.vdouble2d_t_empty(self)
+
+ def size(self):
+ r"""size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
+ return _libBornAgainCore.vdouble2d_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vdouble2d_t self, vdouble2d_t v)"""
+ return _libBornAgainCore.vdouble2d_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
+ return _libBornAgainCore.vdouble2d_t_begin(self)
+
+ def end(self):
+ r"""end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
+ return _libBornAgainCore.vdouble2d_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
+ return _libBornAgainCore.vdouble2d_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
+ return _libBornAgainCore.vdouble2d_t_rend(self)
+
+ def clear(self):
+ r"""clear(vdouble2d_t self)"""
+ return _libBornAgainCore.vdouble2d_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
+ return _libBornAgainCore.vdouble2d_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vdouble2d_t self)"""
+ return _libBornAgainCore.vdouble2d_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
+ erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
+ """
+ return _libBornAgainCore.vdouble2d_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vdouble2d_t self) -> vdouble2d_t
+ __init__(vdouble2d_t self, vdouble2d_t other) -> vdouble2d_t
+ __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size) -> vdouble2d_t
+ __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size, vdouble1d_t value) -> vdouble2d_t
+ """
+ _libBornAgainCore.vdouble2d_t_swiginit(self, _libBornAgainCore.new_vdouble2d_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vdouble2d_t self, vdouble1d_t x)"""
+ return _libBornAgainCore.vdouble2d_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vdouble2d_t self) -> vdouble1d_t"""
+ return _libBornAgainCore.vdouble2d_t_front(self)
+
+ def back(self):
+ r"""back(vdouble2d_t self) -> vdouble1d_t"""
+ return _libBornAgainCore.vdouble2d_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vdouble2d_t self, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)"""
+ return _libBornAgainCore.vdouble2d_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size)
+ resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size, vdouble1d_t x)
+ """
+ return _libBornAgainCore.vdouble2d_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, vdouble1d_t x) -> std::vector< std::vector< double > >::iterator
+ insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)
+ """
+ return _libBornAgainCore.vdouble2d_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vdouble2d_t self, std::vector< std::vector< double > >::size_type n)"""
+ return _libBornAgainCore.vdouble2d_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
+ return _libBornAgainCore.vdouble2d_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vdouble2d_t
+
+# Register vdouble2d_t in _libBornAgainCore:
+_libBornAgainCore.vdouble2d_t_swigregister(vdouble2d_t)
+
+class vector_integer_t(object):
+ r"""Proxy of C++ std::vector< int > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_integer_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_integer_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_integer_t self) -> bool"""
+ return _libBornAgainCore.vector_integer_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_integer_t self) -> bool"""
+ return _libBornAgainCore.vector_integer_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_integer_t self) -> std::vector< int >::size_type"""
+ return _libBornAgainCore.vector_integer_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
+ return _libBornAgainCore.vector_integer_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
+ __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
+ """
+ return _libBornAgainCore.vector_integer_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
+ return _libBornAgainCore.vector_integer_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_integer_t self, std::vector< int >::difference_type i)
+ __delitem__(vector_integer_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_integer_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
+ """
+ return _libBornAgainCore.vector_integer_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_integer_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_integer_t self) -> std::vector< int >::value_type"""
+ return _libBornAgainCore.vector_integer_t_pop(self)
+
+ def append(self, x):
+ r"""append(vector_integer_t self, std::vector< int >::value_type const & x)"""
+ return _libBornAgainCore.vector_integer_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_integer_t self) -> bool"""
+ return _libBornAgainCore.vector_integer_t_empty(self)
+
+ def size(self):
+ r"""size(vector_integer_t self) -> std::vector< int >::size_type"""
+ return _libBornAgainCore.vector_integer_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_integer_t self, vector_integer_t v)"""
+ return _libBornAgainCore.vector_integer_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_integer_t self) -> std::vector< int >::iterator"""
+ return _libBornAgainCore.vector_integer_t_begin(self)
+
+ def end(self):
+ r"""end(vector_integer_t self) -> std::vector< int >::iterator"""
+ return _libBornAgainCore.vector_integer_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
+ return _libBornAgainCore.vector_integer_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
+ return _libBornAgainCore.vector_integer_t_rend(self)
+
+ def clear(self):
+ r"""clear(vector_integer_t self)"""
+ return _libBornAgainCore.vector_integer_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
+ return _libBornAgainCore.vector_integer_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_integer_t self)"""
+ return _libBornAgainCore.vector_integer_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_integer_t self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
+ erase(vector_integer_t self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
+ """
+ return _libBornAgainCore.vector_integer_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_integer_t self) -> vector_integer_t
+ __init__(vector_integer_t self, vector_integer_t other) -> vector_integer_t
+ __init__(vector_integer_t self, std::vector< int >::size_type size) -> vector_integer_t
+ __init__(vector_integer_t self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vector_integer_t
+ """
+ _libBornAgainCore.vector_integer_t_swiginit(self, _libBornAgainCore.new_vector_integer_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_integer_t self, std::vector< int >::value_type const & x)"""
+ return _libBornAgainCore.vector_integer_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_integer_t self) -> std::vector< int >::value_type const &"""
+ return _libBornAgainCore.vector_integer_t_front(self)
+
+ def back(self):
+ r"""back(vector_integer_t self) -> std::vector< int >::value_type const &"""
+ return _libBornAgainCore.vector_integer_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_integer_t self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
+ return _libBornAgainCore.vector_integer_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_integer_t self, std::vector< int >::size_type new_size)
+ resize(vector_integer_t self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_integer_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_integer_t self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
+ insert(vector_integer_t self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_integer_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_integer_t self, std::vector< int >::size_type n)"""
+ return _libBornAgainCore.vector_integer_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_integer_t self) -> std::vector< int >::size_type"""
+ return _libBornAgainCore.vector_integer_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_integer_t
+
+# Register vector_integer_t in _libBornAgainCore:
+_libBornAgainCore.vector_integer_t_swigregister(vector_integer_t)
+
+class vinteger2d_t(object):
+ r"""Proxy of C++ std::vector< std::vector< int > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vinteger2d_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vinteger2d_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vinteger2d_t self) -> bool"""
+ return _libBornAgainCore.vinteger2d_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vinteger2d_t self) -> bool"""
+ return _libBornAgainCore.vinteger2d_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
+ return _libBornAgainCore.vinteger2d_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> vinteger2d_t"""
+ return _libBornAgainCore.vinteger2d_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)
+ __setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, vinteger2d_t v)
+ """
+ return _libBornAgainCore.vinteger2d_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"""
+ return _libBornAgainCore.vinteger2d_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
+ __delitem__(vinteger2d_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vinteger2d_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
+ """
+ return _libBornAgainCore.vinteger2d_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
+ """
+ return _libBornAgainCore.vinteger2d_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vinteger2d_t self) -> vector_integer_t"""
+ return _libBornAgainCore.vinteger2d_t_pop(self)
+
+ def append(self, x):
+ r"""append(vinteger2d_t self, vector_integer_t x)"""
+ return _libBornAgainCore.vinteger2d_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vinteger2d_t self) -> bool"""
+ return _libBornAgainCore.vinteger2d_t_empty(self)
+
+ def size(self):
+ r"""size(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
+ return _libBornAgainCore.vinteger2d_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vinteger2d_t self, vinteger2d_t v)"""
+ return _libBornAgainCore.vinteger2d_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
+ return _libBornAgainCore.vinteger2d_t_begin(self)
+
+ def end(self):
+ r"""end(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
+ return _libBornAgainCore.vinteger2d_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
+ return _libBornAgainCore.vinteger2d_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
+ return _libBornAgainCore.vinteger2d_t_rend(self)
+
+ def clear(self):
+ r"""clear(vinteger2d_t self)"""
+ return _libBornAgainCore.vinteger2d_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vinteger2d_t self) -> std::vector< std::vector< int > >::allocator_type"""
+ return _libBornAgainCore.vinteger2d_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vinteger2d_t self)"""
+ return _libBornAgainCore.vinteger2d_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator
+ erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator
+ """
+ return _libBornAgainCore.vinteger2d_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vinteger2d_t self) -> vinteger2d_t
+ __init__(vinteger2d_t self, vinteger2d_t other) -> vinteger2d_t
+ __init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size) -> vinteger2d_t
+ __init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size, vector_integer_t value) -> vinteger2d_t
+ """
+ _libBornAgainCore.vinteger2d_t_swiginit(self, _libBornAgainCore.new_vinteger2d_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vinteger2d_t self, vector_integer_t x)"""
+ return _libBornAgainCore.vinteger2d_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vinteger2d_t self) -> vector_integer_t"""
+ return _libBornAgainCore.vinteger2d_t_front(self)
+
+ def back(self):
+ r"""back(vinteger2d_t self) -> vector_integer_t"""
+ return _libBornAgainCore.vinteger2d_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vinteger2d_t self, std::vector< std::vector< int > >::size_type n, vector_integer_t x)"""
+ return _libBornAgainCore.vinteger2d_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size)
+ resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size, vector_integer_t x)
+ """
+ return _libBornAgainCore.vinteger2d_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, vector_integer_t x) -> std::vector< std::vector< int > >::iterator
+ insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, vector_integer_t x)
+ """
+ return _libBornAgainCore.vinteger2d_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vinteger2d_t self, std::vector< std::vector< int > >::size_type n)"""
+ return _libBornAgainCore.vinteger2d_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
+ return _libBornAgainCore.vinteger2d_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vinteger2d_t
+
+# Register vinteger2d_t in _libBornAgainCore:
+_libBornAgainCore.vinteger2d_t_swigregister(vinteger2d_t)
+
+class vector_longinteger_t(object):
+ r"""Proxy of C++ std::vector< unsigned long > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_longinteger_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_longinteger_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_longinteger_t self) -> bool"""
+ return _libBornAgainCore.vector_longinteger_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_longinteger_t self) -> bool"""
+ return _libBornAgainCore.vector_longinteger_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
+ return _libBornAgainCore.vector_longinteger_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
+ return _libBornAgainCore.vector_longinteger_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
+ __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
+ """
+ return _libBornAgainCore.vector_longinteger_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
+ return _libBornAgainCore.vector_longinteger_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
+ __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_longinteger_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
+ """
+ return _libBornAgainCore.vector_longinteger_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_longinteger_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
+ return _libBornAgainCore.vector_longinteger_t_pop(self)
+
+ def append(self, x):
+ r"""append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
+ return _libBornAgainCore.vector_longinteger_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_longinteger_t self) -> bool"""
+ return _libBornAgainCore.vector_longinteger_t_empty(self)
+
+ def size(self):
+ r"""size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
+ return _libBornAgainCore.vector_longinteger_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_longinteger_t self, vector_longinteger_t v)"""
+ return _libBornAgainCore.vector_longinteger_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
+ return _libBornAgainCore.vector_longinteger_t_begin(self)
+
+ def end(self):
+ r"""end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
+ return _libBornAgainCore.vector_longinteger_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
+ return _libBornAgainCore.vector_longinteger_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
+ return _libBornAgainCore.vector_longinteger_t_rend(self)
+
+ def clear(self):
+ r"""clear(vector_longinteger_t self)"""
+ return _libBornAgainCore.vector_longinteger_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
+ return _libBornAgainCore.vector_longinteger_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_longinteger_t self)"""
+ return _libBornAgainCore.vector_longinteger_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_longinteger_t self, std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator
+ erase(vector_longinteger_t self, std::vector< unsigned long >::iterator first, std::vector< unsigned long >::iterator last) -> std::vector< unsigned long >::iterator
+ """
+ return _libBornAgainCore.vector_longinteger_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_longinteger_t self) -> vector_longinteger_t
+ __init__(vector_longinteger_t self, vector_longinteger_t other) -> vector_longinteger_t
+ __init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size) -> vector_longinteger_t
+ __init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vector_longinteger_t
+ """
+ _libBornAgainCore.vector_longinteger_t_swiginit(self, _libBornAgainCore.new_vector_longinteger_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
+ return _libBornAgainCore.vector_longinteger_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
+ return _libBornAgainCore.vector_longinteger_t_front(self)
+
+ def back(self):
+ r"""back(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
+ return _libBornAgainCore.vector_longinteger_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_longinteger_t self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
+ return _libBornAgainCore.vector_longinteger_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size)
+ resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size, std::vector< unsigned long >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_longinteger_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::value_type const & x) -> std::vector< unsigned long >::iterator
+ insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_longinteger_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_longinteger_t self, std::vector< unsigned long >::size_type n)"""
+ return _libBornAgainCore.vector_longinteger_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
+ return _libBornAgainCore.vector_longinteger_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_longinteger_t
+
+# Register vector_longinteger_t in _libBornAgainCore:
+_libBornAgainCore.vector_longinteger_t_swigregister(vector_longinteger_t)
+
+class vector_complex_t(object):
+ r"""Proxy of C++ std::vector< std::complex< double > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_complex_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_complex_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_complex_t self) -> bool"""
+ return _libBornAgainCore.vector_complex_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_complex_t self) -> bool"""
+ return _libBornAgainCore.vector_complex_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
+ return _libBornAgainCore.vector_complex_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
+ return _libBornAgainCore.vector_complex_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
+ __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
+ """
+ return _libBornAgainCore.vector_complex_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
+ return _libBornAgainCore.vector_complex_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
+ __delitem__(vector_complex_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_complex_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
+ """
+ return _libBornAgainCore.vector_complex_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_complex_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
+ return _libBornAgainCore.vector_complex_t_pop(self)
+
+ def append(self, x):
+ r"""append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
+ return _libBornAgainCore.vector_complex_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_complex_t self) -> bool"""
+ return _libBornAgainCore.vector_complex_t_empty(self)
+
+ def size(self):
+ r"""size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
+ return _libBornAgainCore.vector_complex_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_complex_t self, vector_complex_t v)"""
+ return _libBornAgainCore.vector_complex_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
+ return _libBornAgainCore.vector_complex_t_begin(self)
+
+ def end(self):
+ r"""end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
+ return _libBornAgainCore.vector_complex_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_complex_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_complex_t_rend(self)
+
+ def clear(self):
+ r"""clear(vector_complex_t self)"""
+ return _libBornAgainCore.vector_complex_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
+ return _libBornAgainCore.vector_complex_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_complex_t self)"""
+ return _libBornAgainCore.vector_complex_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_complex_t self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
+ erase(vector_complex_t self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
+ """
+ return _libBornAgainCore.vector_complex_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_complex_t self) -> vector_complex_t
+ __init__(vector_complex_t self, vector_complex_t other) -> vector_complex_t
+ __init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size) -> vector_complex_t
+ __init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> vector_complex_t
+ """
+ _libBornAgainCore.vector_complex_t_swiginit(self, _libBornAgainCore.new_vector_complex_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
+ return _libBornAgainCore.vector_complex_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
+ return _libBornAgainCore.vector_complex_t_front(self)
+
+ def back(self):
+ r"""back(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
+ return _libBornAgainCore.vector_complex_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_complex_t self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
+ return _libBornAgainCore.vector_complex_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size)
+ resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_complex_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_complex_t self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
+ insert(vector_complex_t self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_complex_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_complex_t self, std::vector< std::complex< double > >::size_type n)"""
+ return _libBornAgainCore.vector_complex_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
+ return _libBornAgainCore.vector_complex_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_complex_t
+
+# Register vector_complex_t in _libBornAgainCore:
+_libBornAgainCore.vector_complex_t_swigregister(vector_complex_t)
+
+class vector_string_t(object):
+ r"""Proxy of C++ std::vector< std::string > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_string_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_string_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_string_t self) -> bool"""
+ return _libBornAgainCore.vector_string_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_string_t self) -> bool"""
+ return _libBornAgainCore.vector_string_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_string_t self) -> std::vector< std::string >::size_type"""
+ return _libBornAgainCore.vector_string_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
+ return _libBornAgainCore.vector_string_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
+ __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
+ """
+ return _libBornAgainCore.vector_string_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
+ return _libBornAgainCore.vector_string_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
+ __delitem__(vector_string_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_string_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
+ """
+ return _libBornAgainCore.vector_string_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
+ __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_string_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_string_t self) -> std::vector< std::string >::value_type"""
+ return _libBornAgainCore.vector_string_t_pop(self)
+
+ def append(self, x):
+ r"""append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
+ return _libBornAgainCore.vector_string_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_string_t self) -> bool"""
+ return _libBornAgainCore.vector_string_t_empty(self)
+
+ def size(self):
+ r"""size(vector_string_t self) -> std::vector< std::string >::size_type"""
+ return _libBornAgainCore.vector_string_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_string_t self, vector_string_t v)"""
+ return _libBornAgainCore.vector_string_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_string_t self) -> std::vector< std::string >::iterator"""
+ return _libBornAgainCore.vector_string_t_begin(self)
+
+ def end(self):
+ r"""end(vector_string_t self) -> std::vector< std::string >::iterator"""
+ return _libBornAgainCore.vector_string_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
+ return _libBornAgainCore.vector_string_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
+ return _libBornAgainCore.vector_string_t_rend(self)
+
+ def clear(self):
+ r"""clear(vector_string_t self)"""
+ return _libBornAgainCore.vector_string_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
+ return _libBornAgainCore.vector_string_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_string_t self)"""
+ return _libBornAgainCore.vector_string_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_string_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
+ erase(vector_string_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
+ """
+ return _libBornAgainCore.vector_string_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_string_t self) -> vector_string_t
+ __init__(vector_string_t self, vector_string_t other) -> vector_string_t
+ __init__(vector_string_t self, std::vector< std::string >::size_type size) -> vector_string_t
+ __init__(vector_string_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string_t
+ """
+ _libBornAgainCore.vector_string_t_swiginit(self, _libBornAgainCore.new_vector_string_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_string_t self, std::vector< std::string >::value_type const & x)"""
+ return _libBornAgainCore.vector_string_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_string_t self) -> std::vector< std::string >::value_type const &"""
+ return _libBornAgainCore.vector_string_t_front(self)
+
+ def back(self):
+ r"""back(vector_string_t self) -> std::vector< std::string >::value_type const &"""
+ return _libBornAgainCore.vector_string_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_string_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
+ return _libBornAgainCore.vector_string_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_string_t self, std::vector< std::string >::size_type new_size)
+ resize(vector_string_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_string_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_string_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
+ insert(vector_string_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
+ """
+ return _libBornAgainCore.vector_string_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_string_t self, std::vector< std::string >::size_type n)"""
+ return _libBornAgainCore.vector_string_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_string_t self) -> std::vector< std::string >::size_type"""
+ return _libBornAgainCore.vector_string_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_string_t
+
+# Register vector_string_t in _libBornAgainCore:
+_libBornAgainCore.vector_string_t_swigregister(vector_string_t)
+
+class map_string_double_t(object):
+ r"""Proxy of C++ std::map< std::string,double > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(map_string_double_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.map_string_double_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(map_string_double_t self) -> bool"""
+ return _libBornAgainCore.map_string_double_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(map_string_double_t self) -> bool"""
+ return _libBornAgainCore.map_string_double_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(map_string_double_t self) -> std::map< std::string,double >::size_type"""
+ return _libBornAgainCore.map_string_double_t___len__(self)
+ def __iter__(self):
+ return self.key_iterator()
+ def iterkeys(self):
+ return self.key_iterator()
+ def itervalues(self):
+ return self.value_iterator()
+ def iteritems(self):
+ return self.iterator()
+
+ def __getitem__(self, key):
+ r"""__getitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> std::map< std::string,double >::mapped_type const &"""
+ return _libBornAgainCore.map_string_double_t___getitem__(self, key)
+
+ def __delitem__(self, key):
+ r"""__delitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)"""
+ return _libBornAgainCore.map_string_double_t___delitem__(self, key)
+
+ def has_key(self, key):
+ r"""has_key(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
+ return _libBornAgainCore.map_string_double_t_has_key(self, key)
+
+ def keys(self):
+ r"""keys(map_string_double_t self) -> PyObject *"""
+ return _libBornAgainCore.map_string_double_t_keys(self)
+
+ def values(self):
+ r"""values(map_string_double_t self) -> PyObject *"""
+ return _libBornAgainCore.map_string_double_t_values(self)
+
+ def items(self):
+ r"""items(map_string_double_t self) -> PyObject *"""
+ return _libBornAgainCore.map_string_double_t_items(self)
+
+ def __contains__(self, key):
+ r"""__contains__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
+ return _libBornAgainCore.map_string_double_t___contains__(self, key)
+
+ def key_iterator(self):
+ r"""key_iterator(map_string_double_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.map_string_double_t_key_iterator(self)
+
+ def value_iterator(self):
+ r"""value_iterator(map_string_double_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.map_string_double_t_value_iterator(self)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)
+ __setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key, std::map< std::string,double >::mapped_type const & x)
+ """
+ return _libBornAgainCore.map_string_double_t___setitem__(self, *args)
+
+ def asdict(self):
+ r"""asdict(map_string_double_t self) -> PyObject *"""
+ return _libBornAgainCore.map_string_double_t_asdict(self)
+
+ def __init__(self, *args):
+ r"""
+ __init__(map_string_double_t self, std::less< std::string > const & other) -> map_string_double_t
+ __init__(map_string_double_t self) -> map_string_double_t
+ __init__(map_string_double_t self, map_string_double_t other) -> map_string_double_t
+ """
+ _libBornAgainCore.map_string_double_t_swiginit(self, _libBornAgainCore.new_map_string_double_t(*args))
+
+ def empty(self):
+ r"""empty(map_string_double_t self) -> bool"""
+ return _libBornAgainCore.map_string_double_t_empty(self)
+
+ def size(self):
+ r"""size(map_string_double_t self) -> std::map< std::string,double >::size_type"""
+ return _libBornAgainCore.map_string_double_t_size(self)
+
+ def swap(self, v):
+ r"""swap(map_string_double_t self, map_string_double_t v)"""
+ return _libBornAgainCore.map_string_double_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(map_string_double_t self) -> std::map< std::string,double >::iterator"""
+ return _libBornAgainCore.map_string_double_t_begin(self)
+
+ def end(self):
+ r"""end(map_string_double_t self) -> std::map< std::string,double >::iterator"""
+ return _libBornAgainCore.map_string_double_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
+ return _libBornAgainCore.map_string_double_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
+ return _libBornAgainCore.map_string_double_t_rend(self)
+
+ def clear(self):
+ r"""clear(map_string_double_t self)"""
+ return _libBornAgainCore.map_string_double_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(map_string_double_t self) -> std::map< std::string,double >::allocator_type"""
+ return _libBornAgainCore.map_string_double_t_get_allocator(self)
+
+ def count(self, x):
+ r"""count(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type"""
+ return _libBornAgainCore.map_string_double_t_count(self, x)
+
+ def erase(self, *args):
+ r"""
+ erase(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type
+ erase(map_string_double_t self, std::map< std::string,double >::iterator position)
+ erase(map_string_double_t self, std::map< std::string,double >::iterator first, std::map< std::string,double >::iterator last)
+ """
+ return _libBornAgainCore.map_string_double_t_erase(self, *args)
+
+ def find(self, x):
+ r"""find(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
+ return _libBornAgainCore.map_string_double_t_find(self, x)
+
+ def lower_bound(self, x):
+ r"""lower_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
+ return _libBornAgainCore.map_string_double_t_lower_bound(self, x)
+
+ def upper_bound(self, x):
+ r"""upper_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
+ return _libBornAgainCore.map_string_double_t_upper_bound(self, x)
+ __swig_destroy__ = _libBornAgainCore.delete_map_string_double_t
+
+# Register map_string_double_t in _libBornAgainCore:
+_libBornAgainCore.map_string_double_t_swigregister(map_string_double_t)
+
+class pvacuum_double_t(object):
+ r"""Proxy of C++ std::pair< double,double > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(pvacuum_double_t self) -> pvacuum_double_t
+ __init__(pvacuum_double_t self, double first, double second) -> pvacuum_double_t
+ __init__(pvacuum_double_t self, pvacuum_double_t other) -> pvacuum_double_t
+ """
+ _libBornAgainCore.pvacuum_double_t_swiginit(self, _libBornAgainCore.new_pvacuum_double_t(*args))
+ first = property(_libBornAgainCore.pvacuum_double_t_first_get, _libBornAgainCore.pvacuum_double_t_first_set, doc=r"""first : double""")
+ second = property(_libBornAgainCore.pvacuum_double_t_second_get, _libBornAgainCore.pvacuum_double_t_second_set, doc=r"""second : double""")
+ def __len__(self):
+ return 2
+ def __repr__(self):
+ return str((self.first, self.second))
+ def __getitem__(self, index):
+ if not (index % 2):
+ return self.first
+ else:
+ return self.second
+ def __setitem__(self, index, val):
+ if not (index % 2):
+ self.first = val
+ else:
+ self.second = val
+ __swig_destroy__ = _libBornAgainCore.delete_pvacuum_double_t
+
+# Register pvacuum_double_t in _libBornAgainCore:
+_libBornAgainCore.pvacuum_double_t_swigregister(pvacuum_double_t)
+
+class vector_pvacuum_double_t(object):
+ r"""Proxy of C++ std::vector< std::pair< double,double > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_pvacuum_double_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_pvacuum_double_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_pvacuum_double_t self) -> bool"""
+ return _libBornAgainCore.vector_pvacuum_double_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_pvacuum_double_t self) -> bool"""
+ return _libBornAgainCore.vector_pvacuum_double_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
+ return _libBornAgainCore.vector_pvacuum_double_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> vector_pvacuum_double_t"""
+ return _libBornAgainCore.vector_pvacuum_double_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)
+ __setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, vector_pvacuum_double_t v)
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"""
+ return _libBornAgainCore.vector_pvacuum_double_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
+ __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_pvacuum_double_t self) -> pvacuum_double_t"""
+ return _libBornAgainCore.vector_pvacuum_double_t_pop(self)
+
+ def append(self, x):
+ r"""append(vector_pvacuum_double_t self, pvacuum_double_t x)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_pvacuum_double_t self) -> bool"""
+ return _libBornAgainCore.vector_pvacuum_double_t_empty(self)
+
+ def size(self):
+ r"""size(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
+ return _libBornAgainCore.vector_pvacuum_double_t_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_pvacuum_double_t self, vector_pvacuum_double_t v)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
+ return _libBornAgainCore.vector_pvacuum_double_t_begin(self)
+
+ def end(self):
+ r"""end(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
+ return _libBornAgainCore.vector_pvacuum_double_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_pvacuum_double_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_pvacuum_double_t_rend(self)
+
+ def clear(self):
+ r"""clear(vector_pvacuum_double_t self)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::allocator_type"""
+ return _libBornAgainCore.vector_pvacuum_double_t_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_pvacuum_double_t self)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos) -> std::vector< std::pair< double,double > >::iterator
+ erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator first, std::vector< std::pair< double,double > >::iterator last) -> std::vector< std::pair< double,double > >::iterator
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_pvacuum_double_t self) -> vector_pvacuum_double_t
+ __init__(vector_pvacuum_double_t self, vector_pvacuum_double_t other) -> vector_pvacuum_double_t
+ __init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size) -> vector_pvacuum_double_t
+ __init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size, pvacuum_double_t value) -> vector_pvacuum_double_t
+ """
+ _libBornAgainCore.vector_pvacuum_double_t_swiginit(self, _libBornAgainCore.new_vector_pvacuum_double_t(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_pvacuum_double_t self, pvacuum_double_t x)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_pvacuum_double_t self) -> pvacuum_double_t"""
+ return _libBornAgainCore.vector_pvacuum_double_t_front(self)
+
+ def back(self):
+ r"""back(vector_pvacuum_double_t self) -> pvacuum_double_t"""
+ return _libBornAgainCore.vector_pvacuum_double_t_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size)
+ resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size, pvacuum_double_t x)
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, pvacuum_double_t x) -> std::vector< std::pair< double,double > >::iterator
+ insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)
+ """
+ return _libBornAgainCore.vector_pvacuum_double_t_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n)"""
+ return _libBornAgainCore.vector_pvacuum_double_t_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
+ return _libBornAgainCore.vector_pvacuum_double_t_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_pvacuum_double_t
+
+# Register vector_pvacuum_double_t in _libBornAgainCore:
+_libBornAgainCore.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)
+
+import libBornAgainFit
+import libBornAgainBase
+class R3(object):
+ r"""Proxy of C++ BasicVector3D< double > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(R3 self) -> R3
+ __init__(R3 self, double const x1, double const y1, double const z1) -> R3
+ """
+ _libBornAgainCore.R3_swiginit(self, _libBornAgainCore.new_R3(*args))
+
+ def x(self):
+ r"""x(R3 self) -> double"""
+ return _libBornAgainCore.R3_x(self)
+
+ def y(self):
+ r"""y(R3 self) -> double"""
+ return _libBornAgainCore.R3_y(self)
+
+ def z(self):
+ r"""z(R3 self) -> double"""
+ return _libBornAgainCore.R3_z(self)
+
+ def setX(self, a):
+ r"""setX(R3 self, double const & a)"""
+ return _libBornAgainCore.R3_setX(self, a)
+
+ def setY(self, a):
+ r"""setY(R3 self, double const & a)"""
+ return _libBornAgainCore.R3_setY(self, a)
+
+ def setZ(self, a):
+ r"""setZ(R3 self, double const & a)"""
+ return _libBornAgainCore.R3_setZ(self, a)
+
+ def __iadd__(self, v):
+ r"""__iadd__(R3 self, R3 v) -> R3"""
+ return _libBornAgainCore.R3___iadd__(self, v)
+
+ def __isub__(self, v):
+ r"""__isub__(R3 self, R3 v) -> R3"""
+ return _libBornAgainCore.R3___isub__(self, v)
+
+ def conj(self):
+ r"""conj(R3 self) -> R3"""
+ return _libBornAgainCore.R3_conj(self)
+
+ def mag2(self):
+ r"""mag2(R3 self) -> double"""
+ return _libBornAgainCore.R3_mag2(self)
+
+ def mag(self):
+ r"""mag(R3 self) -> double"""
+ return _libBornAgainCore.R3_mag(self)
+
+ def magxy2(self):
+ r"""magxy2(R3 self) -> double"""
+ return _libBornAgainCore.R3_magxy2(self)
+
+ def magxy(self):
+ r"""magxy(R3 self) -> double"""
+ return _libBornAgainCore.R3_magxy(self)
+
+ def phi(self):
+ r"""phi(R3 self) -> double"""
+ return _libBornAgainCore.R3_phi(self)
+
+ def theta(self):
+ r"""theta(R3 self) -> double"""
+ return _libBornAgainCore.R3_theta(self)
+
+ def cosTheta(self):
+ r"""cosTheta(R3 self) -> double"""
+ return _libBornAgainCore.R3_cosTheta(self)
+
+ def sin2Theta(self):
+ r"""sin2Theta(R3 self) -> double"""
+ return _libBornAgainCore.R3_sin2Theta(self)
+
+ def unit(self):
+ r"""unit(R3 self) -> R3"""
+ return _libBornAgainCore.R3_unit(self)
+
+ def complex(self):
+ r"""complex(R3 self) -> C3"""
+ return _libBornAgainCore.R3_complex(self)
+
+ def real(self):
+ r"""real(R3 self) -> R3"""
+ return _libBornAgainCore.R3_real(self)
+
+ def angle(self, v):
+ r"""angle(R3 self, R3 v) -> double"""
+ return _libBornAgainCore.R3_angle(self, v)
+
+ def project(self, v):
+ r"""project(R3 self, R3 v) -> R3"""
+ return _libBornAgainCore.R3_project(self, v)
+
+ def __add__(self, rhs):
+ r"""__add__(R3 self, R3 rhs) -> R3"""
+ return _libBornAgainCore.R3___add__(self, rhs)
+
+ def __mul__(self, c):
+ r"""__mul__(R3 self, double c) -> R3"""
+ return _libBornAgainCore.R3___mul__(self, c)
+
+ def __rmul__(self, c):
+ r"""__rmul__(R3 self, double c) -> R3"""
+ return _libBornAgainCore.R3___rmul__(self, c)
+
+ def __neg__(self):
+ r"""__neg__(R3 self) -> R3"""
+ return _libBornAgainCore.R3___neg__(self)
+ __swig_destroy__ = _libBornAgainCore.delete_R3
+
+# Register R3 in _libBornAgainCore:
+_libBornAgainCore.R3_swigregister(R3)
+
+class vector_R3(object):
+ r"""Proxy of C++ std::vector< BasicVector3D< double > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_R3 self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_R3_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_R3 self) -> bool"""
+ return _libBornAgainCore.vector_R3___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_R3 self) -> bool"""
+ return _libBornAgainCore.vector_R3___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_R3 self) -> std::vector< BasicVector3D< double > >::size_type"""
+ return _libBornAgainCore.vector_R3___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j) -> vector_R3"""
+ return _libBornAgainCore.vector_R3___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)
+ __setslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j, vector_R3 v)
+ """
+ return _libBornAgainCore.vector_R3___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)"""
+ return _libBornAgainCore.vector_R3___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i)
+ __delitem__(vector_R3 self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_R3___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
+ __getitem__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i) -> R3
+ """
+ return _libBornAgainCore.vector_R3___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
+ __setitem__(vector_R3 self, PySliceObject * slice)
+ __setitem__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, R3 x)
+ """
+ return _libBornAgainCore.vector_R3___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_R3 self) -> R3"""
+ return _libBornAgainCore.vector_R3_pop(self)
+
+ def append(self, x):
+ r"""append(vector_R3 self, R3 x)"""
+ return _libBornAgainCore.vector_R3_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_R3 self) -> bool"""
+ return _libBornAgainCore.vector_R3_empty(self)
+
+ def size(self):
+ r"""size(vector_R3 self) -> std::vector< BasicVector3D< double > >::size_type"""
+ return _libBornAgainCore.vector_R3_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_R3 self, vector_R3 v)"""
+ return _libBornAgainCore.vector_R3_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_R3 self) -> std::vector< BasicVector3D< double > >::iterator"""
+ return _libBornAgainCore.vector_R3_begin(self)
+
+ def end(self):
+ r"""end(vector_R3 self) -> std::vector< BasicVector3D< double > >::iterator"""
+ return _libBornAgainCore.vector_R3_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_R3 self) -> std::vector< BasicVector3D< double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_R3_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_R3 self) -> std::vector< BasicVector3D< double > >::reverse_iterator"""
+ return _libBornAgainCore.vector_R3_rend(self)
+
+ def clear(self):
+ r"""clear(vector_R3 self)"""
+ return _libBornAgainCore.vector_R3_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_R3 self) -> std::vector< BasicVector3D< double > >::allocator_type"""
+ return _libBornAgainCore.vector_R3_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_R3 self)"""
+ return _libBornAgainCore.vector_R3_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_R3 self, std::vector< BasicVector3D< double > >::iterator pos) -> std::vector< BasicVector3D< double > >::iterator
+ erase(vector_R3 self, std::vector< BasicVector3D< double > >::iterator first, std::vector< BasicVector3D< double > >::iterator last) -> std::vector< BasicVector3D< double > >::iterator
+ """
+ return _libBornAgainCore.vector_R3_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_R3 self) -> vector_R3
+ __init__(vector_R3 self, vector_R3 other) -> vector_R3
+ __init__(vector_R3 self, std::vector< BasicVector3D< double > >::size_type size) -> vector_R3
+ __init__(vector_R3 self, std::vector< BasicVector3D< double > >::size_type size, R3 value) -> vector_R3
+ """
+ _libBornAgainCore.vector_R3_swiginit(self, _libBornAgainCore.new_vector_R3(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_R3 self, R3 x)"""
+ return _libBornAgainCore.vector_R3_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_R3 self) -> R3"""
+ return _libBornAgainCore.vector_R3_front(self)
+
+ def back(self):
+ r"""back(vector_R3 self) -> R3"""
+ return _libBornAgainCore.vector_R3_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_R3 self, std::vector< BasicVector3D< double > >::size_type n, R3 x)"""
+ return _libBornAgainCore.vector_R3_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_R3 self, std::vector< BasicVector3D< double > >::size_type new_size)
+ resize(vector_R3 self, std::vector< BasicVector3D< double > >::size_type new_size, R3 x)
+ """
+ return _libBornAgainCore.vector_R3_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_R3 self, std::vector< BasicVector3D< double > >::iterator pos, R3 x) -> std::vector< BasicVector3D< double > >::iterator
+ insert(vector_R3 self, std::vector< BasicVector3D< double > >::iterator pos, std::vector< BasicVector3D< double > >::size_type n, R3 x)
+ """
+ return _libBornAgainCore.vector_R3_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_R3 self, std::vector< BasicVector3D< double > >::size_type n)"""
+ return _libBornAgainCore.vector_R3_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_R3 self) -> std::vector< BasicVector3D< double > >::size_type"""
+ return _libBornAgainCore.vector_R3_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_R3
+
+# Register vector_R3 in _libBornAgainCore:
+_libBornAgainCore.vector_R3_swigregister(vector_R3)
+
+class C3(object):
+ r"""Proxy of C++ BasicVector3D< std::complex< double > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(C3 self) -> C3
+ __init__(C3 self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3
+ """
+ _libBornAgainCore.C3_swiginit(self, _libBornAgainCore.new_C3(*args))
+
+ def x(self):
+ r"""x(C3 self) -> std::complex< double >"""
+ return _libBornAgainCore.C3_x(self)
+
+ def y(self):
+ r"""y(C3 self) -> std::complex< double >"""
+ return _libBornAgainCore.C3_y(self)
+
+ def z(self):
+ r"""z(C3 self) -> std::complex< double >"""
+ return _libBornAgainCore.C3_z(self)
+
+ def setX(self, a):
+ r"""setX(C3 self, std::complex< double > const & a)"""
+ return _libBornAgainCore.C3_setX(self, a)
+
+ def setY(self, a):
+ r"""setY(C3 self, std::complex< double > const & a)"""
+ return _libBornAgainCore.C3_setY(self, a)
+
+ def setZ(self, a):
+ r"""setZ(C3 self, std::complex< double > const & a)"""
+ return _libBornAgainCore.C3_setZ(self, a)
+
+ def __iadd__(self, v):
+ r"""__iadd__(C3 self, C3 v) -> C3"""
+ return _libBornAgainCore.C3___iadd__(self, v)
+
+ def __isub__(self, v):
+ r"""__isub__(C3 self, C3 v) -> C3"""
+ return _libBornAgainCore.C3___isub__(self, v)
+
+ def conj(self):
+ r"""conj(C3 self) -> C3"""
+ return _libBornAgainCore.C3_conj(self)
+
+ def mag2(self):
+ r"""mag2(C3 self) -> double"""
+ return _libBornAgainCore.C3_mag2(self)
+
+ def mag(self):
+ r"""mag(C3 self) -> double"""
+ return _libBornAgainCore.C3_mag(self)
+
+ def magxy2(self):
+ r"""magxy2(C3 self) -> double"""
+ return _libBornAgainCore.C3_magxy2(self)
+
+ def magxy(self):
+ r"""magxy(C3 self) -> double"""
+ return _libBornAgainCore.C3_magxy(self)
+
+ def unit(self):
+ r"""unit(C3 self) -> C3"""
+ return _libBornAgainCore.C3_unit(self)
+
+ def real(self):
+ r"""real(C3 self) -> R3"""
+ return _libBornAgainCore.C3_real(self)
+
+ def project(self, v):
+ r"""project(C3 self, C3 v) -> C3"""
+ return _libBornAgainCore.C3_project(self, v)
+ __swig_destroy__ = _libBornAgainCore.delete_C3
+
+# Register C3 in _libBornAgainCore:
+_libBornAgainCore.C3_swigregister(C3)
+
+class vector_C3(object):
+ r"""Proxy of C++ std::vector< BasicVector3D< std::complex< double > > > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(vector_C3 self) -> SwigPyIterator"""
+ return _libBornAgainCore.vector_C3_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(vector_C3 self) -> bool"""
+ return _libBornAgainCore.vector_C3___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(vector_C3 self) -> bool"""
+ return _libBornAgainCore.vector_C3___bool__(self)
+
+ def __len__(self):
+ r"""__len__(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
+ return _libBornAgainCore.vector_C3___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j) -> vector_C3"""
+ return _libBornAgainCore.vector_C3___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)
+ __setslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j, vector_C3 v)
+ """
+ return _libBornAgainCore.vector_C3___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)"""
+ return _libBornAgainCore.vector_C3___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i)
+ __delitem__(vector_C3 self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.vector_C3___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(vector_C3 self, PySliceObject * slice) -> vector_C3
+ __getitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i) -> C3
+ """
+ return _libBornAgainCore.vector_C3___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(vector_C3 self, PySliceObject * slice, vector_C3 v)
+ __setitem__(vector_C3 self, PySliceObject * slice)
+ __setitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, C3 x)
+ """
+ return _libBornAgainCore.vector_C3___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(vector_C3 self) -> C3"""
+ return _libBornAgainCore.vector_C3_pop(self)
+
+ def append(self, x):
+ r"""append(vector_C3 self, C3 x)"""
+ return _libBornAgainCore.vector_C3_append(self, x)
+
+ def empty(self):
+ r"""empty(vector_C3 self) -> bool"""
+ return _libBornAgainCore.vector_C3_empty(self)
+
+ def size(self):
+ r"""size(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
+ return _libBornAgainCore.vector_C3_size(self)
+
+ def swap(self, v):
+ r"""swap(vector_C3 self, vector_C3 v)"""
+ return _libBornAgainCore.vector_C3_swap(self, v)
+
+ def begin(self):
+ r"""begin(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
+ return _libBornAgainCore.vector_C3_begin(self)
+
+ def end(self):
+ r"""end(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
+ return _libBornAgainCore.vector_C3_end(self)
+
+ def rbegin(self):
+ r"""rbegin(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
+ return _libBornAgainCore.vector_C3_rbegin(self)
+
+ def rend(self):
+ r"""rend(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
+ return _libBornAgainCore.vector_C3_rend(self)
+
+ def clear(self):
+ r"""clear(vector_C3 self)"""
+ return _libBornAgainCore.vector_C3_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::allocator_type"""
+ return _libBornAgainCore.vector_C3_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(vector_C3 self)"""
+ return _libBornAgainCore.vector_C3_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
+ erase(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator first, std::vector< BasicVector3D< std::complex< double > > >::iterator last) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
+ """
+ return _libBornAgainCore.vector_C3_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(vector_C3 self) -> vector_C3
+ __init__(vector_C3 self, vector_C3 other) -> vector_C3
+ __init__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type size) -> vector_C3
+ __init__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type size, C3 value) -> vector_C3
+ """
+ _libBornAgainCore.vector_C3_swiginit(self, _libBornAgainCore.new_vector_C3(*args))
+
+ def push_back(self, x):
+ r"""push_back(vector_C3 self, C3 x)"""
+ return _libBornAgainCore.vector_C3_push_back(self, x)
+
+ def front(self):
+ r"""front(vector_C3 self) -> C3"""
+ return _libBornAgainCore.vector_C3_front(self)
+
+ def back(self):
+ r"""back(vector_C3 self) -> C3"""
+ return _libBornAgainCore.vector_C3_back(self)
+
+ def assign(self, n, x):
+ r"""assign(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type n, C3 x)"""
+ return _libBornAgainCore.vector_C3_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size)
+ resize(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size, C3 x)
+ """
+ return _libBornAgainCore.vector_C3_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, C3 x) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
+ insert(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, std::vector< BasicVector3D< std::complex< double > > >::size_type n, C3 x)
+ """
+ return _libBornAgainCore.vector_C3_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type n)"""
+ return _libBornAgainCore.vector_C3_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
+ return _libBornAgainCore.vector_C3_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_vector_C3
+
+# Register vector_C3 in _libBornAgainCore:
+_libBornAgainCore.vector_C3_swigregister(vector_C3)
+
+import libBornAgainParam
+import libBornAgainSample
+class swig_dummy_type_axisinfo_vector(object):
+ r"""Proxy of C++ std::vector< AxisInfo > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(swig_dummy_type_axisinfo_vector self) -> SwigPyIterator"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(swig_dummy_type_axisinfo_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(swig_dummy_type_axisinfo_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___bool__(self)
+
+ def __len__(self):
+ r"""__len__(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j) -> swig_dummy_type_axisinfo_vector"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j)
+ __setslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j, swig_dummy_type_axisinfo_vector v)
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i)
+ __delitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice) -> swig_dummy_type_axisinfo_vector
+ __getitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i) -> std::vector< AxisInfo >::value_type const &
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice, swig_dummy_type_axisinfo_vector v)
+ __setitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::value_type const & x)
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_pop(self)
+
+ def append(self, x):
+ r"""append(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::value_type const & x)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_append(self, x)
+
+ def empty(self):
+ r"""empty(swig_dummy_type_axisinfo_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_empty(self)
+
+ def size(self):
+ r"""size(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_size(self)
+
+ def swap(self, v):
+ r"""swap(swig_dummy_type_axisinfo_vector self, swig_dummy_type_axisinfo_vector v)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_swap(self, v)
+
+ def begin(self):
+ r"""begin(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_begin(self)
+
+ def end(self):
+ r"""end(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_end(self)
+
+ def rbegin(self):
+ r"""rbegin(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_rbegin(self)
+
+ def rend(self):
+ r"""rend(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_rend(self)
+
+ def clear(self):
+ r"""clear(swig_dummy_type_axisinfo_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::allocator_type"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(swig_dummy_type_axisinfo_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos) -> std::vector< AxisInfo >::iterator
+ erase(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator first, std::vector< AxisInfo >::iterator last) -> std::vector< AxisInfo >::iterator
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(swig_dummy_type_axisinfo_vector self) -> swig_dummy_type_axisinfo_vector
+ __init__(swig_dummy_type_axisinfo_vector self, swig_dummy_type_axisinfo_vector other) -> swig_dummy_type_axisinfo_vector
+ __init__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type size) -> swig_dummy_type_axisinfo_vector
+ __init__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type size, std::vector< AxisInfo >::value_type const & value) -> swig_dummy_type_axisinfo_vector
+ """
+ _libBornAgainCore.swig_dummy_type_axisinfo_vector_swiginit(self, _libBornAgainCore.new_swig_dummy_type_axisinfo_vector(*args))
+
+ def push_back(self, x):
+ r"""push_back(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::value_type const & x)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_push_back(self, x)
+
+ def front(self):
+ r"""front(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type const &"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_front(self)
+
+ def back(self):
+ r"""back(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type const &"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_back(self)
+
+ def assign(self, n, x):
+ r"""assign(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type n, std::vector< AxisInfo >::value_type const & x)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type new_size)
+ resize(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type new_size, std::vector< AxisInfo >::value_type const & x)
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos, std::vector< AxisInfo >::value_type const & x) -> std::vector< AxisInfo >::iterator
+ insert(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos, std::vector< AxisInfo >::size_type n, std::vector< AxisInfo >::value_type const & x)
+ """
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type n)"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_axisinfo_vector_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_swig_dummy_type_axisinfo_vector
+
+# Register swig_dummy_type_axisinfo_vector in _libBornAgainCore:
+_libBornAgainCore.swig_dummy_type_axisinfo_vector_swigregister(swig_dummy_type_axisinfo_vector)
+
+class swig_dummy_type_inode_vector(object):
+ r"""Proxy of C++ std::vector< INode * > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(swig_dummy_type_inode_vector self) -> SwigPyIterator"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(swig_dummy_type_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(swig_dummy_type_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector___bool__(self)
+
+ def __len__(self):
+ r"""__len__(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j) -> swig_dummy_type_inode_vector"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j)
+ __setslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j, swig_dummy_type_inode_vector v)
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i)
+ __delitem__(swig_dummy_type_inode_vector self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(swig_dummy_type_inode_vector self, PySliceObject * slice) -> swig_dummy_type_inode_vector
+ __getitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i) -> INode
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(swig_dummy_type_inode_vector self, PySliceObject * slice, swig_dummy_type_inode_vector v)
+ __setitem__(swig_dummy_type_inode_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(swig_dummy_type_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_pop(self)
+
+ def append(self, x):
+ r"""append(swig_dummy_type_inode_vector self, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_append(self, x)
+
+ def empty(self):
+ r"""empty(swig_dummy_type_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_empty(self)
+
+ def size(self):
+ r"""size(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_size(self)
+
+ def swap(self, v):
+ r"""swap(swig_dummy_type_inode_vector self, swig_dummy_type_inode_vector v)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_swap(self, v)
+
+ def begin(self):
+ r"""begin(swig_dummy_type_inode_vector self) -> std::vector< INode * >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_begin(self)
+
+ def end(self):
+ r"""end(swig_dummy_type_inode_vector self) -> std::vector< INode * >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_end(self)
+
+ def rbegin(self):
+ r"""rbegin(swig_dummy_type_inode_vector self) -> std::vector< INode * >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_rbegin(self)
+
+ def rend(self):
+ r"""rend(swig_dummy_type_inode_vector self) -> std::vector< INode * >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_rend(self)
+
+ def clear(self):
+ r"""clear(swig_dummy_type_inode_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(swig_dummy_type_inode_vector self) -> std::vector< INode * >::allocator_type"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(swig_dummy_type_inode_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos) -> std::vector< INode * >::iterator
+ erase(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator first, std::vector< INode * >::iterator last) -> std::vector< INode * >::iterator
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(swig_dummy_type_inode_vector self) -> swig_dummy_type_inode_vector
+ __init__(swig_dummy_type_inode_vector self, swig_dummy_type_inode_vector other) -> swig_dummy_type_inode_vector
+ __init__(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type size) -> swig_dummy_type_inode_vector
+ __init__(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type size, INode value) -> swig_dummy_type_inode_vector
+ """
+ _libBornAgainCore.swig_dummy_type_inode_vector_swiginit(self, _libBornAgainCore.new_swig_dummy_type_inode_vector(*args))
+
+ def push_back(self, x):
+ r"""push_back(swig_dummy_type_inode_vector self, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_push_back(self, x)
+
+ def front(self):
+ r"""front(swig_dummy_type_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_front(self)
+
+ def back(self):
+ r"""back(swig_dummy_type_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_back(self)
+
+ def assign(self, n, x):
+ r"""assign(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type n, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type new_size)
+ resize(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type new_size, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos, INode x) -> std::vector< INode * >::iterator
+ insert(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos, std::vector< INode * >::size_type n, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_inode_vector_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type n)"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_inode_vector_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_swig_dummy_type_inode_vector
+
+# Register swig_dummy_type_inode_vector in _libBornAgainCore:
+_libBornAgainCore.swig_dummy_type_inode_vector_swigregister(swig_dummy_type_inode_vector)
+
+class swig_dummy_type_const_inode_vector(object):
+ r"""Proxy of C++ std::vector< INode const * > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(swig_dummy_type_const_inode_vector self) -> SwigPyIterator"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(swig_dummy_type_const_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(swig_dummy_type_const_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___bool__(self)
+
+ def __len__(self):
+ r"""__len__(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j) -> swig_dummy_type_const_inode_vector"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)
+ __setslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j, swig_dummy_type_const_inode_vector v)
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)
+ __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)
+ __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector___setitem__(self, *args)
+
+ def pop(self):
+ r"""pop(swig_dummy_type_const_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_pop(self)
+
+ def append(self, x):
+ r"""append(swig_dummy_type_const_inode_vector self, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_append(self, x)
+
+ def empty(self):
+ r"""empty(swig_dummy_type_const_inode_vector self) -> bool"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_empty(self)
+
+ def size(self):
+ r"""size(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_size(self)
+
+ def swap(self, v):
+ r"""swap(swig_dummy_type_const_inode_vector self, swig_dummy_type_const_inode_vector v)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_swap(self, v)
+
+ def begin(self):
+ r"""begin(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_begin(self)
+
+ def end(self):
+ r"""end(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::iterator"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_end(self)
+
+ def rbegin(self):
+ r"""rbegin(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_rbegin(self)
+
+ def rend(self):
+ r"""rend(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::reverse_iterator"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_rend(self)
+
+ def clear(self):
+ r"""clear(swig_dummy_type_const_inode_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_clear(self)
+
+ def get_allocator(self):
+ r"""get_allocator(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::allocator_type"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_get_allocator(self)
+
+ def pop_back(self):
+ r"""pop_back(swig_dummy_type_const_inode_vector self)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_pop_back(self)
+
+ def erase(self, *args):
+ r"""
+ erase(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos) -> std::vector< INode const * >::iterator
+ erase(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator first, std::vector< INode const * >::iterator last) -> std::vector< INode const * >::iterator
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_erase(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(swig_dummy_type_const_inode_vector self) -> swig_dummy_type_const_inode_vector
+ __init__(swig_dummy_type_const_inode_vector self, swig_dummy_type_const_inode_vector other) -> swig_dummy_type_const_inode_vector
+ __init__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type size) -> swig_dummy_type_const_inode_vector
+ __init__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type size, INode value) -> swig_dummy_type_const_inode_vector
+ """
+ _libBornAgainCore.swig_dummy_type_const_inode_vector_swiginit(self, _libBornAgainCore.new_swig_dummy_type_const_inode_vector(*args))
+
+ def push_back(self, x):
+ r"""push_back(swig_dummy_type_const_inode_vector self, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_push_back(self, x)
+
+ def front(self):
+ r"""front(swig_dummy_type_const_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_front(self)
+
+ def back(self):
+ r"""back(swig_dummy_type_const_inode_vector self) -> INode"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_back(self)
+
+ def assign(self, n, x):
+ r"""assign(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type n, INode x)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_assign(self, n, x)
+
+ def resize(self, *args):
+ r"""
+ resize(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type new_size)
+ resize(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type new_size, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_resize(self, *args)
+
+ def insert(self, *args):
+ r"""
+ insert(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos, INode x) -> std::vector< INode const * >::iterator
+ insert(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos, std::vector< INode const * >::size_type n, INode x)
+ """
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_insert(self, *args)
+
+ def reserve(self, n):
+ r"""reserve(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type n)"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_reserve(self, n)
+
+ def capacity(self):
+ r"""capacity(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
+ return _libBornAgainCore.swig_dummy_type_const_inode_vector_capacity(self)
+ __swig_destroy__ = _libBornAgainCore.delete_swig_dummy_type_const_inode_vector
+
+# Register swig_dummy_type_const_inode_vector in _libBornAgainCore:
+_libBornAgainCore.swig_dummy_type_const_inode_vector_swigregister(swig_dummy_type_const_inode_vector)
+
+
+def GetMajorVersionNumber():
+ r"""GetMajorVersionNumber() -> int"""
+ return _libBornAgainCore.GetMajorVersionNumber()
+
+def GetMinorVersionNumber():
+ r"""GetMinorVersionNumber() -> int"""
+ return _libBornAgainCore.GetMinorVersionNumber()
+
+def GetPatchVersionNumber():
+ r"""GetPatchVersionNumber() -> int"""
+ return _libBornAgainCore.GetPatchVersionNumber()
+
+def GetName():
+ r"""GetName() -> std::string"""
+ return _libBornAgainCore.GetName()
+
+def GetVersionNumber():
+ r"""GetVersionNumber() -> std::string"""
+ return _libBornAgainCore.GetVersionNumber()
+class IterationInfo(object):
+ r"""
+
+
+ Stores fit iteration info to track fit flow from various observers. Used in context of FitObjective.
+
+ C++ includes: IterationInfo.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self):
+ r"""
+ __init__(IterationInfo self) -> IterationInfo
+ IterationInfo::IterationInfo()
+
+ """
+ _libBornAgainCore.IterationInfo_swiginit(self, _libBornAgainCore.new_IterationInfo())
+
+ def update(self, params, chi2):
+ r"""
+ update(IterationInfo self, mumufit::Parameters const & params, double chi2)
+ void IterationInfo::update(const mumufit::Parameters ¶ms, double chi2)
+
+ """
+ return _libBornAgainCore.IterationInfo_update(self, params, chi2)
+
+ def iterationCount(self):
+ r"""
+ iterationCount(IterationInfo self) -> unsigned int
+ unsigned IterationInfo::iterationCount() const
+
+ Returns current number of minimizer iterations.
+
+ """
+ return _libBornAgainCore.IterationInfo_iterationCount(self)
+
+ def chi2(self):
+ r"""
+ chi2(IterationInfo self) -> double
+ double IterationInfo::chi2() const
+
+ """
+ return _libBornAgainCore.IterationInfo_chi2(self)
+
+ def parameters(self):
+ r"""
+ parameters(IterationInfo self) -> mumufit::Parameters
+ mumufit::Parameters IterationInfo::parameters() const
+
+ """
+ return _libBornAgainCore.IterationInfo_parameters(self)
+
+ def parameterMap(self):
+ r"""
+ parameterMap(IterationInfo self) -> map_string_double_t
+ std::map< std::string, double > IterationInfo::parameterMap() const
+
+ Returns map of fit parameter names and its current values.
+
+ """
+ return _libBornAgainCore.IterationInfo_parameterMap(self)
+ __swig_destroy__ = _libBornAgainCore.delete_IterationInfo
+
+# Register IterationInfo in _libBornAgainCore:
+_libBornAgainCore.IterationInfo_swigregister(IterationInfo)
+cvar = _libBornAgainCore.cvar
+major_version_number = cvar.major_version_number
+minor_version_number = cvar.minor_version_number
+patch_version_number = cvar.patch_version_number
+
+class PyBuilderCallback(object):
+ r"""
+
+
+ Builds simulation object using a Python callable. Base class to wrap Python callable and pass it to C++. Used in swig interface file, intended to be overloaded from Python.
+
+ C++ includes: PyFittingCallbacks.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self):
+ r"""
+ __init__(PyBuilderCallback self) -> PyBuilderCallback
+ PyBuilderCallback::PyBuilderCallback()
+
+ """
+ if self.__class__ == PyBuilderCallback:
+ _self = None
+ else:
+ _self = self
+ _libBornAgainCore.PyBuilderCallback_swiginit(self, _libBornAgainCore.new_PyBuilderCallback(_self, ))
+ __swig_destroy__ = _libBornAgainCore.delete_PyBuilderCallback
+
+ def build_simulation(self, arg0):
+ r"""
+ build_simulation(PyBuilderCallback self, mumufit::Parameters const & arg0) -> ISimulation
+ ISimulation * PyBuilderCallback::build_simulation(const mumufit::Parameters &) const
+
+ """
+ return _libBornAgainCore.PyBuilderCallback_build_simulation(self, arg0)
+ def __disown__(self):
+ self.this.disown()
+ _libBornAgainCore.disown_PyBuilderCallback(self)
+ return weakref.proxy(self)
+
+# Register PyBuilderCallback in _libBornAgainCore:
+_libBornAgainCore.PyBuilderCallback_swigregister(PyBuilderCallback)
+
+class PyObserverCallback(object):
+ r"""
+
+
+ Observer for FitObjective based on Python callable. Base class to wrap Python callable and pass it to C++. Used in swig interface file, intended to be overloaded from Python.
+
+ C++ includes: PyFittingCallbacks.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self):
+ r"""
+ __init__(PyObserverCallback self) -> PyObserverCallback
+ PyObserverCallback::PyObserverCallback()
+
+ """
+ if self.__class__ == PyObserverCallback:
+ _self = None
+ else:
+ _self = self
+ _libBornAgainCore.PyObserverCallback_swiginit(self, _libBornAgainCore.new_PyObserverCallback(_self, ))
+ __swig_destroy__ = _libBornAgainCore.delete_PyObserverCallback
+
+ def update(self, arg0):
+ r"""
+ update(PyObserverCallback self, FitObjective arg0)
+ void PyObserverCallback::update(const FitObjective &)
+
+ """
+ return _libBornAgainCore.PyObserverCallback_update(self, arg0)
+ def __disown__(self):
+ self.this.disown()
+ _libBornAgainCore.disown_PyObserverCallback(self)
+ return weakref.proxy(self)
+
+# Register PyObserverCallback in _libBornAgainCore:
+_libBornAgainCore.PyObserverCallback_swigregister(PyObserverCallback)
+
+class FitObjective(object):
+ r"""
+
+
+ Holds vector of SimDataPairs (experimental data and simulation results) for use in fitting. Thereby supports simultaneous fitting of several data sets and model functions, as demonstrated in example fit52/multiple_datasets.
+
+ C++ includes: FitObjective.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self):
+ r"""
+ __init__(FitObjective self) -> FitObjective
+ FitObjective::FitObjective()
+
+ """
+ if self.__class__ == FitObjective:
+ _self = None
+ else:
+ _self = self
+ _libBornAgainCore.FitObjective_swiginit(self, _libBornAgainCore.new_FitObjective(_self, ))
+ __swig_destroy__ = _libBornAgainCore.delete_FitObjective
+
+ def addSimulationAndData_cpp(self, *args):
+ r"""
+ addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble2d_t data, double weight=1.0)
+ addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble1d_t data, double weight=1.0)
+ addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble2d_t data, vdouble2d_t stdv, double weight=1.0)
+ addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble1d_t data, vdouble1d_t stdv, double weight=1.0)
+ void FitObjective::addSimulationAndData(const PyBuilderCallback &callback, const std::vector< double > &data, const std::vector< double > &stdv, double weight=1.0)
+
+ """
+ return _libBornAgainCore.FitObjective_addSimulationAndData_cpp(self, *args)
+
+ def evaluate_cpp(self, params):
+ r"""
+ evaluate_cpp(FitObjective self, mumufit::Parameters const & params) -> double
+ double FitObjective::evaluate(const mumufit::Parameters ¶ms)
+
+ """
+ return _libBornAgainCore.FitObjective_evaluate_cpp(self, params)
+
+ def evaluate_residuals_cpp(self, params):
+ r"""
+ evaluate_residuals_cpp(FitObjective self, mumufit::Parameters const & params) -> vdouble1d_t
+ std::vector< double > FitObjective::evaluate_residuals(const mumufit::Parameters ¶ms)
+
+ """
+ return _libBornAgainCore.FitObjective_evaluate_residuals_cpp(self, params)
+
+ def simulationResult(self, i_item=0):
+ r"""
+ simulationResult(FitObjective self, size_t i_item=0) -> SimulationResult
+ SimulationResult FitObjective::simulationResult(size_t i_item=0) const
+
+ Returns simulation result in the form of SimulationResult.
+
+ """
+ return _libBornAgainCore.FitObjective_simulationResult(self, i_item)
+
+ def experimentalData(self, i_item=0):
+ r"""
+ experimentalData(FitObjective self, size_t i_item=0) -> SimulationResult
+ SimulationResult FitObjective::experimentalData(size_t i_item=0) const
+
+ Returns experimental data in the form of SimulationResult.
+
+ """
+ return _libBornAgainCore.FitObjective_experimentalData(self, i_item)
+
+ def uncertaintyData_cpp(self, i_item=0):
+ r"""
+ uncertaintyData_cpp(FitObjective self, size_t i_item=0) -> SimulationResult
+ SimulationResult FitObjective::uncertaintyData(size_t i_item=0) const
+
+ Returns experimental data uncertainties in the form of SimulationResult.
+
+ """
+ return _libBornAgainCore.FitObjective_uncertaintyData_cpp(self, i_item)
+
+ def relativeDifference(self, i_item=0):
+ r"""
+ relativeDifference(FitObjective self, size_t i_item=0) -> SimulationResult
+ SimulationResult FitObjective::relativeDifference(size_t i_item=0) const
+
+ Returns relative difference between simulation and experimental data in the form of SimulationResult.
+
+ """
+ return _libBornAgainCore.FitObjective_relativeDifference(self, i_item)
+
+ def absoluteDifference(self, i_item=0):
+ r"""
+ absoluteDifference(FitObjective self, size_t i_item=0) -> SimulationResult
+ SimulationResult FitObjective::absoluteDifference(size_t i_item=0) const
+
+ Returns absolute value of difference between simulation and experimental data in the form of SimulationResult.
+
+ """
+ return _libBornAgainCore.FitObjective_absoluteDifference(self, i_item)
+
+ def experimental_array(self):
+ r"""
+ experimental_array(FitObjective self) -> vdouble1d_t
+ std::vector< double > FitObjective::experimental_array() const
+
+ Returns one dimensional array representing merged experimental data. The area outside of the region of interest is not included, masked data is nullified.
+
+ """
+ return _libBornAgainCore.FitObjective_experimental_array(self)
+
+ def simulation_array(self):
+ r"""
+ simulation_array(FitObjective self) -> vdouble1d_t
+ std::vector< double > FitObjective::simulation_array() const
+
+ Returns one dimensional array representing merged simulated intensities data. The area outside of the region of interest is not included, masked data is nullified.
+
+ """
+ return _libBornAgainCore.FitObjective_simulation_array(self)
+
+ def uncertainties_cpp(self):
+ r"""
+ uncertainties_cpp(FitObjective self) -> vdouble1d_t
+ std::vector< double > FitObjective::uncertainties() const
+
+ Returns one-dimensional array representing merged data uncertainties. The area outside of the region of interest is not included, masked data is nullified.
+
+ """
+ return _libBornAgainCore.FitObjective_uncertainties_cpp(self)
+
+ def weights_array(self):
+ r"""
+ weights_array(FitObjective self) -> vdouble1d_t
+ std::vector< double > FitObjective::weights_array() const
+
+ Returns one-dimensional array representing merged user weights. The area outside of the region of interest is not included, masked data is nullified.
+
+ """
+ return _libBornAgainCore.FitObjective_weights_array(self)
+
+ def initPrint(self, every_nth):
+ r"""
+ initPrint(FitObjective self, int every_nth)
+ void FitObjective::initPrint(int every_nth)
+
+ Initializes printing to standard output on every_nth fit iteration.
+
+ """
+ return _libBornAgainCore.FitObjective_initPrint(self, every_nth)
+
+ def initPlot_cpp(self, every_nth, callback):
+ r"""
+ initPlot_cpp(FitObjective self, int every_nth, PyObserverCallback callback)
+ void FitObjective::initPlot(int every_nth, fit_observer_t &&observer)
+
+ """
+ return _libBornAgainCore.FitObjective_initPlot_cpp(self, every_nth, callback)
+
+ def iterationInfo(self):
+ r"""
+ iterationInfo(FitObjective self) -> IterationInfo
+ IterationInfo FitObjective::iterationInfo() const
+
+ """
+ return _libBornAgainCore.FitObjective_iterationInfo(self)
+
+ def minimizerResult(self):
+ r"""
+ minimizerResult(FitObjective self) -> mumufit::MinimizerResult
+ mumufit::MinimizerResult FitObjective::minimizerResult() const
+
+ """
+ return _libBornAgainCore.FitObjective_minimizerResult(self)
+
+ def finalize_cpp(self, result):
+ r"""
+ finalize_cpp(FitObjective self, mumufit::MinimizerResult const & result)
+ void FitObjective::finalize(const mumufit::MinimizerResult &result)
+
+ Should be explicitly called on last iteration to notify all observers.
+
+ """
+ return _libBornAgainCore.FitObjective_finalize_cpp(self, result)
+
+ def fitObjectCount(self):
+ r"""
+ fitObjectCount(FitObjective self) -> unsigned int
+ unsigned FitObjective::fitObjectCount() const
+
+ """
+ return _libBornAgainCore.FitObjective_fitObjectCount(self)
+
+ def execSimulations(self, params):
+ r"""
+ execSimulations(FitObjective self, mumufit::Parameters const & params)
+ void FitObjective::execSimulations(const mumufit::Parameters ¶ms)
+
+ """
+ return _libBornAgainCore.FitObjective_execSimulations(self, params)
+
+ def setChiSquaredModule(self, module):
+ r"""
+ setChiSquaredModule(FitObjective self, IChiSquaredModule module)
+ void FitObjective::setChiSquaredModule(const IChiSquaredModule &module)
+
+ """
+ return _libBornAgainCore.FitObjective_setChiSquaredModule(self, module)
+
+ def setObjectiveMetric(self, *args):
+ r"""
+ setObjectiveMetric(FitObjective self, std::string const & metric)
+ setObjectiveMetric(FitObjective self, std::string const & metric, std::string const & norm)
+ void FitObjective::setObjectiveMetric(std::unique_ptr< ObjectiveMetric > metric)
+
+ """
+ return _libBornAgainCore.FitObjective_setObjectiveMetric(self, *args)
+
+ def containsUncertainties_cpp(self, i_item):
+ r"""
+ containsUncertainties_cpp(FitObjective self, size_t i_item) -> bool
+ bool FitObjective::containsUncertainties(size_t i_item) const
+
+ Returns true if the specified DataPair element contains uncertainties.
+
+ """
+ return _libBornAgainCore.FitObjective_containsUncertainties_cpp(self, i_item)
+
+ def allPairsHaveUncertainties_cpp(self):
+ r"""
+ allPairsHaveUncertainties_cpp(FitObjective self) -> bool
+ bool FitObjective::allPairsHaveUncertainties() const
+
+ Returns true if all the data pairs in FitObjective instance contain uncertainties.
+
+ """
+ return _libBornAgainCore.FitObjective_allPairsHaveUncertainties_cpp(self)
+
+ @staticmethod
+ def availableMetricOptions():
+ r"""availableMetricOptions() -> std::string"""
+ return _libBornAgainCore.FitObjective_availableMetricOptions()
+
+ def addSimulationAndData(self, callback, data, *args, **kwargs):
+ """
+ Sets simulation and experimental data to the fit objective.
+ Optionally accepts experimental data uncertainties and
+ user-defined dataset weight.
+
+ Arguments:
+
+ callback -- user-defined function returning fully-defined bornagain.ISimulation object.
+ The function must use fit parameter dictionary as its input.
+
+ data -- numpy array with experimental data.
+
+ uncertainties -- numpy array with experimental data uncertainties.
+ Array shape must correspond to the shape of data. Optional argument.
+
+ weight -- user-defined weight of the dataset. If not specified, defaults to 1.0.
+ """
+ if not hasattr(self, 'callback_container'):
+ self.callback_container = []
+ wrp = SimulationBuilderWrapper(callback)
+ self.callback_container.append(wrp)
+ return self.addSimulationAndData_cpp(wrp, data, *args, **kwargs)
+
+ def convert_params(self, params):
+ """
+ Converts parameters to what FitObjective::evaluate expects
+ """
+
+ if str(params.__module__) == "lmfit.parameter":
+ bapars = libBornAgainFit.Parameters()
+ for p in params:
+ bapars.add(p, params[p].value)
+ return bapars
+ else:
+ return params
+
+ def evaluate_residuals(self, params):
+ return self.evaluate_residuals_cpp(self.convert_params(params))
+
+ def evaluate(self, params):
+ return self.evaluate_cpp(self.convert_params(params))
+
+ def convert_result(self, minim_result):
+ """
+ Converts result reported by arbitrary minimizer to ba.MinimizerResult
+ """
+
+ if str(minim_result.__module__) == "lmfit.minimizer":
+ return libBornAgainFit.MinimizerResult()
+ else:
+ return minim_result
+
+ def finalize(self, minimizer_result):
+ return self.finalize_cpp(self.convert_result(minimizer_result))
+
+ def initPlot(self, every_nth, callback):
+ self.wrp_plot_observer = ObserverCallbackWrapper(callback)
+ return self.initPlot_cpp(every_nth, self.wrp_plot_observer)
+
+ def uncertainties(self):
+ """
+ Returns one-dimensional array representing merged data uncertainties.
+ If any of the associated data pairs lack uncertainties, returns None.
+ """
+ if self.allPairsHaveUncertainties_cpp():
+ return self.uncertainties_cpp()
+ return None
+
+ def uncertaintyData(self, i=0):
+ """
+ Returns uncertainties for i-th simulation-data pair. If
+ no uncertainties are assigned to the data pair, returns
+ None.
+ """
+ if self.containsUncertainties_cpp(i):
+ return self.uncertaintyData_cpp(i)
+ return None
+
+ def __disown__(self):
+ self.this.disown()
+ _libBornAgainCore.disown_FitObjective(self)
+ return weakref.proxy(self)
+
+# Register FitObjective in _libBornAgainCore:
+_libBornAgainCore.FitObjective_swigregister(FitObjective)
+
+def FitObjective_availableMetricOptions():
+ r"""FitObjective_availableMetricOptions() -> std::string"""
+ return _libBornAgainCore.FitObjective_availableMetricOptions()
+
+class AlphaScan(object):
+ r"""
+
+
+ Scan type with inclination angles as coordinate values and a unique wavelength. Features footprint correction.
+
+ C++ includes: AlphaScan.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(AlphaScan self, double wl, vdouble1d_t inc_angle) -> AlphaScan
+ __init__(AlphaScan self, double wl, IAxis inc_angle) -> AlphaScan
+ __init__(AlphaScan self, double wl, int nbins, double alpha_i_min, double alpha_i_max) -> AlphaScan
+ AlphaScan::AlphaScan(double wl, int nbins, double alpha_i_min, double alpha_i_max)
+
+ Sets angle-defined specular scan. The first parameter is always a wavelength in nm. Second parameter is either a numpy array of incident angles in radians or an IAxis object with angle values. Alternatively an axis can be defined in-place, then the second passed parameter is the number of bins, third - minimum on-axis angle value, fourth - maximum on-axis angle value.
+
+ """
+ _libBornAgainCore.AlphaScan_swiginit(self, _libBornAgainCore.new_AlphaScan(*args))
+ __swig_destroy__ = _libBornAgainCore.delete_AlphaScan
+
+ def clone(self):
+ r"""
+ clone(AlphaScan self) -> AlphaScan
+ AlphaScan * AlphaScan::clone() const override
+
+ """
+ return _libBornAgainCore.AlphaScan_clone(self)
+
+ def setFootprintFactor(self, f_factor):
+ r"""
+ setFootprintFactor(AlphaScan self, IFootprintFactor const * f_factor)
+ void AlphaScan::setFootprintFactor(const IFootprintFactor *f_factor)
+
+ Sets footprint correction factor.
+
+ """
+ return _libBornAgainCore.AlphaScan_setFootprintFactor(self, f_factor)
+
+ def setWavelengthResolution(self, resolution):
+ r"""
+ setWavelengthResolution(AlphaScan self, ScanResolution const & resolution)
+ void AlphaScan::setWavelengthResolution(const ScanResolution &resolution)
+
+ Sets wavelength resolution values via ScanResolution object.
+
+ """
+ return _libBornAgainCore.AlphaScan_setWavelengthResolution(self, resolution)
+
+ def setRelativeWavelengthResolution(self, *args):
+ r"""
+ setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)
+ setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+
+ Sets wavelength resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
+
+ """
+ return _libBornAgainCore.AlphaScan_setRelativeWavelengthResolution(self, *args)
+
+ def setAbsoluteWavelengthResolution(self, *args):
+ r"""
+ setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)
+ setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+
+ Sets wavelength resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
+
+ """
+ return _libBornAgainCore.AlphaScan_setAbsoluteWavelengthResolution(self, *args)
+
+ def setAngleResolution(self, resolution):
+ r"""
+ setAngleResolution(AlphaScan self, ScanResolution const & resolution)
+ void AlphaScan::setAngleResolution(const ScanResolution &resolution)
+
+ Sets angle resolution values via ScanResolution object.
+
+ """
+ return _libBornAgainCore.AlphaScan_setAngleResolution(self, resolution)
+
+ def setRelativeAngularResolution(self, *args):
+ r"""
+ setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)
+ setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+
+ Sets angular resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
+
+ """
+ return _libBornAgainCore.AlphaScan_setRelativeAngularResolution(self, *args)
+
+ def setAbsoluteAngularResolution(self, *args):
+ r"""
+ setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)
+ setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+
+ Sets angular resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
+
+ """
+ return _libBornAgainCore.AlphaScan_setAbsoluteAngularResolution(self, *args)
+
+# Register AlphaScan in _libBornAgainCore:
+_libBornAgainCore.AlphaScan_swigregister(AlphaScan)
+
+class QzScan(object):
+ r"""
+
+
+ Scan type with z-components of scattering vector as coordinate values. Wavelength and incident angles are not accessible separately.
+
+ C++ includes: QzScan.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(QzScan self, vdouble1d_t qs_nm) -> QzScan
+ __init__(QzScan self, IAxis qs_nm) -> QzScan
+ __init__(QzScan self, int nbins, double qz_min, double qz_max) -> QzScan
+ QzScan::QzScan(int nbins, double qz_min, double qz_max)
+
+ Sets q-defined specular scan. Accepts either numpy array of q-values sorted in ascending order or an IAxis object with q-values. Alternatively an axis can be defined in-place, then the first passed parameter is the number of bins, second - minimum on-axis q-value, third - maximum on-axis q_value.
+
+ """
+ _libBornAgainCore.QzScan_swiginit(self, _libBornAgainCore.new_QzScan(*args))
+ __swig_destroy__ = _libBornAgainCore.delete_QzScan
+
+ def clone(self):
+ r"""
+ clone(QzScan self) -> QzScan
+ QzScan * QzScan::clone() const override
+
+ """
+ return _libBornAgainCore.QzScan_clone(self)
+
+ def resolution(self):
+ r"""
+ resolution(QzScan self) -> ScanResolution const *
+ const ScanResolution* QzScan::resolution() const
+
+ """
+ return _libBornAgainCore.QzScan_resolution(self)
+
+ def setQResolution(self, resolution):
+ r"""
+ setQResolution(QzScan self, ScanResolution const & resolution)
+ void QzScan::setQResolution(const ScanResolution &resolution)
+
+ Sets q resolution values via ScanResolution object.
+
+ """
+ return _libBornAgainCore.QzScan_setQResolution(self, resolution)
+
+ def setRelativeQResolution(self, *args):
+ r"""
+ setRelativeQResolution(QzScan self, IRangedDistribution const & distr, double rel_dev)
+ setRelativeQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void QzScan::setRelativeQResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+
+ Sets qz resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
+
+ """
+ return _libBornAgainCore.QzScan_setRelativeQResolution(self, *args)
+
+ def setAbsoluteQResolution(self, *args):
+ r"""
+ setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, double std_dev)
+ setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+
+ Sets qz resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
+
+ """
+ return _libBornAgainCore.QzScan_setAbsoluteQResolution(self, *args)
+
+ def setOffset(self, offset):
+ r"""
+ setOffset(QzScan self, double offset)
+ void QzScan::setOffset(double offset)
+
+ """
+ return _libBornAgainCore.QzScan_setOffset(self, offset)
+
+ def offset(self):
+ r"""
+ offset(QzScan self) -> double
+ double QzScan::offset() const
+
+ """
+ return _libBornAgainCore.QzScan_offset(self)
+
+# Register QzScan in _libBornAgainCore:
+_libBornAgainCore.QzScan_swigregister(QzScan)
+
+class ISimulation(libBornAgainParam.INode):
+ r"""
+
+
+ Abstract base class of OffSpecularSimulation, GISASSimulation and SpecularSimulation. Holds the common infrastructure to run a simulation: multithreading, batch processing, weighting over parameter distributions, ...
+
+ C++ includes: ISimulation.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_ISimulation
+
+ def runSimulation(self):
+ r"""
+ runSimulation(ISimulation self)
+ void ISimulation::runSimulation()
+
+ Run a simulation, possibly averaged over parameter distributions.
+
+ Run simulation with possible averaging over parameter distributions.
+
+ """
+ return _libBornAgainCore.ISimulation_runSimulation(self)
+
+ def runMPISimulation(self):
+ r"""
+ runMPISimulation(ISimulation self)
+ void ISimulation::runMPISimulation()
+
+ Run a simulation in a MPI environment.
+
+ """
+ return _libBornAgainCore.ISimulation_runMPISimulation(self)
+
+ def instrument(self, *args):
+ r"""
+ instrument(ISimulation self) -> Instrument const
+ instrument(ISimulation self) -> Instrument &
+ Instrument& ISimulation::instrument()
+
+ """
+ return _libBornAgainCore.ISimulation_instrument(self, *args)
+
+ def beam(self, *args):
+ r"""
+ beam(ISimulation self) -> Beam
+ beam(ISimulation self) -> Beam const &
+ const Beam& ISimulation::beam() const
+
+ """
+ return _libBornAgainCore.ISimulation_beam(self, *args)
+
+ def detector(self, *args):
+ r"""
+ detector(ISimulation self) -> IDetector
+ detector(ISimulation self) -> IDetector const &
+ const IDetector& ISimulation::detector() const
+
+ """
+ return _libBornAgainCore.ISimulation_detector(self, *args)
+
+ def setSample(self, sample):
+ r"""
+ setSample(ISimulation self, MultiLayer const & sample)
+ void ISimulation::setSample(const MultiLayer &sample)
+
+ The MultiLayer object will not be owned by the ISimulation object.
+
+ """
+ return _libBornAgainCore.ISimulation_setSample(self, sample)
+
+ def sample(self):
+ r"""
+ sample(ISimulation self) -> MultiLayer const *
+ const MultiLayer * ISimulation::sample() const
+
+ """
+ return _libBornAgainCore.ISimulation_sample(self)
+
+ def setSampleBuilder(self, sample_builder):
+ r"""
+ setSampleBuilder(ISimulation self, std::shared_ptr< ISampleBuilder > const & sample_builder)
+ void ISimulation::setSampleBuilder(const std::shared_ptr< ISampleBuilder > &sample_builder)
+
+ """
+ return _libBornAgainCore.ISimulation_setSampleBuilder(self, sample_builder)
+
+ def setBackground(self, bg):
+ r"""
+ setBackground(ISimulation self, IBackground bg)
+ void ISimulation::setBackground(const IBackground &bg)
+
+ """
+ return _libBornAgainCore.ISimulation_setBackground(self, bg)
+
+ def background(self):
+ r"""
+ background(ISimulation self) -> IBackground
+ const IBackground* ISimulation::background() const
+
+ """
+ return _libBornAgainCore.ISimulation_background(self)
+
+ def intensityMapSize(self):
+ r"""
+ intensityMapSize(ISimulation self) -> size_t
+ virtual size_t ISimulation::intensityMapSize() const =0
+
+ Returns the total number of the intensity values in the simulation result.
+
+ """
+ return _libBornAgainCore.ISimulation_intensityMapSize(self)
+
+ def result(self):
+ r"""
+ result(ISimulation self) -> SimulationResult
+ virtual SimulationResult ISimulation::result() const =0
+
+ Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays
+
+ """
+ return _libBornAgainCore.ISimulation_result(self)
+
+ def addParameterDistribution(self, *args):
+ r"""
+ addParameterDistribution(ISimulation self, ParameterDistribution::WhichParameter whichParameter, IDistribution1D const & distribution, size_t nbr_samples, double sigma_factor=0.0, RealLimits const & limits=RealLimits())
+ addParameterDistribution(ISimulation self, ParameterDistribution par_distr)
+ void ISimulation::addParameterDistribution(const ParameterDistribution &par_distr)
+
+ """
+ return _libBornAgainCore.ISimulation_addParameterDistribution(self, *args)
+
+ def getDistributions(self):
+ r"""
+ getDistributions(ISimulation self) -> std::vector< ParameterDistribution,std::allocator< ParameterDistribution > > const &
+ const std::vector< ParameterDistribution > & ISimulation::getDistributions() const
+
+ """
+ return _libBornAgainCore.ISimulation_getDistributions(self)
+
+ def setOptions(self, options):
+ r"""
+ setOptions(ISimulation self, SimulationOptions const & options)
+ void ISimulation::setOptions(const SimulationOptions &options)
+
+ """
+ return _libBornAgainCore.ISimulation_setOptions(self, options)
+
+ def options(self, *args):
+ r"""
+ options(ISimulation self) -> SimulationOptions const
+ options(ISimulation self) -> SimulationOptions &
+ SimulationOptions & ISimulation::options()
+
+ """
+ return _libBornAgainCore.ISimulation_options(self, *args)
+
+ def subscribe(self, inform):
+ r"""
+ subscribe(ISimulation self, std::function< bool (size_t) > const & inform)
+ void ISimulation::subscribe(const std::function< bool(size_t)> &inform)
+
+ """
+ return _libBornAgainCore.ISimulation_subscribe(self, inform)
+
+ def setTerminalProgressMonitor(self):
+ r"""
+ setTerminalProgressMonitor(ISimulation self)
+ void ISimulation::setTerminalProgressMonitor()
+
+ Initializes a progress monitor that prints to stdout.
+
+ """
+ return _libBornAgainCore.ISimulation_setTerminalProgressMonitor(self)
+
+ def getChildren(self):
+ r"""
+ getChildren(ISimulation self) -> swig_dummy_type_const_inode_vector
+ std::vector< const INode * > ISimulation::getChildren() const
+
+ """
+ return _libBornAgainCore.ISimulation_getChildren(self)
+
+ def unitOfParameter(self, which):
+ r"""
+ unitOfParameter(ISimulation self, ParameterDistribution::WhichParameter which) -> std::string
+ std::string ISimulation::unitOfParameter(ParameterDistribution::WhichParameter which) const
+
+ """
+ return _libBornAgainCore.ISimulation_unitOfParameter(self, which)
+
+# Register ISimulation in _libBornAgainCore:
+_libBornAgainCore.ISimulation_swigregister(ISimulation)
+
+class ISimulation2D(ISimulation):
+ r"""
+
+
+ Abstract base class of OffSpecularSimulation and GISASSimulation. Holds the common implementations for simulations with a 2D detector
+
+ C++ includes: ISimulation2D.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_ISimulation2D
+
+ def detector2D(self, *args):
+ r"""
+ detector2D(ISimulation2D self) -> IDetector2D
+ detector2D(ISimulation2D self) -> IDetector2D const &
+ const IDetector2D & ISimulation2D::detector2D() const
+
+ """
+ return _libBornAgainCore.ISimulation2D_detector2D(self, *args)
+
+ def setDetectorParameters(self, n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max):
+ r"""
+ setDetectorParameters(ISimulation2D self, size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max)
+ void ISimulation2D::setDetectorParameters(size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max)
+
+ Sets spherical detector parameters using angle ranges
+
+ Parameters:
+ -----------
+
+ n_phi:
+ number of phi-axis bins
+
+ phi_min:
+ low edge of first phi-bin
+
+ phi_max:
+ upper edge of last phi-bin
+
+ n_alpha:
+ number of alpha-axis bins
+
+ alpha_min:
+ low edge of first alpha-bin
+
+ alpha_max:
+ upper edge of last alpha-bin
+
+ """
+ return _libBornAgainCore.ISimulation2D_setDetectorParameters(self, n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max)
+
+ def setDetector(self, detector):
+ r"""
+ setDetector(ISimulation2D self, IDetector2D const & detector)
+ void ISimulation2D::setDetector(const IDetector2D &detector)
+
+ Sets the detector (axes can be overwritten later)
+
+ """
+ return _libBornAgainCore.ISimulation2D_setDetector(self, detector)
+
+ def addMask(self, shape, mask_value=True):
+ r"""
+ addMask(ISimulation2D self, IShape2D const & shape, bool mask_value=True)
+ void ISimulation2D::addMask(const IShape2D &shape, bool mask_value=true)
+
+ Adds mask of given shape to the stack of detector masks. The mask value 'true' means that the channel will be excluded from the simulation. The mask which is added last has priority.
+
+ Parameters:
+ -----------
+
+ shape:
+ The shape of mask (Rectangle, Polygon, Line, Ellipse)
+
+ mask_value:
+ The value of mask
+
+ """
+ return _libBornAgainCore.ISimulation2D_addMask(self, shape, mask_value)
+
+ def maskAll(self):
+ r"""
+ maskAll(ISimulation2D self)
+ void ISimulation2D::maskAll()
+
+ Put the mask for all detector channels (i.e. exclude whole detector from the analysis)
+
+ """
+ return _libBornAgainCore.ISimulation2D_maskAll(self)
+
+ def setRegionOfInterest(self, xlow, ylow, xup, yup):
+ r"""
+ setRegionOfInterest(ISimulation2D self, double xlow, double ylow, double xup, double yup)
+ void ISimulation2D::setRegionOfInterest(double xlow, double ylow, double xup, double yup)
+
+ Sets rectangular region of interest with lower left and upper right corners defined.
+
+ """
+ return _libBornAgainCore.ISimulation2D_setRegionOfInterest(self, xlow, ylow, xup, yup)
+
+# Register ISimulation2D in _libBornAgainCore:
+_libBornAgainCore.ISimulation2D_swigregister(ISimulation2D)
+
+class GISASSimulation(ISimulation2D):
+ r"""
+
+
+ Main class to run a Grazing-Incidence Small-Angle Scattering simulation.
+
+ C++ includes: GISASSimulation.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.GISASSimulation_class_name
+
+
+ def className(self):
+ r"""
+ className(GISASSimulation self) -> std::string
+ std::string GISASSimulation::className() const final
+
+ """
+ return _libBornAgainCore.GISASSimulation_className(self)
+
+ def __init__(self, *args):
+ r"""
+ __init__(GISASSimulation self, Beam const & beam, MultiLayer const & sample, IDetector const & detector) -> GISASSimulation
+ __init__(GISASSimulation self) -> GISASSimulation
+ GISASSimulation::GISASSimulation()
+
+ """
+ _libBornAgainCore.GISASSimulation_swiginit(self, _libBornAgainCore.new_GISASSimulation(*args))
+ __swig_destroy__ = _libBornAgainCore.delete_GISASSimulation
+
+ def accept(self, visitor):
+ r"""
+ accept(GISASSimulation self, INodeVisitor * visitor)
+ void GISASSimulation::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.GISASSimulation_accept(self, visitor)
+
+ def result(self):
+ r"""
+ result(GISASSimulation self) -> SimulationResult
+ SimulationResult GISASSimulation::result() const override
+
+ Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays
+
+ """
+ return _libBornAgainCore.GISASSimulation_result(self)
+
+ def setBeamParameters(self, wavelength, alpha_i, phi_i):
+ r"""
+ setBeamParameters(GISASSimulation self, double wavelength, double alpha_i, double phi_i)
+ void GISASSimulation::setBeamParameters(double wavelength, double alpha_i, double phi_i)
+
+ Sets beam parameters from here (forwarded to Instrument)
+
+ """
+ return _libBornAgainCore.GISASSimulation_setBeamParameters(self, wavelength, alpha_i, phi_i)
+
+ def intensityMapSize(self):
+ r"""
+ intensityMapSize(GISASSimulation self) -> size_t
+ size_t GISASSimulation::intensityMapSize() const override
+
+ Returns the total number of the intensity values in the simulation result.
+
+ """
+ return _libBornAgainCore.GISASSimulation_intensityMapSize(self)
+
+# Register GISASSimulation in _libBornAgainCore:
+_libBornAgainCore.GISASSimulation_swigregister(GISASSimulation)
+
+class DepthProbeSimulation(ISimulation):
+ r"""Proxy of C++ DepthProbeSimulation class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.DepthProbeSimulation_class_name
+
+
+ def className(self):
+ r"""
+ className(DepthProbeSimulation self) -> std::string
+ std::string DepthProbeSimulation::className() const final
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_className(self)
+
+ def __init__(self):
+ r"""
+ __init__(DepthProbeSimulation self) -> DepthProbeSimulation
+ DepthProbeSimulation::DepthProbeSimulation()
+
+ """
+ _libBornAgainCore.DepthProbeSimulation_swiginit(self, _libBornAgainCore.new_DepthProbeSimulation())
+ __swig_destroy__ = _libBornAgainCore.delete_DepthProbeSimulation
+
+ def accept(self, visitor):
+ r"""
+ accept(DepthProbeSimulation self, INodeVisitor * visitor)
+ void DepthProbeSimulation::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_accept(self, visitor)
+
+ def result(self):
+ r"""
+ result(DepthProbeSimulation self) -> SimulationResult
+ SimulationResult DepthProbeSimulation::result() const override
+
+ Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_result(self)
+
+ def setBeamParameters(self, _lambda, nbins, alpha_i_min, alpha_i_max, beam_shape=None):
+ r"""
+ setBeamParameters(DepthProbeSimulation self, double _lambda, int nbins, double alpha_i_min, double alpha_i_max, IFootprintFactor const * beam_shape=None)
+ void DepthProbeSimulation::setBeamParameters(double lambda, int nbins, double alpha_i_min, double alpha_i_max, const IFootprintFactor *beam_shape=nullptr)
+
+ Sets beam parameters with alpha_i of the beam defined in the range.
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_setBeamParameters(self, _lambda, nbins, alpha_i_min, alpha_i_max, beam_shape)
+
+ def setZSpan(self, n_bins, z_min, z_max):
+ r"""
+ setZSpan(DepthProbeSimulation self, size_t n_bins, double z_min, double z_max)
+ void DepthProbeSimulation::setZSpan(size_t n_bins, double z_min, double z_max)
+
+ Set z positions for intensity calculations. Negative z's correspond to the area under sample surface. The more negative z is, the deeper layer corresponds to it.
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_setZSpan(self, n_bins, z_min, z_max)
+
+ def getAlphaAxis(self):
+ r"""
+ getAlphaAxis(DepthProbeSimulation self) -> IAxis
+ const IAxis * DepthProbeSimulation::getAlphaAxis() const
+
+ Returns a pointer to incident angle axis.
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_getAlphaAxis(self)
+
+ def getZAxis(self):
+ r"""
+ getZAxis(DepthProbeSimulation self) -> IAxis
+ const IAxis * DepthProbeSimulation::getZAxis() const
+
+ Returns a pointer to z-position axis.
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_getZAxis(self)
+
+ def intensityMapSize(self):
+ r"""
+ intensityMapSize(DepthProbeSimulation self) -> size_t
+ size_t DepthProbeSimulation::intensityMapSize() const override
+
+ Returns the total number of the intensity values in the simulation result.
+
+ """
+ return _libBornAgainCore.DepthProbeSimulation_intensityMapSize(self)
+
+# Register DepthProbeSimulation in _libBornAgainCore:
+_libBornAgainCore.DepthProbeSimulation_swigregister(DepthProbeSimulation)
+
+class SpecularSimulation(ISimulation):
+ r"""
+
+
+ Main class to run a specular simulation.
+
+ C++ includes: SpecularSimulation.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.SpecularSimulation_class_name
+
+
+ def className(self):
+ r"""
+ className(SpecularSimulation self) -> std::string
+ std::string SpecularSimulation::className() const final
+
+ """
+ return _libBornAgainCore.SpecularSimulation_className(self)
+ __swig_destroy__ = _libBornAgainCore.delete_SpecularSimulation
+
+ def __init__(self, *args):
+ r"""
+ __init__(SpecularSimulation self) -> SpecularSimulation
+ __init__(SpecularSimulation self, SpecularSimulation arg2) -> SpecularSimulation
+ SpecularSimulation::SpecularSimulation(SpecularSimulation &&)
+
+ """
+ _libBornAgainCore.SpecularSimulation_swiginit(self, _libBornAgainCore.new_SpecularSimulation(*args))
+
+ def prepareSimulation(self):
+ r"""
+ prepareSimulation(SpecularSimulation self)
+ void SpecularSimulation::prepareSimulation() override
+
+ Put into a clean state for running a simulation.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_prepareSimulation(self)
+
+ def accept(self, visitor):
+ r"""
+ accept(SpecularSimulation self, INodeVisitor * visitor)
+ void SpecularSimulation::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.SpecularSimulation_accept(self, visitor)
+
+ def result(self):
+ r"""
+ result(SpecularSimulation self) -> SimulationResult
+ SimulationResult SpecularSimulation::result() const override
+
+ Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays. If simulation was not run, returns an array of proper size filled with zeros.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_result(self)
+
+ def setScan(self, scan):
+ r"""
+ setScan(SpecularSimulation self, ISpecularScan const & scan)
+ void SpecularSimulation::setScan(const ISpecularScan &scan)
+
+ Sets chosen specular scan to the simulation.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_setScan(self, scan)
+
+ def coordinateAxis(self):
+ r"""
+ coordinateAxis(SpecularSimulation self) -> IAxis
+ const IAxis * SpecularSimulation::coordinateAxis() const
+
+ Returns a pointer to coordinate axis.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_coordinateAxis(self)
+
+ def footprintFactor(self):
+ r"""
+ footprintFactor(SpecularSimulation self) -> IFootprintFactor const *
+ const IFootprintFactor * SpecularSimulation::footprintFactor() const
+
+ Returns a pointer to footprint factor holder.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_footprintFactor(self)
+
+ def intensityMapSize(self):
+ r"""
+ intensityMapSize(SpecularSimulation self) -> size_t
+ size_t SpecularSimulation::intensityMapSize() const override
+
+ Returns the total number of the intensity values in the simulation result.
+
+ """
+ return _libBornAgainCore.SpecularSimulation_intensityMapSize(self)
+
+# Register SpecularSimulation in _libBornAgainCore:
+_libBornAgainCore.SpecularSimulation_swigregister(SpecularSimulation)
+
+class OffSpecularSimulation(ISimulation2D):
+ r"""
+
+
+ Main class to run an off-specular simulation.
+
+ C++ includes: OffSpecularSimulation.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.OffSpecularSimulation_class_name
+
+
+ def className(self):
+ r"""
+ className(OffSpecularSimulation self) -> std::string
+ std::string OffSpecularSimulation::className() const final
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_className(self)
+
+ def __init__(self, *args):
+ r"""
+ __init__(OffSpecularSimulation self, Beam const & beam, MultiLayer const & sample, IDetector const & detector) -> OffSpecularSimulation
+ __init__(OffSpecularSimulation self) -> OffSpecularSimulation
+ OffSpecularSimulation::OffSpecularSimulation()
+
+ """
+ _libBornAgainCore.OffSpecularSimulation_swiginit(self, _libBornAgainCore.new_OffSpecularSimulation(*args))
+ __swig_destroy__ = _libBornAgainCore.delete_OffSpecularSimulation
+
+ def accept(self, visitor):
+ r"""
+ accept(OffSpecularSimulation self, INodeVisitor * visitor)
+ void OffSpecularSimulation::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_accept(self, visitor)
+
+ def result(self):
+ r"""
+ result(OffSpecularSimulation self) -> SimulationResult
+ SimulationResult OffSpecularSimulation::result() const override
+
+ Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_result(self)
+
+ def setBeamParameters(self, wavelength, alpha_axis, phi_i):
+ r"""
+ setBeamParameters(OffSpecularSimulation self, double wavelength, IAxis alpha_axis, double phi_i)
+ void OffSpecularSimulation::setBeamParameters(double wavelength, const IAxis &alpha_axis, double phi_i)
+
+ Sets beam parameters from here (forwarded to Instrument)
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_setBeamParameters(self, wavelength, alpha_axis, phi_i)
+
+ def beamAxis(self):
+ r"""
+ beamAxis(OffSpecularSimulation self) -> IAxis
+ const IAxis * OffSpecularSimulation::beamAxis() const
+
+ Returns axis of the beam.
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_beamAxis(self)
+
+ def intensityMapSize(self):
+ r"""
+ intensityMapSize(OffSpecularSimulation self) -> size_t
+ size_t OffSpecularSimulation::intensityMapSize() const override
+
+ Returns the total number of the intensity values in the simulation result.
+
+ """
+ return _libBornAgainCore.OffSpecularSimulation_intensityMapSize(self)
+
+# Register OffSpecularSimulation in _libBornAgainCore:
+_libBornAgainCore.OffSpecularSimulation_swigregister(OffSpecularSimulation)
+
+class IBackground(libBornAgainBase.ICloneable, libBornAgainParam.INode):
+ r"""
+
+
+ Interface for a simulating the background signal.
+
+ C++ includes: IBackground.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_IBackground
+
+ def clone(self):
+ r"""
+ clone(IBackground self) -> IBackground
+ virtual IBackground* IBackground::clone() const =0
+
+ """
+ return _libBornAgainCore.IBackground_clone(self)
+
+ def addBackground(self, element):
+ r"""
+ addBackground(IBackground self, double element) -> double
+ virtual double IBackground::addBackground(double element) const =0
+
+ """
+ return _libBornAgainCore.IBackground_addBackground(self, element)
+
+# Register IBackground in _libBornAgainCore:
+_libBornAgainCore.IBackground_swigregister(IBackground)
+
+class ConstantBackground(IBackground):
+ r"""
+
+
+ Class representing a constant background signal
+
+ C++ includes: ConstantBackground.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.ConstantBackground_class_name
+
+
+ def className(self):
+ r"""
+ className(ConstantBackground self) -> std::string
+ std::string ConstantBackground::className() const final
+
+ """
+ return _libBornAgainCore.ConstantBackground_className(self)
+
+ def __init__(self, *args):
+ r"""
+ __init__(ConstantBackground self, vdouble1d_t P) -> ConstantBackground
+ __init__(ConstantBackground self, double background_value) -> ConstantBackground
+ ConstantBackground::ConstantBackground(double background_value)
+
+ """
+ _libBornAgainCore.ConstantBackground_swiginit(self, _libBornAgainCore.new_ConstantBackground(*args))
+
+ def clone(self):
+ r"""
+ clone(ConstantBackground self) -> ConstantBackground
+ ConstantBackground * ConstantBackground::clone() const override
+
+ """
+ return _libBornAgainCore.ConstantBackground_clone(self)
+
+ def backgroundValue(self):
+ r"""
+ backgroundValue(ConstantBackground self) -> double
+ double ConstantBackground::backgroundValue() const
+
+ """
+ return _libBornAgainCore.ConstantBackground_backgroundValue(self)
+
+ def accept(self, visitor):
+ r"""
+ accept(ConstantBackground self, INodeVisitor * visitor)
+ void ConstantBackground::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.ConstantBackground_accept(self, visitor)
+
+ def addBackground(self, intensity):
+ r"""
+ addBackground(ConstantBackground self, double intensity) -> double
+ double ConstantBackground::addBackground(double intensity) const override
+
+ """
+ return _libBornAgainCore.ConstantBackground_addBackground(self, intensity)
+ __swig_destroy__ = _libBornAgainCore.delete_ConstantBackground
+
+# Register ConstantBackground in _libBornAgainCore:
+_libBornAgainCore.ConstantBackground_swigregister(ConstantBackground)
+
+class PoissonNoiseBackground(IBackground):
+ r"""
+
+
+ Class representing Poisson noise on top of the scattered intensity
+
+ C++ includes: PoissonNoiseBackground.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+ class_name = _libBornAgainCore.PoissonNoiseBackground_class_name
+
+
+ def className(self):
+ r"""
+ className(PoissonNoiseBackground self) -> std::string
+ std::string PoissonNoiseBackground::className() const final
+
+ """
+ return _libBornAgainCore.PoissonNoiseBackground_className(self)
+
+ def __init__(self):
+ r"""
+ __init__(PoissonNoiseBackground self) -> PoissonNoiseBackground
+ PoissonNoiseBackground::PoissonNoiseBackground()
+
+ """
+ _libBornAgainCore.PoissonNoiseBackground_swiginit(self, _libBornAgainCore.new_PoissonNoiseBackground())
+
+ def clone(self):
+ r"""
+ clone(PoissonNoiseBackground self) -> PoissonNoiseBackground
+ PoissonNoiseBackground * PoissonNoiseBackground::clone() const override
+
+ """
+ return _libBornAgainCore.PoissonNoiseBackground_clone(self)
+
+ def accept(self, visitor):
+ r"""
+ accept(PoissonNoiseBackground self, INodeVisitor * visitor)
+ void PoissonNoiseBackground::accept(INodeVisitor *visitor) const override
+
+ """
+ return _libBornAgainCore.PoissonNoiseBackground_accept(self, visitor)
+
+ def addBackground(self, intensity):
+ r"""
+ addBackground(PoissonNoiseBackground self, double intensity) -> double
+ double PoissonNoiseBackground::addBackground(double intensity) const override
+
+ """
+ return _libBornAgainCore.PoissonNoiseBackground_addBackground(self, intensity)
+ __swig_destroy__ = _libBornAgainCore.delete_PoissonNoiseBackground
+
+# Register PoissonNoiseBackground in _libBornAgainCore:
+_libBornAgainCore.PoissonNoiseBackground_swigregister(PoissonNoiseBackground)
+
+
+def sampleCode(multilayer):
+ r"""
+ sampleCode(MultiLayer const & multilayer) -> std::string
+ std::string Py::Export::sampleCode(const MultiLayer &multilayer)
+
+ """
+ return _libBornAgainCore.sampleCode(multilayer)
+
+def simulationPlotCode(simulation):
+ r"""
+ simulationPlotCode(ISimulation simulation) -> std::string
+ std::string Py::Export::simulationPlotCode(const ISimulation &simulation)
+
+ """
+ return _libBornAgainCore.simulationPlotCode(simulation)
+
+def simulationSaveCode(simulation, fname):
+ r"""
+ simulationSaveCode(ISimulation simulation, std::string const & fname) -> std::string
+ std::string Py::Export::simulationSaveCode(const ISimulation &simulation, const std::string &fname)
+
+ """
+ return _libBornAgainCore.simulationSaveCode(simulation, fname)
+class IIntensityFunction(object):
+ r"""
+
+
+ Interface for applying arbitrary function to the measured intensity.
+
+ C++ includes: IIntensityFunction.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_IIntensityFunction
+
+ def clone(self):
+ r"""
+ clone(IIntensityFunction self) -> IIntensityFunction
+ virtual IIntensityFunction* IIntensityFunction::clone() const =0
+
+ """
+ return _libBornAgainCore.IIntensityFunction_clone(self)
+
+ def evaluate(self, value):
+ r"""
+ evaluate(IIntensityFunction self, double value) -> double
+ virtual double IIntensityFunction::evaluate(double value) const =0
+
+ """
+ return _libBornAgainCore.IIntensityFunction_evaluate(self, value)
+
+# Register IIntensityFunction in _libBornAgainCore:
+_libBornAgainCore.IIntensityFunction_swigregister(IIntensityFunction)
+
+class IntensityFunctionLog(IIntensityFunction):
+ r"""
+
+
+ Algorithm for applying log function to the measured intensity.
+
+ C++ includes: IIntensityFunction.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def clone(self):
+ r"""
+ clone(IntensityFunctionLog self) -> IntensityFunctionLog
+ IntensityFunctionLog * IntensityFunctionLog::clone() const
+
+ """
+ return _libBornAgainCore.IntensityFunctionLog_clone(self)
+
+ def evaluate(self, value):
+ r"""
+ evaluate(IntensityFunctionLog self, double value) -> double
+ double IntensityFunctionLog::evaluate(double value) const
+
+ """
+ return _libBornAgainCore.IntensityFunctionLog_evaluate(self, value)
+
+ def __init__(self):
+ r"""
+ __init__(IntensityFunctionLog self) -> IntensityFunctionLog
+
+
+ Algorithm for applying log function to the measured intensity.
+
+ C++ includes: IIntensityFunction.h
+
+ """
+ _libBornAgainCore.IntensityFunctionLog_swiginit(self, _libBornAgainCore.new_IntensityFunctionLog())
+ __swig_destroy__ = _libBornAgainCore.delete_IntensityFunctionLog
+
+# Register IntensityFunctionLog in _libBornAgainCore:
+_libBornAgainCore.IntensityFunctionLog_swigregister(IntensityFunctionLog)
+
+class IntensityFunctionSqrt(IIntensityFunction):
+ r"""
+
+
+ Algorithm for applying sqrt function to the measured intensity.
+
+ C++ includes: IIntensityFunction.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def clone(self):
+ r"""
+ clone(IntensityFunctionSqrt self) -> IntensityFunctionSqrt
+ IntensityFunctionSqrt * IntensityFunctionSqrt::clone() const
+
+ """
+ return _libBornAgainCore.IntensityFunctionSqrt_clone(self)
+
+ def evaluate(self, value):
+ r"""
+ evaluate(IntensityFunctionSqrt self, double value) -> double
+ double IntensityFunctionSqrt::evaluate(double value) const
+
+ """
+ return _libBornAgainCore.IntensityFunctionSqrt_evaluate(self, value)
+
+ def __init__(self):
+ r"""
+ __init__(IntensityFunctionSqrt self) -> IntensityFunctionSqrt
+
+
+ Algorithm for applying sqrt function to the measured intensity.
+
+ C++ includes: IIntensityFunction.h
+
+ """
+ _libBornAgainCore.IntensityFunctionSqrt_swiginit(self, _libBornAgainCore.new_IntensityFunctionSqrt())
+ __swig_destroy__ = _libBornAgainCore.delete_IntensityFunctionSqrt
+
+# Register IntensityFunctionSqrt in _libBornAgainCore:
+_libBornAgainCore.IntensityFunctionSqrt_swigregister(IntensityFunctionSqrt)
+
+class IChiSquaredModule(libBornAgainBase.ICloneable):
+ r"""
+
+
+ Interface residual calculations.
+
+ C++ includes: IChiSquaredModule.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_IChiSquaredModule
+
+ def clone(self):
+ r"""
+ clone(IChiSquaredModule self) -> IChiSquaredModule
+ virtual IChiSquaredModule* IChiSquaredModule::clone() const =0
+
+ clone method
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_clone(self)
+
+ def varianceFunction(self):
+ r"""
+ varianceFunction(IChiSquaredModule self) -> IVarianceFunction
+ const IVarianceFunction * IChiSquaredModule::varianceFunction() const
+
+ Returns squared function.
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_varianceFunction(self)
+
+ def setVarianceFunction(self, variance_function):
+ r"""
+ setVarianceFunction(IChiSquaredModule self, IVarianceFunction variance_function)
+ void IChiSquaredModule::setVarianceFunction(const IVarianceFunction &variance_function)
+
+ Sets squared function.
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_setVarianceFunction(self, variance_function)
+
+ def getIntensityFunction(self):
+ r"""
+ getIntensityFunction(IChiSquaredModule self) -> IIntensityFunction
+ const IIntensityFunction * IChiSquaredModule::getIntensityFunction() const
+
+ Returns data rescaler.
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_getIntensityFunction(self)
+
+ def setIntensityFunction(self, intensity_function):
+ r"""
+ setIntensityFunction(IChiSquaredModule self, IIntensityFunction intensity_function)
+ void IChiSquaredModule::setIntensityFunction(const IIntensityFunction &intensity_function)
+
+ Sets data rescaler.
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_setIntensityFunction(self, intensity_function)
+
+ def residual(self, a, b, weight):
+ r"""
+ residual(IChiSquaredModule self, double a, double b, double weight) -> double
+ virtual double IChiSquaredModule::residual(double a, double b, double weight)=0
+
+ """
+ return _libBornAgainCore.IChiSquaredModule_residual(self, a, b, weight)
+
+# Register IChiSquaredModule in _libBornAgainCore:
+_libBornAgainCore.IChiSquaredModule_swigregister(IChiSquaredModule)
+
+class ChiSquaredModule(IChiSquaredModule):
+ r"""
+
+
+ Calculation of chi2 between two data sets.
+
+ C++ includes: ChiSquaredModule.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, *args):
+ r"""
+ __init__(ChiSquaredModule self) -> ChiSquaredModule
+ __init__(ChiSquaredModule self, ChiSquaredModule other) -> ChiSquaredModule
+ ChiSquaredModule::ChiSquaredModule(const ChiSquaredModule &other)
+
+ """
+ _libBornAgainCore.ChiSquaredModule_swiginit(self, _libBornAgainCore.new_ChiSquaredModule(*args))
+ __swig_destroy__ = _libBornAgainCore.delete_ChiSquaredModule
+
+ def clone(self):
+ r"""
+ clone(ChiSquaredModule self) -> ChiSquaredModule
+ virtual ChiSquaredModule* ChiSquaredModule::clone() const
+
+ clone method
+
+ """
+ return _libBornAgainCore.ChiSquaredModule_clone(self)
+
+ def residual(self, a, b, weight):
+ r"""
+ residual(ChiSquaredModule self, double a, double b, double weight) -> double
+ double ChiSquaredModule::residual(double a, double b, double weight)
+
+ """
+ return _libBornAgainCore.ChiSquaredModule_residual(self, a, b, weight)
+
+# Register ChiSquaredModule in _libBornAgainCore:
+_libBornAgainCore.ChiSquaredModule_swigregister(ChiSquaredModule)
+
+class IVarianceFunction(object):
+ r"""
+
+
+ Variance function interface.
+
+ C++ includes: VarianceFunctions.h
+
+ """
+
+ 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__ = _libBornAgainCore.delete_IVarianceFunction
+
+ def clone(self):
+ r"""
+ clone(IVarianceFunction self) -> IVarianceFunction
+ virtual IVarianceFunction* IVarianceFunction::clone() const =0
+
+ """
+ return _libBornAgainCore.IVarianceFunction_clone(self)
+
+ def variance(self, real_value, simulated_value):
+ r"""
+ variance(IVarianceFunction self, double real_value, double simulated_value) -> double
+ virtual double IVarianceFunction::variance(double real_value, double simulated_value) const =0
+
+ """
+ return _libBornAgainCore.IVarianceFunction_variance(self, real_value, simulated_value)
+
+# Register IVarianceFunction in _libBornAgainCore:
+_libBornAgainCore.IVarianceFunction_swigregister(IVarianceFunction)
+
+class VarianceConstantFunction(IVarianceFunction):
+ r"""
+
+
+ Returns 1.0 as variance value
+
+ C++ includes: VarianceFunctions.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def clone(self):
+ r"""
+ clone(VarianceConstantFunction self) -> VarianceConstantFunction
+ VarianceConstantFunction * VarianceConstantFunction::clone() const override
+
+ """
+ return _libBornAgainCore.VarianceConstantFunction_clone(self)
+
+ def variance(self, arg2, arg3):
+ r"""
+ variance(VarianceConstantFunction self, double arg2, double arg3) -> double
+ double VarianceConstantFunction::variance(double, double) const override
+
+ """
+ return _libBornAgainCore.VarianceConstantFunction_variance(self, arg2, arg3)
+
+ def __init__(self):
+ r"""
+ __init__(VarianceConstantFunction self) -> VarianceConstantFunction
+
+
+ Returns 1.0 as variance value
+
+ C++ includes: VarianceFunctions.h
+
+ """
+ _libBornAgainCore.VarianceConstantFunction_swiginit(self, _libBornAgainCore.new_VarianceConstantFunction())
+ __swig_destroy__ = _libBornAgainCore.delete_VarianceConstantFunction
+
+# Register VarianceConstantFunction in _libBornAgainCore:
+_libBornAgainCore.VarianceConstantFunction_swigregister(VarianceConstantFunction)
+
+class VarianceSimFunction(IVarianceFunction):
+ r"""
+
+
+ Returns max(sim, epsilon)
+
+ C++ includes: VarianceFunctions.h
+
+ """
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def __init__(self, epsilon=1.0):
+ r"""
+ __init__(VarianceSimFunction self, double epsilon=1.0) -> VarianceSimFunction
+ VarianceSimFunction::VarianceSimFunction(double epsilon=1.0)
+
+ """
+ _libBornAgainCore.VarianceSimFunction_swiginit(self, _libBornAgainCore.new_VarianceSimFunction(epsilon))
+
+ def clone(self):
+ r"""
+ clone(VarianceSimFunction self) -> VarianceSimFunction
+ VarianceSimFunction * VarianceSimFunction::clone() const override
+
+ """
+ return _libBornAgainCore.VarianceSimFunction_clone(self)
+
+ def variance(self, exp, sim):
+ r"""
+ variance(VarianceSimFunction self, double exp, double sim) -> double
+ double VarianceSimFunction::variance(double exp, double sim) const override
+
+ """
+ return _libBornAgainCore.VarianceSimFunction_variance(self, exp, sim)
+ __swig_destroy__ = _libBornAgainCore.delete_VarianceSimFunction
+
+# Register VarianceSimFunction in _libBornAgainCore:
+_libBornAgainCore.VarianceSimFunction_swigregister(VarianceSimFunction)
+
+
+class SimulationBuilderWrapper(PyBuilderCallback):
+ def __init__(self, f):
+ super(SimulationBuilderWrapper, self).__init__()
+ self.f_ = f
+
+ def create_par_dict(self, pars):
+ """
+ Convertion of ba.Parameters to Python dictionary
+ """
+ pars_dict = dict()
+ for index, p in enumerate(pars):
+ pars_dict[p.name()] = p.value
+ return pars_dict
+
+ def build_simulation(self, obj):
+ simulation = self.f_(self.create_par_dict(obj))
+ simulation.__disown__()
+ return simulation
+
+
+
+
+class ObserverCallbackWrapper(PyObserverCallback):
+ def __init__(self, callback):
+ super(ObserverCallbackWrapper, self).__init__()
+ self.callback_ = callback
+
+ def update(self, fit_objective):
+ return self.callback_(fit_objective)
+
+
+
diff --git a/auto/Wrap/libBornAgainCore_wrap.cpp b/auto/Wrap/libBornAgainCore_wrap.cpp
index 64ff59ac481e105d9e04e7d45e3f228aba157b68..6ce1384e82a20ba2e764f3fb62dbdefba2569414 100644
--- a/auto/Wrap/libBornAgainCore_wrap.cpp
+++ b/auto/Wrap/libBornAgainCore_wrap.cpp
@@ -39069,7 +39069,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ISimulation_setSampleBuilderCpp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_ISimulation_setSampleBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ISimulation *arg1 = (ISimulation *) 0 ;
std::shared_ptr< ISampleBuilder > *arg2 = 0 ;
@@ -39079,18 +39079,18 @@ SWIGINTERN PyObject *_wrap_ISimulation_setSampleBuilderCpp(PyObject *SWIGUNUSEDP
int res2 = 0 ;
PyObject *swig_obj[2] ;
- if (!SWIG_Python_UnpackTuple(args, "ISimulation_setSampleBuilderCpp", 2, 2, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ISimulation_setSampleBuilder", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISimulation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISimulation_setSampleBuilderCpp" "', argument " "1"" of type '" "ISimulation *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISimulation_setSampleBuilder" "', argument " "1"" of type '" "ISimulation *""'");
}
arg1 = reinterpret_cast< ISimulation * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ISimulation_setSampleBuilderCpp" "', argument " "2"" of type '" "std::shared_ptr< ISampleBuilder > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ISimulation_setSampleBuilder" "', argument " "2"" of type '" "std::shared_ptr< ISampleBuilder > const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ISimulation_setSampleBuilderCpp" "', argument " "2"" of type '" "std::shared_ptr< ISampleBuilder > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ISimulation_setSampleBuilder" "', argument " "2"" of type '" "std::shared_ptr< ISampleBuilder > const &""'");
}
arg2 = reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp2);
(arg1)->setSampleBuilder((std::shared_ptr< ISampleBuilder > const &)*arg2);
@@ -44419,8 +44419,8 @@ static PyMethodDef SwigMethods[] = {
"const MultiLayer * ISimulation::sample() const\n"
"\n"
""},
- { "ISimulation_setSampleBuilderCpp", _wrap_ISimulation_setSampleBuilderCpp, METH_VARARGS, "\n"
- "ISimulation_setSampleBuilderCpp(ISimulation self, std::shared_ptr< ISampleBuilder > const & sample_builder)\n"
+ { "ISimulation_setSampleBuilder", _wrap_ISimulation_setSampleBuilder, METH_VARARGS, "\n"
+ "ISimulation_setSampleBuilder(ISimulation self, std::shared_ptr< ISampleBuilder > const & sample_builder)\n"
"void ISimulation::setSampleBuilder(const std::shared_ptr< ISampleBuilder > &sample_builder)\n"
"\n"
""},
diff --git a/auto/Wrap/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index b478a9609997df4286962b95ef90901f0f266259..3c96ca9071452303030200a5e78d441391d5e1cb 100644
--- a/auto/Wrap/libBornAgainSample.py
+++ b/auto/Wrap/libBornAgainSample.py
@@ -12092,49 +12092,4 @@ def BCTLattice(a, c):
"""
return _libBornAgainSample.BCTLattice(a, c)
-class ISampleBuilder(object):
- r"""
-
-
- Interface to the class capable to build samples to simulate.
-
- C++ includes: ISampleBuilder.h
-
- """
-
- thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
- __repr__ = _swig_repr
- __swig_destroy__ = _libBornAgainSample.delete_ISampleBuilder
-
- def buildSample(self):
- r"""
- buildSample(ISampleBuilder self) -> MultiLayer
- virtual MultiLayer* ISampleBuilder::buildSample() const =0
-
- """
- return _libBornAgainSample.ISampleBuilder_buildSample(self)
-
- def __init__(self):
- r"""
- __init__(ISampleBuilder self) -> ISampleBuilder
-
-
- Interface to the class capable to build samples to simulate.
-
- C++ includes: ISampleBuilder.h
-
- """
- if self.__class__ == ISampleBuilder:
- _self = None
- else:
- _self = self
- _libBornAgainSample.ISampleBuilder_swiginit(self, _libBornAgainSample.new_ISampleBuilder(_self, ))
- def __disown__(self):
- self.this.disown()
- _libBornAgainSample.disown_ISampleBuilder(self)
- return weakref.proxy(self)
-
-# Register ISampleBuilder in _libBornAgainSample:
-_libBornAgainSample.ISampleBuilder_swigregister(ISampleBuilder)
-
diff --git a/auto/Wrap/libBornAgainSample_wrap.cpp b/auto/Wrap/libBornAgainSample_wrap.cpp
index b35b14b3b37916ec3f0054c7955a0a6a5af64b89..4b4dab13388bddcc7210a728cc6a6d6ec98a0326 100644
--- a/auto/Wrap/libBornAgainSample_wrap.cpp
+++ b/auto/Wrap/libBornAgainSample_wrap.cpp
@@ -3177,111 +3177,109 @@ namespace Swig {
#define SWIGTYPE_p_IProfileRectangularRipple swig_types[77]
#define SWIGTYPE_p_IProfileRipple swig_types[78]
#define SWIGTYPE_p_IRotation swig_types[79]
-#define SWIGTYPE_p_ISampleBuilder swig_types[80]
-#define SWIGTYPE_p_ISampleNode swig_types[81]
-#define SWIGTYPE_p_ISawtoothRipple swig_types[82]
-#define SWIGTYPE_p_ISelectionRule swig_types[83]
-#define SWIGTYPE_p_IdentityRotation swig_types[84]
-#define SWIGTYPE_p_Interference1DLattice swig_types[85]
-#define SWIGTYPE_p_Interference2DLattice swig_types[86]
-#define SWIGTYPE_p_Interference2DParaCrystal swig_types[87]
-#define SWIGTYPE_p_Interference2DSuperLattice swig_types[88]
-#define SWIGTYPE_p_Interference3DLattice swig_types[89]
-#define SWIGTYPE_p_InterferenceFinite2DLattice swig_types[90]
-#define SWIGTYPE_p_InterferenceFinite3DLattice swig_types[91]
-#define SWIGTYPE_p_InterferenceHardDisk swig_types[92]
-#define SWIGTYPE_p_InterferenceNone swig_types[93]
-#define SWIGTYPE_p_InterferenceRadialParaCrystal swig_types[94]
-#define SWIGTYPE_p_InterferenceTwin swig_types[95]
-#define SWIGTYPE_p_IsotropicGaussPeakShape swig_types[96]
-#define SWIGTYPE_p_IsotropicLorentzPeakShape swig_types[97]
-#define SWIGTYPE_p_Lattice2D swig_types[98]
-#define SWIGTYPE_p_Lattice2D__ReciprocalBases swig_types[99]
-#define SWIGTYPE_p_Lattice3D swig_types[100]
-#define SWIGTYPE_p_Layer swig_types[101]
-#define SWIGTYPE_p_LayerInterface swig_types[102]
-#define SWIGTYPE_p_LayerRoughness swig_types[103]
-#define SWIGTYPE_p_LorentzFisherPeakShape swig_types[104]
-#define SWIGTYPE_p_Material swig_types[105]
-#define SWIGTYPE_p_MesoCrystal swig_types[106]
-#define SWIGTYPE_p_MisesFisherGaussPeakShape swig_types[107]
-#define SWIGTYPE_p_MisesGaussPeakShape swig_types[108]
-#define SWIGTYPE_p_MultiLayer swig_types[109]
-#define SWIGTYPE_p_NodeMeta swig_types[110]
-#define SWIGTYPE_p_Particle swig_types[111]
-#define SWIGTYPE_p_ParticleComposition swig_types[112]
-#define SWIGTYPE_p_ParticleCoreShell swig_types[113]
-#define SWIGTYPE_p_ParticleLayout swig_types[114]
-#define SWIGTYPE_p_RotationEuler swig_types[115]
-#define SWIGTYPE_p_RotationX swig_types[116]
-#define SWIGTYPE_p_RotationY swig_types[117]
-#define SWIGTYPE_p_RotationZ swig_types[118]
-#define SWIGTYPE_p_RoughnessModelWrap swig_types[119]
-#define SWIGTYPE_p_RoughnessModelWrap__RoughnessModel swig_types[120]
-#define SWIGTYPE_p_SafePointerVectorT_IParticle_t swig_types[121]
-#define SWIGTYPE_p_SimpleSelectionRule swig_types[122]
-#define SWIGTYPE_p_SlicedParticle swig_types[123]
-#define SWIGTYPE_p_SlicingEffects swig_types[124]
-#define SWIGTYPE_p_SquareLattice2D swig_types[125]
-#define SWIGTYPE_p_Transform3D swig_types[126]
-#define SWIGTYPE_p_WavevectorInfo swig_types[127]
-#define SWIGTYPE_p_ZLimits swig_types[128]
-#define SWIGTYPE_p_allocator_type swig_types[129]
-#define SWIGTYPE_p_char swig_types[130]
-#define SWIGTYPE_p_difference_type swig_types[131]
-#define SWIGTYPE_p_first_type swig_types[132]
-#define SWIGTYPE_p_int swig_types[133]
-#define SWIGTYPE_p_key_type swig_types[134]
-#define SWIGTYPE_p_long_long swig_types[135]
-#define SWIGTYPE_p_mapped_type swig_types[136]
-#define SWIGTYPE_p_p_PyObject swig_types[137]
-#define SWIGTYPE_p_second_type swig_types[138]
-#define SWIGTYPE_p_short swig_types[139]
-#define SWIGTYPE_p_signed_char swig_types[140]
-#define SWIGTYPE_p_size_type swig_types[141]
-#define SWIGTYPE_p_std__allocatorT_BasicVector3DT_double_t_t swig_types[142]
-#define SWIGTYPE_p_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t swig_types[143]
-#define SWIGTYPE_p_std__allocatorT_IFormFactor_p_t swig_types[144]
-#define SWIGTYPE_p_std__allocatorT_INode_const_p_t swig_types[145]
-#define SWIGTYPE_p_std__allocatorT_INode_p_t swig_types[146]
-#define SWIGTYPE_p_std__allocatorT_double_t swig_types[147]
-#define SWIGTYPE_p_std__allocatorT_int_t swig_types[148]
-#define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[149]
-#define SWIGTYPE_p_std__allocatorT_std__pairT_double_double_t_t swig_types[150]
-#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_double_t_t swig_types[151]
-#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[152]
-#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[153]
-#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[154]
-#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[155]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[156]
-#define SWIGTYPE_p_std__invalid_argument swig_types[157]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[158]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[159]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[160]
-#define SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t swig_types[161]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[162]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[163]
-#define SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t swig_types[164]
-#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[165]
-#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[166]
-#define SWIGTYPE_p_std__vectorT_Material_const_p_std__allocatorT_Material_const_p_t_t swig_types[167]
-#define SWIGTYPE_p_std__vectorT_ParticleLayout_const_p_std__allocatorT_ParticleLayout_const_p_t_t swig_types[168]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[169]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[170]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[171]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[172]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[173]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[174]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[175]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[176]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[177]
-#define SWIGTYPE_p_unsigned_char swig_types[178]
-#define SWIGTYPE_p_unsigned_int swig_types[179]
-#define SWIGTYPE_p_unsigned_long_long swig_types[180]
-#define SWIGTYPE_p_unsigned_short swig_types[181]
-#define SWIGTYPE_p_value_type swig_types[182]
-static swig_type_info *swig_types[184];
-static swig_module_info swig_module = {swig_types, 183, 0, 0, 0, 0};
+#define SWIGTYPE_p_ISampleNode swig_types[80]
+#define SWIGTYPE_p_ISawtoothRipple swig_types[81]
+#define SWIGTYPE_p_ISelectionRule swig_types[82]
+#define SWIGTYPE_p_IdentityRotation swig_types[83]
+#define SWIGTYPE_p_Interference1DLattice swig_types[84]
+#define SWIGTYPE_p_Interference2DLattice swig_types[85]
+#define SWIGTYPE_p_Interference2DParaCrystal swig_types[86]
+#define SWIGTYPE_p_Interference2DSuperLattice swig_types[87]
+#define SWIGTYPE_p_Interference3DLattice swig_types[88]
+#define SWIGTYPE_p_InterferenceFinite2DLattice swig_types[89]
+#define SWIGTYPE_p_InterferenceFinite3DLattice swig_types[90]
+#define SWIGTYPE_p_InterferenceHardDisk swig_types[91]
+#define SWIGTYPE_p_InterferenceNone swig_types[92]
+#define SWIGTYPE_p_InterferenceRadialParaCrystal swig_types[93]
+#define SWIGTYPE_p_InterferenceTwin swig_types[94]
+#define SWIGTYPE_p_IsotropicGaussPeakShape swig_types[95]
+#define SWIGTYPE_p_IsotropicLorentzPeakShape swig_types[96]
+#define SWIGTYPE_p_Lattice2D swig_types[97]
+#define SWIGTYPE_p_Lattice2D__ReciprocalBases swig_types[98]
+#define SWIGTYPE_p_Lattice3D swig_types[99]
+#define SWIGTYPE_p_Layer swig_types[100]
+#define SWIGTYPE_p_LayerInterface swig_types[101]
+#define SWIGTYPE_p_LayerRoughness swig_types[102]
+#define SWIGTYPE_p_LorentzFisherPeakShape swig_types[103]
+#define SWIGTYPE_p_Material swig_types[104]
+#define SWIGTYPE_p_MesoCrystal swig_types[105]
+#define SWIGTYPE_p_MisesFisherGaussPeakShape swig_types[106]
+#define SWIGTYPE_p_MisesGaussPeakShape swig_types[107]
+#define SWIGTYPE_p_MultiLayer swig_types[108]
+#define SWIGTYPE_p_NodeMeta swig_types[109]
+#define SWIGTYPE_p_Particle swig_types[110]
+#define SWIGTYPE_p_ParticleComposition swig_types[111]
+#define SWIGTYPE_p_ParticleCoreShell swig_types[112]
+#define SWIGTYPE_p_ParticleLayout swig_types[113]
+#define SWIGTYPE_p_RotationEuler swig_types[114]
+#define SWIGTYPE_p_RotationX swig_types[115]
+#define SWIGTYPE_p_RotationY swig_types[116]
+#define SWIGTYPE_p_RotationZ swig_types[117]
+#define SWIGTYPE_p_RoughnessModelWrap swig_types[118]
+#define SWIGTYPE_p_RoughnessModelWrap__RoughnessModel swig_types[119]
+#define SWIGTYPE_p_SafePointerVectorT_IParticle_t swig_types[120]
+#define SWIGTYPE_p_SimpleSelectionRule swig_types[121]
+#define SWIGTYPE_p_SlicedParticle swig_types[122]
+#define SWIGTYPE_p_SlicingEffects swig_types[123]
+#define SWIGTYPE_p_SquareLattice2D swig_types[124]
+#define SWIGTYPE_p_Transform3D swig_types[125]
+#define SWIGTYPE_p_WavevectorInfo swig_types[126]
+#define SWIGTYPE_p_ZLimits swig_types[127]
+#define SWIGTYPE_p_allocator_type swig_types[128]
+#define SWIGTYPE_p_char swig_types[129]
+#define SWIGTYPE_p_difference_type swig_types[130]
+#define SWIGTYPE_p_first_type swig_types[131]
+#define SWIGTYPE_p_int swig_types[132]
+#define SWIGTYPE_p_key_type swig_types[133]
+#define SWIGTYPE_p_long_long swig_types[134]
+#define SWIGTYPE_p_mapped_type swig_types[135]
+#define SWIGTYPE_p_p_PyObject swig_types[136]
+#define SWIGTYPE_p_second_type swig_types[137]
+#define SWIGTYPE_p_short swig_types[138]
+#define SWIGTYPE_p_signed_char swig_types[139]
+#define SWIGTYPE_p_size_type swig_types[140]
+#define SWIGTYPE_p_std__allocatorT_BasicVector3DT_double_t_t swig_types[141]
+#define SWIGTYPE_p_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t swig_types[142]
+#define SWIGTYPE_p_std__allocatorT_IFormFactor_p_t swig_types[143]
+#define SWIGTYPE_p_std__allocatorT_INode_const_p_t swig_types[144]
+#define SWIGTYPE_p_std__allocatorT_INode_p_t swig_types[145]
+#define SWIGTYPE_p_std__allocatorT_double_t swig_types[146]
+#define SWIGTYPE_p_std__allocatorT_int_t swig_types[147]
+#define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[148]
+#define SWIGTYPE_p_std__allocatorT_std__pairT_double_double_t_t swig_types[149]
+#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_double_t_t swig_types[150]
+#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[151]
+#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[152]
+#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[153]
+#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[154]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[155]
+#define SWIGTYPE_p_std__invalid_argument swig_types[156]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[157]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[158]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[159]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[160]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[161]
+#define SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t swig_types[162]
+#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[163]
+#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[164]
+#define SWIGTYPE_p_std__vectorT_Material_const_p_std__allocatorT_Material_const_p_t_t swig_types[165]
+#define SWIGTYPE_p_std__vectorT_ParticleLayout_const_p_std__allocatorT_ParticleLayout_const_p_t_t swig_types[166]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[167]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[168]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[169]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[170]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[171]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[172]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[173]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[174]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[175]
+#define SWIGTYPE_p_unsigned_char swig_types[176]
+#define SWIGTYPE_p_unsigned_int swig_types[177]
+#define SWIGTYPE_p_unsigned_long_long swig_types[178]
+#define SWIGTYPE_p_unsigned_short swig_types[179]
+#define SWIGTYPE_p_value_type swig_types[180]
+static swig_type_info *swig_types[182];
+static swig_module_info swig_module = {swig_types, 181, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -6828,7 +6826,6 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__insert__SWIG_
#include "Sample/Particle/ParticleComposition.h"
#include "Sample/Particle/ParticleCoreShell.h"
#include "Sample/Particle/SlicedParticle.h"
-#include "Sample/SampleBuilderEngine/ISampleBuilder.h"
#include "Sample/Scattering/IFormFactorDecorator.h"
#include "Sample/Interface/LayerInterface.h"
#include "Sample/Interface/LayerRoughness.h"
@@ -7419,19 +7416,6 @@ SWIGINTERNINLINE PyObject*
}
-struct SWIG_null_deleter {
- void operator() (void const *) const {
- }
-};
-#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
-#define SWIG_NO_NULL_DELETER_1
-#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
-#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN
-
-
-#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
-
-
/* ---------------------------------------------------
* C++ director class methods
@@ -8732,51 +8716,6 @@ complex_t SwigDirector_IBornFF::evaluate_for_q(C3 q) const {
}
-SwigDirector_ISampleBuilder::SwigDirector_ISampleBuilder(PyObject *self): ISampleBuilder(), Swig::Director(self) {
- SWIG_DIRECTOR_RGTR((ISampleBuilder *)this, this);
-}
-
-
-
-
-SwigDirector_ISampleBuilder::~SwigDirector_ISampleBuilder() {
-}
-
-MultiLayer *SwigDirector_ISampleBuilder::buildSample() const {
- MultiLayer *c_result = 0 ;
- void *swig_argp ;
- int swig_res ;
- swig_owntype own ;
-
- if (!swig_get_self()) {
- Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ISampleBuilder.__init__.");
- }
-#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
- const size_t swig_method_index = 0;
- const char *const swig_method_name = "buildSample";
- PyObject *method = swig_get_method(swig_method_index, swig_method_name);
- swig::SwigVar_PyObject args = PyTuple_New(0);
- swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
-#else
- swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("buildSample");
- swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
-#endif
- if (!result) {
- PyObject *error = PyErr_Occurred();
- if (error) {
- Swig::DirectorMethodException::raise("Error detected when calling 'ISampleBuilder.buildSample'");
- }
- }
- swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_MultiLayer, 0 | SWIG_POINTER_DISOWN, &own);
- if (!SWIG_IsOK(swig_res)) {
- Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""MultiLayer *""'");
- }
- c_result = reinterpret_cast< MultiLayer * >(swig_argp);
- swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
- return (MultiLayer *) c_result;
-}
-
-
#ifdef __cplusplus
extern "C" {
#endif
@@ -68447,166 +68386,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_delete_ISampleBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- ISampleBuilder *arg1 = (ISampleBuilder *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- std::shared_ptr< ISampleBuilder > tempshared1 ;
- std::shared_ptr< ISampleBuilder > *smartarg1 = 0 ;
- PyObject *swig_obj[1] ;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- {
- int newmem = 0;
- res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, 0 | 0 , &newmem);
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ISampleBuilder" "', argument " "1"" of type '" "ISampleBuilder *""'");
- }
- if (newmem & SWIG_CAST_NEW_MEMORY) {
- tempshared1 = *reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- delete reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >(tempshared1.get());
- } else {
- smartarg1 = reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >((smartarg1 ? smartarg1->get() : 0));
- }
- }
- (void)arg1; delete smartarg1;
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ISampleBuilder_buildSample(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- ISampleBuilder *arg1 = (ISampleBuilder *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- std::shared_ptr< ISampleBuilder const > tempshared1 ;
- std::shared_ptr< ISampleBuilder const > *smartarg1 = 0 ;
- PyObject *swig_obj[1] ;
- Swig::Director *director = 0;
- bool upcall = false;
- MultiLayer *result = 0 ;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- {
- int newmem = 0;
- res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, 0 | 0 , &newmem);
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISampleBuilder_buildSample" "', argument " "1"" of type '" "ISampleBuilder const *""'");
- }
- if (newmem & SWIG_CAST_NEW_MEMORY) {
- tempshared1 = *reinterpret_cast< std::shared_ptr< const ISampleBuilder > * >(argp1);
- delete reinterpret_cast< std::shared_ptr< const ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >(tempshared1.get());
- } else {
- smartarg1 = reinterpret_cast< std::shared_ptr< const ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >((smartarg1 ? smartarg1->get() : 0));
- }
- }
- director = SWIG_DIRECTOR_CAST(arg1);
- upcall = (director && (director->swig_get_self()==swig_obj[0]));
- try {
- if (upcall) {
- Swig::DirectorPureVirtualException::raise("ISampleBuilder::buildSample");
- } else {
- result = (MultiLayer *)((ISampleBuilder const *)arg1)->buildSample();
- }
- } catch (Swig::DirectorException&) {
- SWIG_fail;
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiLayer, 0 | 0 );
- if (director) {
- SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
- }
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_ISampleBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- PyObject *arg1 = (PyObject *) 0 ;
- PyObject *swig_obj[1] ;
- ISampleBuilder *result = 0 ;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- arg1 = swig_obj[0];
- if ( arg1 != Py_None ) {
- /* subclassed */
- result = (ISampleBuilder *)new SwigDirector_ISampleBuilder(arg1);
- } else {
- SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor");
- SWIG_fail;
- }
-
- {
- std::shared_ptr< ISampleBuilder > *smartresult = result ? new std::shared_ptr< ISampleBuilder >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
- }
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_disown_ISampleBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- ISampleBuilder *arg1 = (ISampleBuilder *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- std::shared_ptr< ISampleBuilder > tempshared1 ;
- std::shared_ptr< ISampleBuilder > *smartarg1 = 0 ;
- PyObject *swig_obj[1] ;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- {
- int newmem = 0;
- res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, 0 | 0 , &newmem);
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ISampleBuilder" "', argument " "1"" of type '" "ISampleBuilder *""'");
- }
- if (newmem & SWIG_CAST_NEW_MEMORY) {
- tempshared1 = *reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- delete reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >(tempshared1.get());
- } else {
- smartarg1 = reinterpret_cast< std::shared_ptr< ISampleBuilder > * >(argp1);
- arg1 = const_cast< ISampleBuilder * >((smartarg1 ? smartarg1->get() : 0));
- }
- }
- {
- Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
- if (director) director->swig_disown();
- }
-
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *ISampleBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *obj;
- if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t, SWIG_NewClientData(obj));
- return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *ISampleBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- return SWIG_Python_InitShadowInstance(args);
-}
-
static PyMethodDef SwigMethods[] = {
{ "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
{ "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, "delete_SwigPyIterator(SwigPyIterator self)"},
@@ -74825,28 +74604,6 @@ static PyMethodDef SwigMethods[] = {
"Returns a body-centered cubic (cI) lattice with edge length a. TODO: Clarify meaning of c \n"
"\n"
""},
- { "delete_ISampleBuilder", _wrap_delete_ISampleBuilder, METH_O, "\n"
- "delete_ISampleBuilder(ISampleBuilder self)\n"
- "virtual ISampleBuilder::~ISampleBuilder()=default\n"
- "\n"
- ""},
- { "ISampleBuilder_buildSample", _wrap_ISampleBuilder_buildSample, METH_O, "\n"
- "ISampleBuilder_buildSample(ISampleBuilder self) -> MultiLayer\n"
- "virtual MultiLayer* ISampleBuilder::buildSample() const =0\n"
- "\n"
- ""},
- { "new_ISampleBuilder", _wrap_new_ISampleBuilder, METH_O, "\n"
- "new_ISampleBuilder(PyObject * _self) -> ISampleBuilder\n"
- "\n"
- "\n"
- "Interface to the class capable to build samples to simulate.\n"
- "\n"
- "C++ includes: ISampleBuilder.h\n"
- "\n"
- ""},
- { "disown_ISampleBuilder", _wrap_disown_ISampleBuilder, METH_O, NULL},
- { "ISampleBuilder_swigregister", ISampleBuilder_swigregister, METH_O, NULL},
- { "ISampleBuilder_swiginit", ISampleBuilder_swiginit, METH_VARARGS, NULL},
{ NULL, NULL, 0, NULL }
};
@@ -76275,7 +76032,6 @@ static swig_type_info _swigt__p_IPeakShape = {"_p_IPeakShape", "IPeakShape *", 0
static swig_type_info _swigt__p_IProfileRectangularRipple = {"_p_IProfileRectangularRipple", "IProfileRectangularRipple *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IProfileRipple = {"_p_IProfileRipple", "IProfileRipple *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IRotation = {"_p_IRotation", "IRotation *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ISampleBuilder = {"_p_ISampleBuilder", "ISampleBuilder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISampleNode = {"_p_ISampleNode", "ISampleNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISawtoothRipple = {"_p_ISawtoothRipple", "ISawtoothRipple *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISelectionRule = {"_p_ISelectionRule", "ISelectionRule *", 0, 0, (void*)0, 0};
@@ -76356,7 +76112,6 @@ static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argume
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t = {"_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t", "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *|std::map< std::string,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_double_double_t = {"_p_std__pairT_double_double_t", "std::pair< double,double > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__shared_ptrT_ISampleBuilder_t = {"_p_std__shared_ptrT_ISampleBuilder_t", "std::shared_ptr< ISampleBuilder > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t = {"_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t", "std::vector< BasicVector3D< double > > *|std::vector< BasicVector3D< double >,std::allocator< BasicVector3D< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t = {"_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t", "std::vector< BasicVector3D< std::complex< double > > > *|std::vector< BasicVector3D< std::complex< double > >,std::allocator< BasicVector3D< std::complex< double > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t = {"_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t", "std::vector< IFormFactor *,std::allocator< IFormFactor * > > *|std::vector< IFormFactor * > *", 0, 0, (void*)0, 0};
@@ -76460,7 +76215,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_IProfileRectangularRipple,
&_swigt__p_IProfileRipple,
&_swigt__p_IRotation,
- &_swigt__p_ISampleBuilder,
&_swigt__p_ISampleNode,
&_swigt__p_ISawtoothRipple,
&_swigt__p_ISelectionRule,
@@ -76541,7 +76295,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__lessT_std__string_t,
&_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
&_swigt__p_std__pairT_double_double_t,
- &_swigt__p_std__shared_ptrT_ISampleBuilder_t,
&_swigt__p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t,
&_swigt__p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t,
&_swigt__p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t,
@@ -76645,7 +76398,6 @@ static swig_cast_info _swigc__p_IPeakShape[] = { {&_swigt__p_IPeakShape, 0, 0,
static swig_cast_info _swigc__p_IProfileRectangularRipple[] = { {&_swigt__p_IProfileRectangularRipple, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IProfileRipple[] = { {&_swigt__p_FormFactorCosineRippleLorentz, _p_FormFactorCosineRippleLorentzTo_p_IProfileRipple, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleLorentz, _p_FormFactorSawtoothRippleLorentzTo_p_IProfileRipple, 0, 0}, {&_swigt__p_IProfileRectangularRipple, _p_IProfileRectangularRippleTo_p_IProfileRipple, 0, 0}, {&_swigt__p_ISawtoothRipple, _p_ISawtoothRippleTo_p_IProfileRipple, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleBox, _p_FormFactorSawtoothRippleBoxTo_p_IProfileRipple, 0, 0}, {&_swigt__p_FormFactorCosineRippleBox, _p_FormFactorCosineRippleBoxTo_p_IProfileRipple, 0, 0}, {&_swigt__p_IProfileRipple, 0, 0, 0}, {&_swigt__p_ICosineRipple, _p_ICosineRippleTo_p_IProfileRipple, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleGauss, _p_FormFactorSawtoothRippleGaussTo_p_IProfileRipple, 0, 0}, {&_swigt__p_FormFactorCosineRippleGauss, _p_FormFactorCosineRippleGaussTo_p_IProfileRipple, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IRotation[] = { {&_swigt__p_RotationY, _p_RotationYTo_p_IRotation, 0, 0}, {&_swigt__p_RotationEuler, _p_RotationEulerTo_p_IRotation, 0, 0}, {&_swigt__p_RotationZ, _p_RotationZTo_p_IRotation, 0, 0}, {&_swigt__p_IRotation, 0, 0, 0}, {&_swigt__p_IdentityRotation, _p_IdentityRotationTo_p_IRotation, 0, 0}, {&_swigt__p_RotationX, _p_RotationXTo_p_IRotation, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ISampleBuilder[] = { {&_swigt__p_ISampleBuilder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISampleNode[] = { {&_swigt__p_FormFactorBox, _p_FormFactorBoxTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorSphereGaussianRadius, _p_FormFactorSphereGaussianRadiusTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorSphereLogNormalRadius, _p_FormFactorSphereLogNormalRadiusTo_p_ISampleNode, 0, 0}, {&_swigt__p_MultiLayer, _p_MultiLayerTo_p_ISampleNode, 0, 0}, {&_swigt__p_ParticleLayout, _p_ParticleLayoutTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorHemiEllipsoid, _p_FormFactorHemiEllipsoidTo_p_ISampleNode, 0, 0}, {&_swigt__p_IBornFF, _p_IBornFFTo_p_ISampleNode, 0, 0}, {&_swigt__p_MisesGaussPeakShape, _p_MisesGaussPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_MisesFisherGaussPeakShape, _p_MisesFisherGaussPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_LorentzFisherPeakShape, _p_LorentzFisherPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_GaussFisherPeakShape, _p_GaussFisherPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_IsotropicLorentzPeakShape, _p_IsotropicLorentzPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_IPeakShape, _p_IPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_IsotropicGaussPeakShape, _p_IsotropicGaussPeakShapeTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorPrism3, _p_FormFactorPrism3To_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorTetrahedron, _p_FormFactorTetrahedronTo_p_ISampleNode, 0, 0}, {&_swigt__p_IFormFactorPolyhedron, _p_IFormFactorPolyhedronTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCuboctahedron, _p_FormFactorCuboctahedronTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorDodecahedron, _p_FormFactorDodecahedronTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorIcosahedron, _p_FormFactorIcosahedronTo_p_ISampleNode, 0, 0}, {&_swigt__p_IFormFactorPrism, _p_IFormFactorPrismTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorPrism6, _p_FormFactorPrism6To_p_ISampleNode, 0, 0}, {&_swigt__p_ParticleCoreShell, _p_ParticleCoreShellTo_p_ISampleNode, 0, 0}, {&_swigt__p_IProfileRectangularRipple, _p_IProfileRectangularRippleTo_p_ISampleNode, 0, 0}, {&_swigt__p_ISawtoothRipple, _p_ISawtoothRippleTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorFullSphere, _p_FormFactorFullSphereTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorTruncatedSphere, _p_FormFactorTruncatedSphereTo_p_ISampleNode, 0, 0}, {&_swigt__p_IFormFactor, _p_IFormFactorTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorLongBoxGauss, _p_FormFactorLongBoxGaussTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceHardDisk, _p_InterferenceHardDiskTo_p_ISampleNode, 0, 0}, {&_swigt__p_IInterference, _p_IInterferenceTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorTruncatedSpheroid, _p_FormFactorTruncatedSpheroidTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorFullSpheroid, _p_FormFactorFullSpheroidTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorTruncatedCube, _p_FormFactorTruncatedCubeTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCantellatedCube, _p_FormFactorCantellatedCubeTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceTwin, _p_InterferenceTwinTo_p_ISampleNode, 0, 0}, {&_swigt__p_Particle, _p_ParticleTo_p_ISampleNode, 0, 0}, {&_swigt__p_IParticle, _p_IParticleTo_p_ISampleNode, 0, 0}, {&_swigt__p_IAbstractParticle, _p_IAbstractParticleTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleBox, _p_FormFactorSawtoothRippleBoxTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCosineRippleBox, _p_FormFactorCosineRippleBoxTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCone, _p_FormFactorConeTo_p_ISampleNode, 0, 0}, {&_swigt__p_Layer, _p_LayerTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorPyramid, _p_FormFactorPyramidTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorAnisoPyramid, _p_FormFactorAnisoPyramidTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCylinder, _p_FormFactorCylinderTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorEllipsoidalCylinder, _p_FormFactorEllipsoidalCylinderTo_p_ISampleNode, 0, 0}, {&_swigt__p_ParticleComposition, _p_ParticleCompositionTo_p_ISampleNode, 0, 0}, {&_swigt__p_ISampleNode, 0, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleGauss, _p_FormFactorSawtoothRippleGaussTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCosineRippleGauss, _p_FormFactorCosineRippleGaussTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCone6, _p_FormFactorCone6To_p_ISampleNode, 0, 0}, {&_swigt__p_IFormFactorDecorator, _p_IFormFactorDecoratorTo_p_ISampleNode, 0, 0}, {&_swigt__p_LayerRoughness, _p_LayerRoughnessTo_p_ISampleNode, 0, 0}, {&_swigt__p_Crystal, _p_CrystalTo_p_ISampleNode, 0, 0}, {&_swigt__p_MesoCrystal, _p_MesoCrystalTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceRadialParaCrystal, _p_InterferenceRadialParaCrystalTo_p_ISampleNode, 0, 0}, {&_swigt__p_Interference2DParaCrystal, _p_Interference2DParaCrystalTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCrystal, _p_FormFactorCrystalTo_p_ISampleNode, 0, 0}, {&_swigt__p_IProfileRipple, _p_IProfileRippleTo_p_ISampleNode, 0, 0}, {&_swigt__p_ICosineRipple, _p_ICosineRippleTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorHollowSphere, _p_FormFactorHollowSphereTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorGaussSphere, _p_FormFactorGaussSphereTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorWeighted, _p_FormFactorWeightedTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceNone, _p_InterferenceNoneTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorLongBoxLorentz, _p_FormFactorLongBoxLorentzTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleLorentz, _p_FormFactorSawtoothRippleLorentzTo_p_ISampleNode, 0, 0}, {&_swigt__p_FormFactorCosineRippleLorentz, _p_FormFactorCosineRippleLorentzTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceFinite3DLattice, _p_InterferenceFinite3DLatticeTo_p_ISampleNode, 0, 0}, {&_swigt__p_InterferenceFinite2DLattice, _p_InterferenceFinite2DLatticeTo_p_ISampleNode, 0, 0}, {&_swigt__p_Interference3DLattice, _p_Interference3DLatticeTo_p_ISampleNode, 0, 0}, {&_swigt__p_Interference2DSuperLattice, _p_Interference2DSuperLatticeTo_p_ISampleNode, 0, 0}, {&_swigt__p_Interference2DLattice, _p_Interference2DLatticeTo_p_ISampleNode, 0, 0}, {&_swigt__p_Interference1DLattice, _p_Interference1DLatticeTo_p_ISampleNode, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISawtoothRipple[] = { {&_swigt__p_FormFactorSawtoothRippleLorentz, _p_FormFactorSawtoothRippleLorentzTo_p_ISawtoothRipple, 0, 0}, {&_swigt__p_ISawtoothRipple, 0, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleBox, _p_FormFactorSawtoothRippleBoxTo_p_ISawtoothRipple, 0, 0}, {&_swigt__p_FormFactorSawtoothRippleGauss, _p_FormFactorSawtoothRippleGaussTo_p_ISawtoothRipple, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISelectionRule[] = { {&_swigt__p_ISelectionRule, 0, 0, 0}, {&_swigt__p_SimpleSelectionRule, _p_SimpleSelectionRuleTo_p_ISelectionRule, 0, 0},{0, 0, 0, 0}};
@@ -76726,7 +76478,6 @@ static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__in
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t[] = { {&_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_double_double_t[] = { {&_swigt__p_std__pairT_double_double_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__shared_ptrT_ISampleBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ISampleBuilder_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t[] = { {&_swigt__p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t[] = { {&_swigt__p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t[] = { {&_swigt__p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -76830,7 +76581,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_IProfileRectangularRipple,
_swigc__p_IProfileRipple,
_swigc__p_IRotation,
- _swigc__p_ISampleBuilder,
_swigc__p_ISampleNode,
_swigc__p_ISawtoothRipple,
_swigc__p_ISelectionRule,
@@ -76911,7 +76661,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__lessT_std__string_t,
_swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
_swigc__p_std__pairT_double_double_t,
- _swigc__p_std__shared_ptrT_ISampleBuilder_t,
_swigc__p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t,
_swigc__p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t,
_swigc__p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t,
diff --git a/auto/Wrap/libBornAgainSample_wrap.h b/auto/Wrap/libBornAgainSample_wrap.h
index fc45908649c4505b5a2af9d4538826abaeb4b86c..a7ffaae59bb48409ee3aa9ade040fe5001b1c253 100644
--- a/auto/Wrap/libBornAgainSample_wrap.h
+++ b/auto/Wrap/libBornAgainSample_wrap.h
@@ -194,46 +194,4 @@ private:
};
-class SwigDirector_ISampleBuilder : public ISampleBuilder, public Swig::Director {
-
-public:
- SwigDirector_ISampleBuilder(PyObject *self);
- virtual ~SwigDirector_ISampleBuilder();
- virtual MultiLayer *buildSample() const;
-
-/* Internal director utilities */
-public:
- bool swig_get_inner(const char *swig_protected_method_name) const {
- std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
- return (iv != swig_inner.end() ? iv->second : false);
- }
- void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
- swig_inner[swig_protected_method_name] = swig_val;
- }
-private:
- mutable std::map<std::string, bool> swig_inner;
-
-#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
-/* VTable implementation */
- PyObject *swig_get_method(size_t method_index, const char *method_name) const {
- PyObject *method = vtable[method_index];
- if (!method) {
- swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
- method = PyObject_GetAttr(swig_get_self(), name);
- if (!method) {
- std::string msg = "Method in class ISampleBuilder doesn't exist, undefined ";
- msg += method_name;
- Swig::DirectorMethodException::raise(msg.c_str());
- }
- vtable[method_index] = method;
- }
- return method;
- }
-private:
- mutable swig::SwigVar_PyObject vtable[1];
-#endif
-
-};
-
-
#endif