python-gyoto 1.0.2-2ubuntu1 / usr / lib / python2.7 / dist-packages / gyoto_std.py

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




"""The Gyoto standard plug-in"""


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gyoto_std', [dirname(__file__)])
        except ImportError:
            import _gyoto_std
            return _gyoto_std
        if fp is not None:
            try:
                _mod = imp.load_module('_gyoto_std', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gyoto_std = swig_import_helper()
    del swig_import_helper
else:
    import _gyoto_std
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


import gyoto
class StandardAstrobj(gyoto.Astrobj, gyoto.Functor__Double_constDoubleArray):
    """


    Astronomical objects defined bya a potential/distance.

    Many geometrically thick objects can be defined by the value of a
    function of the 4 coordinates, and their emission can often be defined
    in terms of an emission law and of a transmission law.

    This is a base class for this standard case which simplifies a lot
    writting new Astrobjs.

    It is either to implement a sub-class of Astrobj::Standard than a sub-
    class of Astrobj::Generic. In particular, there is no need to
    implement the Generic::Impact() function. Instead, one needs to
    implement a few much simpler functions and most of the complex ray-
    tracing algorithms and heuristics is implemented in
    Standard::Impact(). It is recommended to read first the introduction
    in the Gyoto::Astrobj namespace documentation.

    The geometrical shape of a Gyoto::Astrobj::Standard object is yielded
    by a function of the 4 position vector. This function is implemented
    as operator()(). The velocity field of the fluid is implemented in the
    getVelocity() method. The emission(), integrateEmission() and
    transmission() methods implement the radiative transfer primitives for
    this object. Finally, you may choose to reimplement
    processHitQuantities() and Impact(), but this should not be necessary
    (that is the all point of the Standard class).

    Like any other Astrobj::Generic sub-classes, an Astrobj::Standard
    subclass should register an Astrobj::Subcontractor_t function using
    the Astrobj::Register() function. See also Writing plug-ins for Gyoto
    .

    C++ includes: GyotoStandardAstrobj.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Astrobj, gyoto.Functor__Double_constDoubleArray]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardAstrobj, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Astrobj, gyoto.Functor__Double_constDoubleArray]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardAstrobj, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(StandardAstrobj self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.StandardAstrobj_getProperties(self)

    __swig_destroy__ = _gyoto_std.delete_StandardAstrobj
    __del__ = lambda self: None

    def safetyValue(self, *args):
        """
        safetyValue(StandardAstrobj self, double val)
        safetyValue(StandardAstrobj self) -> double



        Get Standard::safety_value_. 
        """
        return _gyoto_std.StandardAstrobj_safetyValue(self, *args)


    def Impact(self, ph, index, data=None):
        """
        Impact(StandardAstrobj self, Photon ph, size_t index, AstrobjProperties data=None) -> int
        Impact(StandardAstrobj self, Photon ph, size_t index) -> int



        Does a photon at these coordinates impact the object?

        Impact() checks whether a Photon impacts the object between two
        integration steps of the photon's trajectory (those two steps are
        photon->getCoord(index, coord1) and photon->getCoord(index+1,
        coord2)). Impact returns 1 if the photon impacts the object between
        these two steps, else 0. In many cases of geometrically thick obects,
        the implementation Astrobj::Standard::Impact() will be fine.

        Impact will call Generic::processHitQuantities() (which is virtual and
        may be re-implemented) to compute observable properties on demand: if
        the data pointer is non-NULL, the object will look in it for pointers
        to properties which apply to its kind. If a pointer to a property
        known to this object is present, then the property is computed and
        store at the pointed-to address. For instance, all objects know the
        "intensity" property. If data->intensity != NULL, the instensity is
        computed and stored in *data->intensity.

        If data is non-NULL and only in this case, processHitQuantities() will
        also call ph->transmit() to update the transmissions of the Photon
        (see Photon::transmit(size_t, double)). This must not be done if data
        is NULL (see Astrobj::Complex::Impact() for an explanation).

        Parameters:
        -----------

        ph:   Gyoto::Photon aimed at the object;

        index:  Index of the last photon step;

        data:  Pointer to a structure to hold the observables at impact.

        1 if impact, 0 if not. 
        """
        return _gyoto_std.StandardAstrobj_Impact(self, ph, index, data)


    def __call__(self, coord):
        """__call__(StandardAstrobj self, double const [4] coord) -> double"""
        return _gyoto_std.StandardAstrobj___call__(self, coord)


    def getVelocity(self, pos, vel):
        """
        getVelocity(StandardAstrobj self, double const [4] pos, double [4] vel)



        Fluid velocity field.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto_std.StandardAstrobj_getVelocity(self, pos, vel)


    def giveDelta(self, coord):
        """
        giveDelta(StandardAstrobj self, double [8] coord) -> double



        Maximum inside object.

        Gives the requested integration stept (in coordinate time t) between
        two neighbooring points along a portion of geodesic inside an astrobj

        Parameters:
        -----------

        coord:  input coordinate at whicht is given 
        """
        return _gyoto_std.StandardAstrobj_giveDelta(self, coord)


    def __init__(self, base):
        """
        __init__(Gyoto::Astrobj::Standard self, Astrobj base) -> StandardAstrobj



        Copy constructor.

        Make a deep copy of an Astrobj::Standard instance 
        """
        this = _gyoto_std.new_StandardAstrobj(base)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
StandardAstrobj_swigregister = _gyoto_std.StandardAstrobj_swigregister
StandardAstrobj_swigregister(StandardAstrobj)
cvar = _gyoto_std.cvar
StandardAstrobj.properties = _gyoto_std.cvar.StandardAstrobj_properties

class UniformSphere(StandardAstrobj):
    """


    Optically thick or thin, spherical objects.

    Gyoto::Astrobj::UniformSphere is an abstract type from which uniform,
    spherical objects inherit (in particular, the Gyoto::Astrobj::Star and
    Gyoto::Astrobj::FixedStar classes).

    These objects are coordinate-spherical: they comprise all the points
    within a given radius from a centre. The distance is the usual
    Euclidian distance in a Cartesian coordinate system which is trivially
    determined by the coordinate system in which the Metric is expressed.

    The sphere is in solid motion: all the points have the same
    4-velocity. The centre of the sphere may move. This motion and the
    velocity are provided by the derived classes through the
    getCartesian() and getVelocity() methods.

    The spheres can be optically thick or optically thin. In the optically
    thin case, the opacity law provided as a Gyoto::Spectrum also sets
    both the emissivity. Another Gyoto::Spectrum provides the emission law
    of the source, which is uniform.

    Gyoto::Astrobj::UniformSphere::setParameters() take care of
    interpreting the XML elements describing the parameters of the sphere:
    setGenericParameters() also takes care of calling setParameter().

    C++ includes: GyotoUniformSphere.h 
    """

    __swig_setmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniformSphere, name, value)
    __swig_getmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniformSphere, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(UniformSphere self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.UniformSphere_getProperties(self)

    __swig_destroy__ = _gyoto_std.delete_UniformSphere
    __del__ = lambda self: None

    def className(self):
        """
        className(UniformSphere self) -> std::string



        "UniformSphere" 
        """
        return _gyoto_std.UniformSphere_className(self)


    def className_l(self):
        """
        className_l(UniformSphere self) -> std::string



        "uniformsphere" 
        """
        return _gyoto_std.UniformSphere_className_l(self)


    def spectrum(self, *args):
        """
        spectrum(UniformSphere self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > arg2)
        spectrum(UniformSphere self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >



        Get spectrum_. 
        """
        return _gyoto_std.UniformSphere_spectrum(self, *args)


    def opacity(self, *args):
        """
        opacity(UniformSphere self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > arg2)
        opacity(UniformSphere self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >



        Get opacity_. 
        """
        return _gyoto_std.UniformSphere_opacity(self, *args)


    def radius(self, *args):
        """
        radius(UniformSphere self) -> double
        radius(UniformSphere self, double arg2)
        radius(UniformSphere self, std::string const & arg2) -> double
        radius(UniformSphere self, double arg2, std::string const & arg3)



        Set radius_ in specified unit. 
        """
        return _gyoto_std.UniformSphere_radius(self, *args)


    def deltaMaxOverRadius(self, *args):
        """
        deltaMaxOverRadius(UniformSphere self) -> double
        deltaMaxOverRadius(UniformSphere self, double f)



        Set dltmor_. 
        """
        return _gyoto_std.UniformSphere_deltaMaxOverRadius(self, *args)


    def deltaMaxOverDistance(self, *args):
        """
        deltaMaxOverDistance(UniformSphere self) -> double
        deltaMaxOverDistance(UniformSphere self, double f)



        Set dltmod_. 
        """
        return _gyoto_std.UniformSphere_deltaMaxOverDistance(self, *args)


    def isotropic(self, *args):
        """
        isotropic(UniformSphere self) -> bool
        isotropic(UniformSphere self, bool arg2)
        """
        return _gyoto_std.UniformSphere_isotropic(self, *args)


    def alpha(self, *args):
        """
        alpha(UniformSphere self) -> double
        alpha(UniformSphere self, double arg2)
        """
        return _gyoto_std.UniformSphere_alpha(self, *args)


    def __call__(self, coord):
        """__call__(UniformSphere self, double const [4] coord) -> double"""
        return _gyoto_std.UniformSphere___call__(self, coord)


    def deltaMax(self, coord):
        """
        deltaMax(UniformSphere self, double * coord) -> double



        Get max step constraint for adaptive integration.

        Parameters:
        -----------

        coord:  position

        max step to find this object reliably 
        """
        return _gyoto_std.UniformSphere_deltaMax(self, coord)


    def __init__(self, base):
        """
        __init__(Gyoto::Astrobj::UniformSphere self, Astrobj base) -> UniformSphere



        Copy constructor. 
        """
        this = _gyoto_std.new_UniformSphere(base)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
UniformSphere_swigregister = _gyoto_std.UniformSphere_swigregister
UniformSphere_swigregister(UniformSphere)
UniformSphere.properties = _gyoto_std.cvar.UniformSphere_properties

class ComplexAstrobj(gyoto.Astrobj):
    """


    Complex astronomical object.

    A Gyoto::Astrobj::Generic whic contain several Gyoto::Astrobj::Generic
    instances. It is essentially a SmartPointer<Astrobj::Generic> array,
    which some methods around. Indeed, the operator[](size_t i) method is
    implemented to retrieve the i-th element.

    In an XML description, the < Astrobj> section must be unique, its kind
    is "Complex". Each sub-astrobj then appears as a <SubAstrobj>
    subsection:

    C++ includes: GyotoComplexAstrobj.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Astrobj]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComplexAstrobj, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Astrobj]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComplexAstrobj, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ComplexAstrobj self) -> ComplexAstrobj



        "Virtual" copy constructor 
        """
        return _gyoto_std.ComplexAstrobj_clone(self)


    def deltaMax(self, coord):
        """
        deltaMax(ComplexAstrobj self, double [8] coord) -> double



        Get max step constraint for adaptive integration.

        Parameters:
        -----------

        coord:  position

        max step to find this object reliably 
        """
        return _gyoto_std.ComplexAstrobj_deltaMax(self, coord)

    __swig_destroy__ = _gyoto_std.delete_ComplexAstrobj
    __del__ = lambda self: None

    def append(self, element):
        """
        append(ComplexAstrobj self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > element)



        Add element at the end of the array.

        If the Astrobj::Complex itself does not have a metric already
        assigned, it takes it from the new element. Else, it sets the metric
        in the new element to its own. This ensures that all elements use the
        same metric (this heuristic is not entirely fool-proof, it's safer to
        set the metric directly in the Astrobj::Complex). 
        """
        return _gyoto_std.ComplexAstrobj_append(self, element)


    def remove(self, i):
        """
        remove(ComplexAstrobj self, size_t i)



        Remove i-th element from the array. 
        """
        return _gyoto_std.ComplexAstrobj_remove(self, i)


    def getCardinal(self):
        """
        getCardinal(ComplexAstrobj self) -> size_t



        Get the number of elements in the array. 
        """
        return _gyoto_std.ComplexAstrobj_getCardinal(self)


    def metric(self, *args):
        """
        metric(ComplexAstrobj self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(ComplexAstrobj self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(ComplexAstrobj self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg)



        Get the Metric gg_. 
        """
        return _gyoto_std.ComplexAstrobj_metric(self, *args)


    def fillElement(self, fmp):
        """
        fillElement(ComplexAstrobj self, FactoryMessenger fmp)



        Fill the XML element for this Object.

        The base implementation simply calls fillProperty() for each Property
        defined for the Object.

        Derived classes should avoid overriding fillElement(). It may make
        sense occasionally, e.g. to make sure that the metric is output first.

        To customize how a given Property is rendered, it is better to
        override fillProperty().

        If this method is overridden, the implementation should in general
        call fillElement() on the direct base. 
        """
        return _gyoto_std.ComplexAstrobj_fillElement(self, fmp)


    def setParameters(self, fmp):
        """
        setParameters(ComplexAstrobj self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto_std.ComplexAstrobj_setParameters(self, fmp)


    def Impact(self, ph, index, data=None):
        """
        Impact(ComplexAstrobj self, Photon ph, size_t index, AstrobjProperties data=None) -> int
        Impact(ComplexAstrobj self, Photon ph, size_t index) -> int



        Call Impact() for each of the elements.

        Astrobj::Complex::Impact( Gyoto::Photon* ph, size_t index,
        Astrobj::Properties *data) calls the specific implementation of
        Astrobj::Generic::Impact() for each of its elements twice: the first
        time, data is set to NULL so that Astrobj::Complex::Impact() only
        knows whether each object is hit by the Photon. If no object is hit,
        return. If a single object is hit, call Impact() again only for this
        object, passing data this time. If several objects are hit, the
        Photon's trajectory is refined so that the step is at most step_max_
        and the Impact() methods for each of the hit objects are called again
        for each step, passing data. It is therefore important that the
        transmission of the Photon is not touched by Impact() when data==NULL.

        """
        return _gyoto_std.ComplexAstrobj_Impact(self, ph, index, data)


    def __getitem__(self, i):
        """__getitem__(ComplexAstrobj self, int i) -> Astrobj"""
        return _gyoto_std.ComplexAstrobj___getitem__(self, i)


    def __setitem__(self, i, p):
        """__setitem__(ComplexAstrobj self, int i, Astrobj p)"""
        return _gyoto_std.ComplexAstrobj___setitem__(self, i, p)


    def __init__(self, *args):
        """
        Complex() -> ComplexAstrobj
        Complex(ComplexAstrobj arg2) -> ComplexAstrobj
        __init__(Gyoto::Astrobj::Complex self, Astrobj base) -> ComplexAstrobj



        Copy constructor. 
        """
        this = _gyoto_std.new_ComplexAstrobj(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
ComplexAstrobj_swigregister = _gyoto_std.ComplexAstrobj_swigregister
ComplexAstrobj_swigregister(ComplexAstrobj)

class Star(UniformSphere, gyoto.Worldline):
    """


    Mass-less, spherical object following a timelike geodesic.

    Gyoto can compute the Star's orbit in a Gyoto::Metric and perform ray-
    tracing on this target. The XML description of a Star looks like:

    Star supports exactly the union of the parameters supported by
    Gyoto::Astrobj::UniformSphere and Gyoto::Worldline.

    The Metric element can be of any kind. This Metric sets the coordinate
    system.

    The Star is a coordinate sphere of radius Radius in solid motion.

    Position sets the initial 4-coordinate of the centre of the sphere.
    Velocity contains its initial 3-velocity (the time derivatives of the
    3 space coordinates).

    Like many Astrobj::Generic impementations, a Star can be OpticallyThin
    or OpticallyThick.

    Spectrum and Opacity (if OpticallyThin) are the descriptions of two
    Gyoto::Spectrum::Generic sub-classes.

    C++ includes: GyotoStar.h 
    """

    __swig_setmethods__ = {}
    for _s in [UniformSphere, gyoto.Worldline]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Star, name, value)
    __swig_getmethods__ = {}
    for _s in [UniformSphere, gyoto.Worldline]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Star, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(Star self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.Star_getProperties(self)


    def clone(self):
        """
        clone(Star self) -> Star



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto_std.Star_clone(self)

    __swig_destroy__ = _gyoto_std.delete_Star
    __del__ = lambda self: None

    def className(self):
        """
        className(Star self) -> std::string



        "Star" 
        """
        return _gyoto_std.Star_className(self)


    def className_l(self):
        """
        className_l(Star self) -> std::string



        "star" 
        """
        return _gyoto_std.Star_className_l(self)


    def metric(self, *args):
        """
        metric(Star self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(Star self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >



        Get the Metric gg_. 
        """
        return _gyoto_std.Star_metric(self, *args)


    def getMass(self):
        """
        getMass(Star self) -> double



        Return 1.

        The mass of a Star is always 1. Stars do not perturb the metric. The
        only relevant point is that Stars are massive particules, their exact
        mass is of no importance. 
        """
        return _gyoto_std.Star_getMass(self)


    def rMax(self, *args):
        """
        rMax(Star self) -> double
        rMax(Star self, std::string const & unit) -> double
        rMax(Star self, std::string const & unit) -> double
        rMax(Star self, double val)
        rMax(Star self, double val, std::string const & unit)
        rMax(Star self) -> double



        Set maximal distance from center of coordinate system.

        Call Generic::rMax(double val) after converting val from unit to
        geometrical units.

        Parameters:
        -----------

        val:   rmax_ expressed in unit "unit";

        unit:  string... 
        """
        return _gyoto_std.Star_rMax(self, *args)


    def setInitialCondition(self, coord):
        """
        setInitialCondition(Star self, double [8] coord)



        Set or re-set the initial condition prior to integration.

        Parameters:
        -----------

        gg:   Gyoto::SmartPointer to the Gyoto::Metric in this universe;

        coord:  8 element array containing the initial condition, i.e. the
        4-position and the 4-velocity of the Photon at the receiving end;

        dir:  direction: 1 for future, -1 for past. 
        """
        return _gyoto_std.Star_setInitialCondition(self, coord)


    def setParameter(self, name, content, unit):
        """
        setParameter(Star self, std::string name, std::string content, std::string unit) -> int



        Set parameter by Property (and name)

        This function is used when parsing an XML description, if Property (
        p) of this name is found (i.e. either p.name or p.name_false is equal
        to name). Implementation should fall-back on calling the direct's
        parent implementation:

        Parameters:
        -----------

        p:   Property that matches name ( p.name == name or p.name_false ==
        name)

        name:  XML name of the parameter (XML entity)

        content:  string representation of the value

        unit:  string representation of the unit 
        """
        return _gyoto_std.Star_setParameter(self, name, content, unit)


    def setParameters(self, fmp):
        """
        setParameters(Star self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto_std.Star_setParameters(self, fmp)


    def fillProperty(self, fmp, p):
        """
        fillProperty(Star self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto_std.Star_fillProperty(self, fmp, p)


    def _delta(self, *args):
        """
        _delta(Star self, double const delta)
        _delta(Star self, double arg2, std::string const & unit)
        _delta(Star self) -> double
        _delta(Star self, std::string const & unit) -> double
        """
        return _gyoto_std.Star__delta(self, *args)


    def _tMin(self, *args):
        """
        _tMin(Star self, double const tmin)
        _tMin(Star self, double arg2, std::string const & unit)
        _tMin(Star self) -> double
        _tMin(Star self, std::string const & unit) -> double
        """
        return _gyoto_std.Star__tMin(self, *args)


    def _adaptive(self, *args):
        """
        _adaptive(Star self, bool mode)
        _adaptive(Star self) -> bool
        """
        return _gyoto_std.Star__adaptive(self, *args)


    def _secondary(self, *args):
        """
        _secondary(Star self, bool sec)
        _secondary(Star self) -> bool
        """
        return _gyoto_std.Star__secondary(self, *args)


    def _maxiter(self, *args):
        """
        _maxiter(Star self, size_t miter)
        _maxiter(Star self) -> size_t
        """
        return _gyoto_std.Star__maxiter(self, *args)


    def _integrator(self, *args):
        """
        _integrator(Star self, std::string const & type)
        _integrator(Star self) -> std::string
        """
        return _gyoto_std.Star__integrator(self, *args)


    def _deltaMin(self, *args):
        """
        _deltaMin(Star self) -> double
        _deltaMin(Star self, double h1)
        """
        return _gyoto_std.Star__deltaMin(self, *args)


    def _absTol(self, *args):
        """
        _absTol(Star self, double arg2)
        _absTol(Star self) -> double
        """
        return _gyoto_std.Star__absTol(self, *args)


    def _relTol(self, *args):
        """
        _relTol(Star self, double arg2)
        _relTol(Star self) -> double
        """
        return _gyoto_std.Star__relTol(self, *args)


    def _deltaMax(self, *args):
        """
        _deltaMax(Star self, double h1)
        _deltaMax(Star self) -> double
        """
        return _gyoto_std.Star__deltaMax(self, *args)


    def _deltaMaxOverR(self, *args):
        """
        _deltaMaxOverR(Star self) -> double
        _deltaMaxOverR(Star self, double t)
        """
        return _gyoto_std.Star__deltaMaxOverR(self, *args)


    def _initCoord(self, *args):
        """
        _initCoord(Star self) -> vector_double
        _initCoord(Star self, vector_double f)
        """
        return _gyoto_std.Star__initCoord(self, *args)


    def _metric(self, *args):
        """
        _metric(Star self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        _metric(Star self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        """
        return _gyoto_std.Star__metric(self, *args)


    def deltaMax(self, *args):
        """
        deltaMax(Star self) -> double
        deltaMax(Star self, double const [8] pos, double delta_max_external) -> double
        deltaMax(Star self, double h1)
        deltaMax(Star self, double * coord) -> double



        Get max step constraint for adaptive integration.

        Parameters:
        -----------

        coord:  position

        max step to find this object reliably 
        """
        return _gyoto_std.Star_deltaMax(self, *args)


    def getCartesian(self, dates, n_dates, x, y, z, xprime=None, yprime=None, zprime=None):
        """
        getCartesian(Star self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None, double *const yprime=None, double *const zprime=None)
        getCartesian(Star self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None, double *const yprime=None)
        getCartesian(Star self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None)
        getCartesian(Star self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z)



        Get the 6 Cartesian coordinates for specific dates.

        This method is present in both the API of UniformSphere and Worldline.
        It is pure virtual in UniformSphere. The Star reimplementation is a
        trivial wrapper around Worldline::getCartesian(). 
        """
        return _gyoto_std.Star_getCartesian(self, dates, n_dates, x, y, z, xprime, yprime, zprime)


    def getVelocity(self, pos, vel):
        """
        getVelocity(Star self, double const [4] pos, double [4] vel)



        Yield velocity of the center of the sphere. 
        """
        return _gyoto_std.Star_getVelocity(self, pos, vel)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::Star self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, double radius, double [4] pos, double [3] v) -> Star
        __init__(Gyoto::Astrobj::Star self) -> Star
        __init__(Gyoto::Astrobj::Star self, Star orig) -> Star
        __init__(Gyoto::Astrobj::Star self, Astrobj base) -> Star



        Copy constructor. 
        """
        this = _gyoto_std.new_Star(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Star_swigregister = _gyoto_std.Star_swigregister
Star_swigregister(Star)
Star.properties = _gyoto_std.cvar.Star_properties

class StarTrace(Star):
    """


    Like a Star that would be on all points of its orbit at all time.

    StarTrace inherits all the members and methods from Star. It has two
    additional members, tmin_ and tmax_, which specify the time interval
    of the Star's orbit that is to be considerred illuminated.

    A StarTrace is not (necessarily) continuous: the Star is considerred
    to be present at all the locations computed by xFill(), meaning that
    if the integration step is large compared to radius_, the object will
    be a collection of discrete blobs. To ensure continuity, one should
    use a non-adaptive step and specify a reasonable step. Computation is
    also faster in optically thick mode.

    C++ includes: GyotoStarTrace.h 
    """

    __swig_setmethods__ = {}
    for _s in [Star]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StarTrace, name, value)
    __swig_getmethods__ = {}
    for _s in [Star]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StarTrace, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(StarTrace self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.StarTrace_getProperties(self)


    def clone(self):
        """
        clone(StarTrace self) -> StarTrace



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto_std.StarTrace_clone(self)

    __swig_destroy__ = _gyoto_std.delete_StarTrace
    __del__ = lambda self: None

    def xAllocate(self, *args):
        """
        xAllocate(StarTrace self)
        xAllocate(StarTrace self, size_t arg2)



        Allocate x0, x1 etc. with a specified size.

        Parameters:
        -----------

        size:  : number of cells in each array x0, x1 etc. 
        """
        return _gyoto_std.StarTrace_xAllocate(self, *args)


    def xAllocateXYZ(self):
        """
        xAllocateXYZ(StarTrace self)



        Allocate x_, y_, z_. 
        """
        return _gyoto_std.StarTrace_xAllocateXYZ(self)


    def xExpand(self, *args):
        """
        xExpand(StarTrace self, double *& x, int dir)
        xExpand(StarTrace self, int arg2) -> size_t



        Expand x0, x1 etc... to hold more elements.

        Double the size of arrays x0, x1 etc. and copy old version of the
        array in the first half if dir =1 and in the second half if dir =-1.

        Parameters:
        -----------

        dir:  : 1 to expand after last element, -1 to expand before first
        element

        ind : if dir=1, new index of old last element, if dir=-1, new index of
        old first element 
        """
        return _gyoto_std.StarTrace_xExpand(self, *args)


    def computeXYZ(self, *args):
        """
        computeXYZ(StarTrace self, size_t i)
        computeXYZ(StarTrace self)



        Compute (and cache) x_, y_ and z_. 
        """
        return _gyoto_std.StarTrace_computeXYZ(self, *args)


    def setInitCoord(self, *args):
        """
        setInitCoord(StarTrace self, double [4] pos, double [3] vel, int dir=1)
        setInitCoord(StarTrace self, double [4] pos, double [3] vel)
        setInitCoord(StarTrace self, double const [8] coord, int dir=0)
        setInitCoord(StarTrace self, double const [8] coord)



        Set initial coordinate.

        Parameters:
        -----------

        pos:  initial 4-position

        vel:  initial 3-velocity

        dir:  direction of integration 
        """
        return _gyoto_std.StarTrace_setInitCoord(self, *args)


    def metric(self, *args):
        """
        metric(StarTrace self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(StarTrace self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(StarTrace self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg)



        Get the Metric gg_. 
        """
        return _gyoto_std.StarTrace_metric(self, *args)


    def xStore(self, ind, coord):
        """
        xStore(StarTrace self, size_t ind, double [8] coord)



        Store coord at index ind. 
        """
        return _gyoto_std.StarTrace_xStore(self, ind, coord)


    def className(self):
        """
        className(StarTrace self) -> std::string



        "StarTrace" 
        """
        return _gyoto_std.StarTrace_className(self)


    def className_l(self):
        """
        className_l(StarTrace self) -> std::string



        "startrace" 
        """
        return _gyoto_std.StarTrace_className_l(self)


    def TMin(self, *args):
        """
        TMin(StarTrace self) -> double
        TMin(StarTrace self, double arg2)



        Set tmin_. 
        """
        return _gyoto_std.StarTrace_TMin(self, *args)


    def TMax(self, *args):
        """
        TMax(StarTrace self) -> double
        TMax(StarTrace self, double arg2)



        Set tmax_. 
        """
        return _gyoto_std.StarTrace_TMax(self, *args)


    def setInitialCondition(self, coord):
        """
        setInitialCondition(StarTrace self, double [8] coord)



        Set or re-set the initial condition prior to integration.

        Parameters:
        -----------

        gg:   Gyoto::SmartPointer to the Gyoto::Metric in this universe;

        coord:  8 element array containing the initial condition, i.e. the
        4-position and the 4-velocity of the Photon at the receiving end;

        dir:  direction: 1 for future, -1 for past. 
        """
        return _gyoto_std.StarTrace_setInitialCondition(self, coord)


    def __call__(self, coord):
        """__call__(StarTrace self, double const [4] coord) -> double"""
        return _gyoto_std.StarTrace___call__(self, coord)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::StarTrace self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, double radius, double [4] pos, double [3] v) -> StarTrace
        __init__(Gyoto::Astrobj::StarTrace self) -> StarTrace
        __init__(Gyoto::Astrobj::StarTrace self, StarTrace orig) -> StarTrace
        __init__(Gyoto::Astrobj::StarTrace self, Star o, double tmin, double tmax) -> StarTrace
        __init__(Gyoto::Astrobj::StarTrace self, Astrobj base) -> StarTrace



        Build StarTrace from Star. 
        """
        this = _gyoto_std.new_StarTrace(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
StarTrace_swigregister = _gyoto_std.StarTrace_swigregister
StarTrace_swigregister(StarTrace)
StarTrace.properties = _gyoto_std.cvar.StarTrace_properties

class FixedStar(UniformSphere):
    """


    Fixed (i.e. non-moving) star (or spherical blob)

    The target of ray-traced Gyoto::Photon

    C++ includes: GyotoFixedStar.h 
    """

    __swig_setmethods__ = {}
    for _s in [UniformSphere]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FixedStar, name, value)
    __swig_getmethods__ = {}
    for _s in [UniformSphere]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FixedStar, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(FixedStar self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.FixedStar_getProperties(self)


    def clone(self):
        """
        clone(FixedStar self) -> FixedStar



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto_std.FixedStar_clone(self)

    __swig_destroy__ = _gyoto_std.delete_FixedStar
    __del__ = lambda self: None

    def getPos(self, *args):
        """
        getPos(FixedStar self) -> double const
        getPos(FixedStar self, double * dst)



        Get a copy of the pos_ array. 
        """
        return _gyoto_std.FixedStar_getPos(self, *args)


    def position(self, *args):
        """
        position(FixedStar self) -> vector_double
        position(FixedStar self, vector_double arg2)



        Set pos_ from vector. 
        """
        return _gyoto_std.FixedStar_position(self, *args)


    def rMax(self):
        """
        rMax(FixedStar self) -> double



        Set maximal distance from center of coordinate system.

        Call Generic::rMax(double val) after converting val from unit to
        geometrical units.

        Parameters:
        -----------

        val:   rmax_ expressed in unit "unit";

        unit:  string... 
        """
        return _gyoto_std.FixedStar_rMax(self)


    def rotating(self, *args):
        """
        rotating(FixedStar self) -> bool
        rotating(FixedStar self, bool arg2)
        """
        return _gyoto_std.FixedStar_rotating(self, *args)


    def metric(self, *args):
        """
        metric(FixedStar self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(FixedStar self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(FixedStar self, Gyoto::SmartPointer< Gyoto::Metric::Generic > metric)



        Get the Metric gg_. 
        """
        return _gyoto_std.FixedStar_metric(self, *args)


    def radius(self, *args):
        """
        radius(FixedStar self) -> double
        radius(FixedStar self, std::string const & arg2) -> double
        radius(FixedStar self, double arg2, std::string const & arg3)
        radius(FixedStar self, double radius)



        Set radius_ in specified unit. 
        """
        return _gyoto_std.FixedStar_radius(self, *args)


    def setPos(self, arg2):
        """
        setPos(FixedStar self, double const [3] arg2)



        Set pos_ array. 
        """
        return _gyoto_std.FixedStar_setPos(self, arg2)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::FixedStar self) -> FixedStar
        __init__(Gyoto::Astrobj::FixedStar self, FixedStar orig) -> FixedStar
        __init__(Gyoto::Astrobj::FixedStar self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, double [3] StPsn, double radius) -> FixedStar
        __init__(Gyoto::Astrobj::FixedStar self, Astrobj base) -> FixedStar



        Standard constructor. 
        """
        this = _gyoto_std.new_FixedStar(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
FixedStar_swigregister = _gyoto_std.FixedStar_swigregister
FixedStar_swigregister(FixedStar)
FixedStar.properties = _gyoto_std.cvar.FixedStar_properties

class Torus(StandardAstrobj):
    """


    Optically thin or thick torus in circular rotation.

    Any Metric::Generic is acceptable as long as it implements
    Metric::Generic::circularVelocity().

    C++ includes: GyotoTorus.h 
    """

    __swig_setmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Torus, name, value)
    __swig_getmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Torus, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(Torus self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.Torus_getProperties(self)


    def clone(self):
        """
        clone(Torus self) -> Torus



        "Virtual" copy constructor 
        """
        return _gyoto_std.Torus_clone(self)

    __swig_destroy__ = _gyoto_std.delete_Torus
    __del__ = lambda self: None

    def largeRadius(self, *args):
        """
        largeRadius(Torus self) -> double
        largeRadius(Torus self, std::string unit) -> double
        largeRadius(Torus self, double c)
        largeRadius(Torus self, double c, std::string unit)



        Set large radius Torus::c_ in specified unit. 
        """
        return _gyoto_std.Torus_largeRadius(self, *args)


    def smallRadius(self, *args):
        """
        smallRadius(Torus self) -> double
        smallRadius(Torus self, std::string unit) -> double
        smallRadius(Torus self, double a)
        smallRadius(Torus self, double a, std::string unit)



        Set small radius in specified unit. 
        """
        return _gyoto_std.Torus_smallRadius(self, *args)


    def spectrum(self, *args):
        """
        spectrum(Torus self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > arg2)
        spectrum(Torus self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >



        Get Torus::spectrum_. 
        """
        return _gyoto_std.Torus_spectrum(self, *args)


    def opacity(self, *args):
        """
        opacity(Torus self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > arg2)
        opacity(Torus self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >



        Get Torus::opacity_. 
        """
        return _gyoto_std.Torus_opacity(self, *args)


    def rMax(self, *args):
        """
        rMax(Torus self) -> double
        rMax(Torus self, std::string const & unit) -> double
        rMax(Torus self, std::string const & unit) -> double
        rMax(Torus self, double val)
        rMax(Torus self, double val, std::string const & unit)
        rMax(Torus self) -> double



        Set maximal distance from center of coordinate system.

        Call Generic::rMax(double val) after converting val from unit to
        geometrical units.

        Parameters:
        -----------

        val:   rmax_ expressed in unit "unit";

        unit:  string... 
        """
        return _gyoto_std.Torus_rMax(self, *args)


    def __call__(self, coord):
        """__call__(Torus self, double const [4] coord) -> double"""
        return _gyoto_std.Torus___call__(self, coord)


    def deltaMax(self, arg2):
        """
        deltaMax(Torus self, double * arg2) -> double



        Get max step constraint for adaptive integration.

        Parameters:
        -----------

        coord:  position

        max step to find this object reliably 
        """
        return _gyoto_std.Torus_deltaMax(self, arg2)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::Torus self) -> Torus
        __init__(Gyoto::Astrobj::Torus self, Torus arg2) -> Torus
        __init__(Gyoto::Astrobj::Torus self, Astrobj base) -> Torus



        Copy constructor. 
        """
        this = _gyoto_std.new_Torus(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Torus_swigregister = _gyoto_std.Torus_swigregister
Torus_swigregister(Torus)
Torus.properties = _gyoto_std.cvar.Torus_properties

class PageThorneDisk(gyoto.ThinDisk, gyoto.Listener):
    """


    Geometrically thin disk in Kerr metric.

    This class describes a disk contained in the z=0 (equatorial) plane,
    extending from r=r_ISCO to r=infinity. The flux emitted at radius r is
    given by Page & Thorne (1974, ApJ 191:499, Eqs. 11b, 14, 15).

    The metric must be either KerrBL or KerrKS. Emission, Spectrum and
    BinSpectrum are not provide, the only intensity provided is provided,
    as quantity User4 and it is the default quantity returned if nothing
    is requested. The other quantities implemented in ThinDisk are also
    provided.

    C++ includes: GyotoPageThorneDisk.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.ThinDisk, gyoto.Listener]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PageThorneDisk, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.ThinDisk, gyoto.Listener]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PageThorneDisk, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(PageThorneDisk self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.PageThorneDisk_getProperties(self)


    def clone(self):
        """
        clone(PageThorneDisk self) -> PageThorneDisk



        Cloner. 
        """
        return _gyoto_std.PageThorneDisk_clone(self)

    __swig_destroy__ = _gyoto_std.delete_PageThorneDisk
    __del__ = lambda self: None

    def metric(self, *args):
        """
        metric(PageThorneDisk self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(PageThorneDisk self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(PageThorneDisk self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)



        Get the Metric gg_. 
        """
        return _gyoto_std.PageThorneDisk_metric(self, *args)


    def BlackbodyMdot(self, *args):
        """
        BlackbodyMdot(PageThorneDisk self, double v)
        BlackbodyMdot(PageThorneDisk self) -> double
        """
        return _gyoto_std.PageThorneDisk_BlackbodyMdot(self, *args)


    def blackBody(self, *args):
        """
        blackBody(PageThorneDisk self, bool t)
        blackBody(PageThorneDisk self) -> bool
        """
        return _gyoto_std.PageThorneDisk_blackBody(self, *args)


    def uniFlux(self, *args):
        """
        uniFlux(PageThorneDisk self, bool t)
        uniFlux(PageThorneDisk self) -> bool
        """
        return _gyoto_std.PageThorneDisk_uniFlux(self, *args)


    def emission(self, *args):
        """
        emission(PageThorneDisk self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(PageThorneDisk self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(PageThorneDisk self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.PageThorneDisk_emission(self, *args)


    def bolometricEmission(self, nuem, dsem, c_obj):
        """
        bolometricEmission(PageThorneDisk self, double nuem, double dsem, double [8] c_obj) -> double



        Bolometric emission.

        Similar to Generic::emission(), but bolometric. 
        """
        return _gyoto_std.PageThorneDisk_bolometricEmission(self, nuem, dsem, c_obj)


    def processHitQuantities(self, ph, coord_ph_hit, coord_obj_hit, dt, data):
        """
        processHitQuantities(PageThorneDisk self, Photon ph, double * coord_ph_hit, double * coord_obj_hit, double dt, AstrobjProperties data)



        processHitQuantities fills the requested data in Impact. For
        PageThorneDisk, only fill User4, which corresponds to bolometric
        intensity. 
        """
        return _gyoto_std.PageThorneDisk_processHitQuantities(self, ph, coord_ph_hit, coord_obj_hit, dt, data)


    def getDefaultQuantities(self):
        """
        getDefaultQuantities(PageThorneDisk self) -> Gyoto::Quantity_t



        Which quantities to compute if know was requested.

        Return a Gyoto::Quantity_t suitable as input to
        Gyoto::Scenery::setRequestedQuantities() to set de default quantities
        to compute for this object. The default of these defaults
        GYOTO_QUANTITY_INTENSITY. 
        """
        return _gyoto_std.PageThorneDisk_getDefaultQuantities(self)


    def tell(self, msg):
        """
        tell(PageThorneDisk self, Teller msg)



        Update PageThorneDisk::aa_.

        Calls updateSpin().

        See Hook::Listener::tell() 
        """
        return _gyoto_std.PageThorneDisk_tell(self, msg)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::PageThorneDisk self) -> PageThorneDisk
        __init__(Gyoto::Astrobj::PageThorneDisk self, PageThorneDisk arg2) -> PageThorneDisk
        __init__(Gyoto::Astrobj::PageThorneDisk self, Astrobj base) -> PageThorneDisk



        Copy constructor. 
        """
        this = _gyoto_std.new_PageThorneDisk(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
PageThorneDisk_swigregister = _gyoto_std.PageThorneDisk_swigregister
PageThorneDisk_swigregister(PageThorneDisk)
PageThorneDisk.properties = _gyoto_std.cvar.PageThorneDisk_properties

class ThinDiskPL(gyoto.ThinDisk):
    """


    Geometrically thin disk with black-body emission.

    Mass density varies with a power-law, temperature depends on density.

    =0 (rcur/r0)

    XML entities: PLSlope: ThinDiskPL::PLSlope_

    PLRho: ThinDiskPL::PLRho_

    PLRadRef: ThinDiskPL::PLRadRef_

    C++ includes: GyotoThinDiskPL.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThinDiskPL, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThinDiskPL, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(ThinDiskPL self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.ThinDiskPL_getProperties(self)


    def clone(self):
        """
        clone(ThinDiskPL self) -> ThinDiskPL



        Cloner. 
        """
        return _gyoto_std.ThinDiskPL_clone(self)

    __swig_destroy__ = _gyoto_std.delete_ThinDiskPL
    __del__ = lambda self: None

    def PLSlope(self, *args):
        """
        PLSlope(ThinDiskPL self, double arg2)
        PLSlope(ThinDiskPL self) -> double
        """
        return _gyoto_std.ThinDiskPL_PLSlope(self, *args)


    def PLRho(self, *args):
        """
        PLRho(ThinDiskPL self, double arg2)
        PLRho(ThinDiskPL self) -> double
        """
        return _gyoto_std.ThinDiskPL_PLRho(self, *args)


    def PLRadRef(self, *args):
        """
        PLRadRef(ThinDiskPL self, double arg2)
        PLRadRef(ThinDiskPL self) -> double
        """
        return _gyoto_std.ThinDiskPL_PLRadRef(self, *args)


    def emission(self, *args):
        """
        emission(ThinDiskPL self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(ThinDiskPL self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(ThinDiskPL self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.ThinDiskPL_emission(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::ThinDiskPL self) -> ThinDiskPL
        __init__(Gyoto::Astrobj::ThinDiskPL self, ThinDiskPL arg2) -> ThinDiskPL
        __init__(Gyoto::Astrobj::ThinDiskPL self, Astrobj base) -> ThinDiskPL



        Copy constructor. 
        """
        this = _gyoto_std.new_ThinDiskPL(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
ThinDiskPL_swigregister = _gyoto_std.ThinDiskPL_swigregister
ThinDiskPL_swigregister(ThinDiskPL)
ThinDiskPL.properties = _gyoto_std.cvar.ThinDiskPL_properties

class PolishDoughnut(StandardAstrobj):
    """


    A toroïdal accretion structure.

    Reference: Straub, O.; Vincent, F. H.; Abramowicz, M. A.; Gourgoulhon,
    E.; & Paumard, T. 2012, Modelling the black hole silhouette in
    Sagittarius A* with ion tori, A&A 543:83.

    C++ includes: GyotoPolishDoughnut.h 
    """

    __swig_setmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolishDoughnut, name, value)
    __swig_getmethods__ = {}
    for _s in [StandardAstrobj]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PolishDoughnut, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(PolishDoughnut self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.PolishDoughnut_getProperties(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(PolishDoughnut self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto_std.PolishDoughnut_fillProperty(self, fmp, p)


    def clone(self):
        """
        clone(PolishDoughnut self) -> PolishDoughnut



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto_std.PolishDoughnut_clone(self)

    __swig_destroy__ = _gyoto_std.delete_PolishDoughnut
    __del__ = lambda self: None

    def getL0(self):
        """
        getL0(PolishDoughnut self) -> double



        Get PolishDoughnut::l0_. 
        """
        return _gyoto_std.PolishDoughnut_getL0(self)


    def _lambda(self, *args):
        """
        _lambda(PolishDoughnut self) -> double
        _lambda(PolishDoughnut self, double arg2)



        Set PolishDoughnut::lambda_. 
        """
        return _gyoto_std.PolishDoughnut__lambda(self, *args)


    def centralDensity(self, *args):
        """
        centralDensity(PolishDoughnut self) -> double
        centralDensity(PolishDoughnut self, std::string const & unit) -> double
        centralDensity(PolishDoughnut self, double density)
        centralDensity(PolishDoughnut self, double density, std::string const & unit)



        Set PolishDoughnut::central_density_ in specified unit. 
        """
        return _gyoto_std.PolishDoughnut_centralDensity(self, *args)


    def centralTempOverVirial(self, *args):
        """
        centralTempOverVirial(PolishDoughnut self) -> double
        centralTempOverVirial(PolishDoughnut self, double val)



        Set PolishDoughnut::centraltemp_over_virial_. 
        """
        return _gyoto_std.PolishDoughnut_centralTempOverVirial(self, *args)


    def beta(self, *args):
        """
        beta(PolishDoughnut self) -> double
        beta(PolishDoughnut self, double beta)



        Set PolishDoughnut::beta_. 
        """
        return _gyoto_std.PolishDoughnut_beta(self, *args)


    def spectralOversampling(self, *args):
        """
        spectralOversampling(PolishDoughnut self, size_t arg2)
        spectralOversampling(PolishDoughnut self) -> size_t



        Get PolishDoughnut::spectral_oversampling_. 
        """
        return _gyoto_std.PolishDoughnut_spectralOversampling(self, *args)


    def changeCusp(self, *args):
        """
        changeCusp(PolishDoughnut self) -> bool
        changeCusp(PolishDoughnut self, bool t)



        Set PolishDoughnut::komissarov_. 
        """
        return _gyoto_std.PolishDoughnut_changeCusp(self, *args)


    def komissarov(self, *args):
        """
        komissarov(PolishDoughnut self) -> bool
        komissarov(PolishDoughnut self, bool komis)



        Set PolishDoughnut::komissarov_. 
        """
        return _gyoto_std.PolishDoughnut_komissarov(self, *args)


    def angleAveraged(self, *args):
        """
        angleAveraged(PolishDoughnut self) -> bool
        angleAveraged(PolishDoughnut self, bool komis)



        Set PolishDoughnut::angle_averaged_.

        if komis, also sets komissarov_ to true 
        """
        return _gyoto_std.PolishDoughnut_angleAveraged(self, *args)


    def nonThermalDeltaExpo(self, *args):
        """
        nonThermalDeltaExpo(PolishDoughnut self, vector_double v)
        nonThermalDeltaExpo(PolishDoughnut self) -> vector_double
        """
        return _gyoto_std.PolishDoughnut_nonThermalDeltaExpo(self, *args)


    def angmomrinner(self, *args):
        """
        angmomrinner(PolishDoughnut self, vector_double v)
        angmomrinner(PolishDoughnut self) -> vector_double
        """
        return _gyoto_std.PolishDoughnut_angmomrinner(self, *args)


    def adafparams(self, *args):
        """
        adafparams(PolishDoughnut self, vector_double v)
        adafparams(PolishDoughnut self) -> vector_double
        """
        return _gyoto_std.PolishDoughnut_adafparams(self, *args)


    def adaf(self, *args):
        """
        adaf(PolishDoughnut self, bool t)
        adaf(PolishDoughnut self) -> bool
        """
        return _gyoto_std.PolishDoughnut_adaf(self, *args)


    def setParameter(self, p, name, content, unit):
        """
        setParameter(PolishDoughnut self, Property p, std::string const & name, std::string const & content, std::string const & unit)



        Set parameter by name.

        This function is used when parsing an XML description, if no Property
        of this name is found. Overriding implementation should fall-back on
        calling the direct's parent implementation:

        Parameters:
        -----------

        name:  XML name of the parameter (XML entity). This may have a path
        component, e.g. "Astrobj::Radius", in which case a property named
        "Astrobj" will be sought in the current object, and setParameter
        will be called recusrively on this Astrobj with Radius as name.

        content:  string representation of the value

        unit:  string representation of the unit

        0 if this parameter is known, 1 if it is not. 
        """
        return _gyoto_std.PolishDoughnut_setParameter(self, p, name, content, unit)


    def getWsurface(self):
        """
        getWsurface(PolishDoughnut self) -> double



        Get PolishDoughnut::W_surface_. 
        """
        return _gyoto_std.PolishDoughnut_getWsurface(self)


    def getWcentre(self):
        """
        getWcentre(PolishDoughnut self) -> double



        Get PolishDoughnut::W_centre_. 
        """
        return _gyoto_std.PolishDoughnut_getWcentre(self)


    def getRcusp(self):
        """
        getRcusp(PolishDoughnut self) -> double



        Get PolishDoughnut::r_cusp_. 
        """
        return _gyoto_std.PolishDoughnut_getRcusp(self)


    def getRcentre(self):
        """
        getRcentre(PolishDoughnut self) -> double



        Get PolishDoughnut::r_centre_. 
        """
        return _gyoto_std.PolishDoughnut_getRcentre(self)


    def metric(self, *args):
        """
        metric(PolishDoughnut self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(PolishDoughnut self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)



        Get the Metric gg_. 
        """
        return _gyoto_std.PolishDoughnut_metric(self, *args)


    def Impact(self, ph, index, data):
        """
        Impact(PolishDoughnut self, Photon ph, size_t index, AstrobjProperties data) -> int



        Does a photon at these coordinates impact the object?

        Impact() checks whether a Photon impacts the object between two
        integration steps of the photon's trajectory (those two steps are
        photon->getCoord(index, coord1) and photon->getCoord(index+1,
        coord2)). Impact returns 1 if the photon impacts the object between
        these two steps, else 0. In many cases of geometrically thick obects,
        the implementation Astrobj::Standard::Impact() will be fine.

        Impact will call Generic::processHitQuantities() (which is virtual and
        may be re-implemented) to compute observable properties on demand: if
        the data pointer is non-NULL, the object will look in it for pointers
        to properties which apply to its kind. If a pointer to a property
        known to this object is present, then the property is computed and
        store at the pointed-to address. For instance, all objects know the
        "intensity" property. If data->intensity != NULL, the instensity is
        computed and stored in *data->intensity.

        If data is non-NULL and only in this case, processHitQuantities() will
        also call ph->transmit() to update the transmissions of the Photon
        (see Photon::transmit(size_t, double)). This must not be done if data
        is NULL (see Astrobj::Complex::Impact() for an explanation).

        Parameters:
        -----------

        ph:   Gyoto::Photon aimed at the object;

        index:  Index of the last photon step;

        data:  Pointer to a structure to hold the observables at impact.

        1 if impact, 0 if not. 
        """
        return _gyoto_std.PolishDoughnut_Impact(self, ph, index, data)


    def __call__(self, coord):
        """__call__(PolishDoughnut self, double const [4] coord) -> double"""
        return _gyoto_std.PolishDoughnut___call__(self, coord)


    def bessi0(xx):
        """bessi0(double xx) -> double"""
        return _gyoto_std.PolishDoughnut_bessi0(xx)

    if _newclass:
        bessi0 = staticmethod(bessi0)
    __swig_getmethods__["bessi0"] = lambda x: bessi0

    def bessi1(xx):
        """bessi1(double xx) -> double"""
        return _gyoto_std.PolishDoughnut_bessi1(xx)

    if _newclass:
        bessi1 = staticmethod(bessi1)
    __swig_getmethods__["bessi1"] = lambda x: bessi1

    def bessk0(xx):
        """bessk0(double xx) -> double"""
        return _gyoto_std.PolishDoughnut_bessk0(xx)

    if _newclass:
        bessk0 = staticmethod(bessk0)
    __swig_getmethods__["bessk0"] = lambda x: bessk0

    def bessk1(xx):
        """bessk1(double xx) -> double"""
        return _gyoto_std.PolishDoughnut_bessk1(xx)

    if _newclass:
        bessk1 = staticmethod(bessk1)
    __swig_getmethods__["bessk1"] = lambda x: bessk1

    def bessk(nn, xx):
        """bessk(int nn, double xx) -> double"""
        return _gyoto_std.PolishDoughnut_bessk(nn, xx)

    if _newclass:
        bessk = staticmethod(bessk)
    __swig_getmethods__["bessk"] = lambda x: bessk

    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::PolishDoughnut self) -> PolishDoughnut
        __init__(Gyoto::Astrobj::PolishDoughnut self, PolishDoughnut arg2) -> PolishDoughnut
        __init__(Gyoto::Astrobj::PolishDoughnut self, Astrobj base) -> PolishDoughnut



        Copy constructor. 
        """
        this = _gyoto_std.new_PolishDoughnut(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
PolishDoughnut_swigregister = _gyoto_std.PolishDoughnut_swigregister
PolishDoughnut_swigregister(PolishDoughnut)
PolishDoughnut.properties = _gyoto_std.cvar.PolishDoughnut_properties

def PolishDoughnut_bessi0(xx):
    """PolishDoughnut_bessi0(double xx) -> double"""
    return _gyoto_std.PolishDoughnut_bessi0(xx)

def PolishDoughnut_bessi1(xx):
    """PolishDoughnut_bessi1(double xx) -> double"""
    return _gyoto_std.PolishDoughnut_bessi1(xx)

def PolishDoughnut_bessk0(xx):
    """PolishDoughnut_bessk0(double xx) -> double"""
    return _gyoto_std.PolishDoughnut_bessk0(xx)

def PolishDoughnut_bessk1(xx):
    """PolishDoughnut_bessk1(double xx) -> double"""
    return _gyoto_std.PolishDoughnut_bessk1(xx)

def PolishDoughnut_bessk(nn, xx):
    """PolishDoughnut_bessk(int nn, double xx) -> double"""
    return _gyoto_std.PolishDoughnut_bessk(nn, xx)

class ThinDiskIronLine(gyoto.ThinDisk):
    """Proxy of C++ Gyoto::Astrobj::ThinDiskIronLine class."""

    __swig_setmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThinDiskIronLine, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThinDiskIronLine, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(ThinDiskIronLine self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.ThinDiskIronLine_getProperties(self)

    __swig_destroy__ = _gyoto_std.delete_ThinDiskIronLine
    __del__ = lambda self: None

    def clone(self):
        """
        clone(ThinDiskIronLine self) -> ThinDiskIronLine



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto_std.ThinDiskIronLine_clone(self)


    def emission(self, *args):
        """
        emission(ThinDiskIronLine self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(ThinDiskIronLine self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(ThinDiskIronLine self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.ThinDiskIronLine_emission(self, *args)


    def getVelocity(self, pos, vel):
        """
        getVelocity(ThinDiskIronLine self, double const [4] pos, double [4] vel)



        Get fluid 4-velocity at point.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.
        getVelocity() should work at some distance from the equatorial plane.
        The default implementation calls Metric::Generic::circularVelocity().

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto_std.ThinDiskIronLine_getVelocity(self, pos, vel)


    def PowerLawIndex(self, *args):
        """
        PowerLawIndex(ThinDiskIronLine self, double arg2)
        PowerLawIndex(ThinDiskIronLine self) -> double
        """
        return _gyoto_std.ThinDiskIronLine_PowerLawIndex(self, *args)


    def LineFreq(self, *args):
        """
        LineFreq(ThinDiskIronLine self, double arg2)
        LineFreq(ThinDiskIronLine self) -> double
        LineFreq(ThinDiskIronLine self, double v, std::string const & u)
        LineFreq(ThinDiskIronLine self, std::string const & u) -> double
        """
        return _gyoto_std.ThinDiskIronLine_LineFreq(self, *args)


    def CutRadius(self, *args):
        """
        CutRadius(ThinDiskIronLine self, double arg2)
        CutRadius(ThinDiskIronLine self) -> double
        CutRadius(ThinDiskIronLine self, double v, std::string const & u)
        CutRadius(ThinDiskIronLine self, std::string const & u) -> double
        """
        return _gyoto_std.ThinDiskIronLine_CutRadius(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::ThinDiskIronLine self) -> ThinDiskIronLine
        __init__(Gyoto::Astrobj::ThinDiskIronLine self, ThinDiskIronLine o) -> ThinDiskIronLine
        __init__(Gyoto::Astrobj::ThinDiskIronLine self, Astrobj base) -> ThinDiskIronLine
        """
        this = _gyoto_std.new_ThinDiskIronLine(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
ThinDiskIronLine_swigregister = _gyoto_std.ThinDiskIronLine_swigregister
ThinDiskIronLine_swigregister(ThinDiskIronLine)
ThinDiskIronLine.properties = _gyoto_std.cvar.ThinDiskIronLine_properties

class PatternDisk(gyoto.ThinDisk):
    """


    Geometrically thin disk read from FITS file.

    This class describes a disk contained in the z=0 (equatorial) plane,
    extending from r=r_ISCO to r=infinity. The flux emitted at radius r
    and longitude phi at frequency nu is given in a FITS file.

    C++ includes: GyotoPatternDisk.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PatternDisk, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PatternDisk, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(PatternDisk self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.PatternDisk_getProperties(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(PatternDisk self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto_std.PatternDisk_fillProperty(self, fmp, p)


    def clone(self):
        """
        clone(PatternDisk self) -> PatternDisk



        Cloner. 
        """
        return _gyoto_std.PatternDisk_clone(self)

    __swig_destroy__ = _gyoto_std.delete_PatternDisk
    __del__ = lambda self: None

    def innerRadius(self, *args):
        """
        innerRadius(PatternDisk self) -> double
        innerRadius(PatternDisk self, std::string const & arg2) -> double
        innerRadius(PatternDisk self, double arg2, std::string const & arg3)
        innerRadius(PatternDisk self, double arg2)



        Set rin_. 
        """
        return _gyoto_std.PatternDisk_innerRadius(self, *args)


    def outerRadius(self, *args):
        """
        outerRadius(PatternDisk self) -> double
        outerRadius(PatternDisk self, std::string const & arg2) -> double
        outerRadius(PatternDisk self, double arg2, std::string const & arg3)
        outerRadius(PatternDisk self, double arg2)



        Set rout_. 
        """
        return _gyoto_std.PatternDisk_outerRadius(self, *args)


    def patternVelocity(self, *args):
        """
        patternVelocity(PatternDisk self, double arg2)
        patternVelocity(PatternDisk self) -> double



        Get PatternDisk::Omega_. 
        """
        return _gyoto_std.PatternDisk_patternVelocity(self, *args)


    def file(self, *args):
        """
        file(PatternDisk self, std::string const & f)
        file(PatternDisk self) -> std::string
        """
        return _gyoto_std.PatternDisk_file(self, *args)


    def fitsRead(self, filename_):
        """fitsRead(PatternDisk self, std::string filename_)"""
        return _gyoto_std.PatternDisk_fitsRead(self, filename_)


    def fitsWrite(self, filename_):
        """fitsWrite(PatternDisk self, std::string filename_)"""
        return _gyoto_std.PatternDisk_fitsWrite(self, filename_)


    def setEmission(self, pattern):
        """
        setEmission(PatternDisk self, double * pattern)



        Set PatternDisk::emission_.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.PatternDisk_setEmission(self, pattern)


    def setVelocity(self, pattern):
        """
        setVelocity(PatternDisk self, double * pattern)



        Set PatternDisk::velocity__.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.PatternDisk_setVelocity(self, pattern)


    def radius(self, pattern):
        """
        radius(PatternDisk self, double * pattern)



        Set PatternDisk::radius_.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.PatternDisk_radius(self, pattern)


    def copyIntensity(self, pattern=None, naxes=0):
        """
        copyIntensity(PatternDisk self, double const *const pattern=None, size_t const [3] naxes=0)
        copyIntensity(PatternDisk self, double const *const pattern=None)
        copyIntensity(PatternDisk self)



        Set PatternDisk::emission_.

        PatternDisk::emission_ is freed if not NULL, reallocated, and pattern
        is copied into emission_.

        If PatternDisk::opacity_, PatternDisk::velocity_ or
        PatternDisk::radius_ have been set previously with mismatching sizes,
        they are deallocated too.

        Finally, PatternDisk::nnu_, PatternDisk::nphi_, and PatternDisk::nr_
        are set according to naxes.

        Parameters:
        -----------

        pattern:  Array to copy as emission_. May be NULL in which case
        emission_ is simply deallocated and set to NULL.

        naxes:  { nnu_, nphi_, nr_ }. 
        """
        return _gyoto_std.PatternDisk_copyIntensity(self, pattern, naxes)


    def getIntensity(self):
        """
        getIntensity(PatternDisk self) -> double const *



        Get PatternDisk::emission_. 
        """
        return _gyoto_std.PatternDisk_getIntensity(self)


    def getIntensityNaxes(self, naxes):
        """
        getIntensityNaxes(PatternDisk self, size_t [3] naxes)



        Get PatternDisk::nnu_, PatternDisk::nphi_, and PatternDisk::nr_. 
        """
        return _gyoto_std.PatternDisk_getIntensityNaxes(self, naxes)


    def copyOpacity(self, pattern=None, naxes=0):
        """
        copyOpacity(PatternDisk self, double const *const pattern=None, size_t const [3] naxes=0)
        copyOpacity(PatternDisk self, double const *const pattern=None)
        copyOpacity(PatternDisk self)



        Set PatternDisk::opacity_.

        PatternDisk::opacity_ is first freed if not NULL and set to NULL.

        If pattern is not NULL, PatternDisk::emission_ must have been set
        previously with matching dimensions. PatternDisk::opacity_ is then
        reallocated, and pattern is copied into opacity_.

        Parameters:
        -----------

        pattern:  Array to copy as opacity_. May be NULL in which case
        opacity_ is simply deallocated and set to NULL.

        naxes:  { nnu_, nphi_, nr_ }. 
        """
        return _gyoto_std.PatternDisk_copyOpacity(self, pattern, naxes)


    def opacity(self):
        """
        opacity(PatternDisk self) -> double const *



        Get PatternDisk::opacity_. 
        """
        return _gyoto_std.PatternDisk_opacity(self)


    def copyVelocity(self, pattern=None, naxes=0):
        """
        copyVelocity(PatternDisk self, double const *const pattern=None, size_t const [2] naxes=0)
        copyVelocity(PatternDisk self, double const *const pattern=None)
        copyVelocity(PatternDisk self)



        Set PatternDisk::velocity_.

        PatternDisk::velocity_ is first freed if not NULL and set to NULL.

        If pattern is not NULL, PatternDisk::emission_ must have been set
        previously with matching dimensions. PatternDisk::velocity_ is then
        reallocated, and pattern is copied into velocity_.

        Parameters:
        -----------

        pattern:  Array to copy as velocity_. May be NULL in which case
        velocity_ is simply deallocated and set to NULL.

        naxes:  { nphi_, nr_ }. 
        """
        return _gyoto_std.PatternDisk_copyVelocity(self, pattern, naxes)


    def copyGridRadius(self, pattern=None, nr=0):
        """
        copyGridRadius(PatternDisk self, double const *const pattern=None, size_t nr=0)
        copyGridRadius(PatternDisk self, double const *const pattern=None)
        copyGridRadius(PatternDisk self)



        Set PatternDisk::radius_.

        PatternDisk::radius_ is first freed if not NULL and set to NULL.

        If pattern is not NULL, PatternDisk::emission_ must have been set
        previously with matching dimensions. PatternDisk::radius_ is then
        reallocated, and pattern is copied into radius_.

        Parameters:
        -----------

        pattern:  Array to copy as radius_. May be NULL in which case radius_
        is simply deallocated and set to NULL.

        nr:  size of radius array. 
        """
        return _gyoto_std.PatternDisk_copyGridRadius(self, pattern, nr)


    def getGridRadius(self):
        """
        getGridRadius(PatternDisk self) -> double const *



        Get PatternDisk::radius_. 
        """
        return _gyoto_std.PatternDisk_getGridRadius(self)


    def repeatPhi(self, *args):
        """
        repeatPhi(PatternDisk self, size_t n)
        repeatPhi(PatternDisk self) -> size_t



        Get PatternDisk::repeat_phi_. 
        """
        return _gyoto_std.PatternDisk_repeatPhi(self, *args)


    def nu0(self, *args):
        """
        nu0(PatternDisk self, double freq)
        nu0(PatternDisk self) -> double



        Get PatternDisk::nu0_. 
        """
        return _gyoto_std.PatternDisk_nu0(self, *args)


    def dnu(self, *args):
        """
        dnu(PatternDisk self, double dfreq)
        dnu(PatternDisk self) -> double



        Get PatternDisk::dnu_. 
        """
        return _gyoto_std.PatternDisk_dnu(self, *args)


    def phimin(self, *args):
        """
        phimin(PatternDisk self, double phimin)
        phimin(PatternDisk self) -> double



        Get PatternDisk::phimin_. 
        """
        return _gyoto_std.PatternDisk_phimin(self, *args)


    def phimax(self, *args):
        """
        phimax(PatternDisk self, double phimax)
        phimax(PatternDisk self) -> double



        Get PatternDisk::phimax_. 
        """
        return _gyoto_std.PatternDisk_phimax(self, *args)


    def emission(self, *args):
        """
        emission(PatternDisk self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(PatternDisk self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(PatternDisk self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.PatternDisk_emission(self, *args)


    def transmission(self, nu_em, dsem, coord):
        """
        transmission(PatternDisk self, double nu_em, double dsem, double [8] coord) -> double



        Transmission: exp( * dsem )

        transmission() computes the transmission of this fluid element or 0 if
        optically thick. The default implementation returns 1. (no
        attenuation) if optically thin, 0. if optically thick.

        Parameters:
        -----------

        nuem:  frequency in the fluid's frame

        coord:   Photon coordinate

        dsem:  geometrical length in geometrical units 
        """
        return _gyoto_std.PatternDisk_transmission(self, nu_em, dsem, coord)


    def getVelocity(self, *args):
        """
        getVelocity(PatternDisk self) -> double const
        getVelocity(PatternDisk self, double const [4] pos, double [4] vel)



        Get fluid 4-velocity at point.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.
        getVelocity() should work at some distance from the equatorial plane.
        The default implementation calls Metric::Generic::circularVelocity().

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto_std.PatternDisk_getVelocity(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::PatternDisk self) -> PatternDisk
        __init__(Gyoto::Astrobj::PatternDisk self, PatternDisk arg2) -> PatternDisk
        __init__(Gyoto::Astrobj::PatternDisk self, Astrobj base) -> PatternDisk



        Copy constructor. 
        """
        this = _gyoto_std.new_PatternDisk(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
PatternDisk_swigregister = _gyoto_std.PatternDisk_swigregister
PatternDisk_swigregister(PatternDisk)
PatternDisk.properties = _gyoto_std.cvar.PatternDisk_properties

class PatternDiskBB(PatternDisk):
    """


    Geometrically thin disk read from FITS file with black body spectrum.

    This class describes a disk contained in the z=0 (equatorial) plane,
    extending from r=r_ISCO to r=rmax_. The flux emitted at radius r and
    longitude phi at frequency nu is given in a FITS file.

    C++ includes: GyotoPatternDiskBB.h 
    """

    __swig_setmethods__ = {}
    for _s in [PatternDisk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PatternDiskBB, name, value)
    __swig_getmethods__ = {}
    for _s in [PatternDisk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PatternDiskBB, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(PatternDiskBB self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.PatternDiskBB_getProperties(self)


    def clone(self):
        """
        clone(PatternDiskBB self) -> PatternDiskBB



        Cloner. 
        """
        return _gyoto_std.PatternDiskBB_clone(self)

    __swig_destroy__ = _gyoto_std.delete_PatternDiskBB
    __del__ = lambda self: None

    def spectralEmission(self, *args):
        """
        spectralEmission(PatternDiskBB self) -> bool
        spectralEmission(PatternDiskBB self, bool t)
        """
        return _gyoto_std.PatternDiskBB_spectralEmission(self, *args)


    def risco(self, *args):
        """
        risco(PatternDiskBB self) -> double
        risco(PatternDiskBB self, double r)
        """
        return _gyoto_std.PatternDiskBB_risco(self, *args)


    def emission(self, *args):
        """
        emission(PatternDiskBB self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(PatternDiskBB self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(PatternDiskBB self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.PatternDiskBB_emission(self, *args)


    def getVelocity(self, *args):
        """
        getVelocity(PatternDiskBB self) -> double const
        getVelocity(PatternDiskBB self, double const [4] pos, double [4] vel)



        Get fluid 4-velocity at point.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.
        getVelocity() should work at some distance from the equatorial plane.
        The default implementation calls Metric::Generic::circularVelocity().

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto_std.PatternDiskBB_getVelocity(self, *args)


    def metric(self, *args):
        """
        metric(PatternDiskBB self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(PatternDiskBB self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(PatternDiskBB self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg)



        Get the Metric gg_. 
        """
        return _gyoto_std.PatternDiskBB_metric(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::PatternDiskBB self) -> PatternDiskBB
        __init__(Gyoto::Astrobj::PatternDiskBB self, PatternDiskBB arg2) -> PatternDiskBB
        __init__(Gyoto::Astrobj::PatternDiskBB self, Astrobj base) -> PatternDiskBB



        Copy constructor. 
        """
        this = _gyoto_std.new_PatternDiskBB(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
PatternDiskBB_swigregister = _gyoto_std.PatternDiskBB_swigregister
PatternDiskBB_swigregister(PatternDiskBB)
PatternDiskBB.properties = _gyoto_std.cvar.PatternDiskBB_properties

class DynamicalDisk(PatternDiskBB):
    """


    Geometrically thin disk read from a set of FITS files.

    This class describes a PatternDiskBB that evolves dynamically. It is
    described by a set of FITS files.

    C++ includes: GyotoDynamicalDisk.h 
    """

    __swig_setmethods__ = {}
    for _s in [PatternDiskBB]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicalDisk, name, value)
    __swig_getmethods__ = {}
    for _s in [PatternDiskBB]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicalDisk, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(DynamicalDisk self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.DynamicalDisk_getProperties(self)


    def clone(self):
        """
        clone(DynamicalDisk self) -> DynamicalDisk



        Cloner. 
        """
        return _gyoto_std.DynamicalDisk_clone(self)

    __swig_destroy__ = _gyoto_std.delete_DynamicalDisk
    __del__ = lambda self: None

    def file(self, *args):
        """
        file(DynamicalDisk self) -> std::string
        file(DynamicalDisk self, std::string const & fname)
        """
        return _gyoto_std.DynamicalDisk_file(self, *args)


    def tinit(self, *args):
        """
        tinit(DynamicalDisk self, double t)
        tinit(DynamicalDisk self) -> double
        """
        return _gyoto_std.DynamicalDisk_tinit(self, *args)


    def dt(self, *args):
        """
        dt(DynamicalDisk self, double t)
        dt(DynamicalDisk self) -> double
        """
        return _gyoto_std.DynamicalDisk_dt(self, *args)


    def emission(self, *args):
        """
        emission(DynamicalDisk self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(DynamicalDisk self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(DynamicalDisk self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.DynamicalDisk_emission(self, *args)


    def getVelocity(self, *args):
        """
        getVelocity(DynamicalDisk self, double const [4] pos, double [4] vel)
        getVelocity(DynamicalDisk self) -> double const *



        Get PatternDisk::velocity_. 
        """
        return _gyoto_std.DynamicalDisk_getVelocity(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::DynamicalDisk self) -> DynamicalDisk
        __init__(Gyoto::Astrobj::DynamicalDisk self, DynamicalDisk arg2) -> DynamicalDisk
        __init__(Gyoto::Astrobj::DynamicalDisk self, Astrobj base) -> DynamicalDisk



        Copy constructor. 
        """
        this = _gyoto_std.new_DynamicalDisk(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
DynamicalDisk_swigregister = _gyoto_std.DynamicalDisk_swigregister
DynamicalDisk_swigregister(DynamicalDisk)
DynamicalDisk.properties = _gyoto_std.cvar.DynamicalDisk_properties

class Disk3D(gyoto.Astrobj):
    """


    Geometrically thick disk read from FITS file.

    This class is the base class for thick disks. The emitter's velocity
    is given in a FITS file, together with emission related quantity
    (typically temperature). This class mainly implements the Impact()
    function. Emission() function is here left to its default, and should
    be implemented according to specific needs in heir classes. Here the
    disk is supposed not to evolve in time. The dynamical treatment is
    provided in heir classes.

    The 3D disk is assumed to be described by a regular (non adaptive)
    grid of cylindrical geometry. The disk is a slab from rin_ to rout_
    and zmin_ (typically = -zmax_) to zmax_.

    C++ includes: GyotoDisk3D.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Astrobj]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Disk3D, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Astrobj]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Disk3D, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(Disk3D self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.Disk3D_getProperties(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(Disk3D self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto_std.Disk3D_fillProperty(self, fmp, p)


    def clone(self):
        """
        clone(Disk3D self) -> Disk3D



        Cloner. 
        """
        return _gyoto_std.Disk3D_clone(self)

    __swig_destroy__ = _gyoto_std.delete_Disk3D
    __del__ = lambda self: None

    def fitsRead(self, filename_):
        """fitsRead(Disk3D self, std::string filename_)"""
        return _gyoto_std.Disk3D_fitsRead(self, filename_)


    def fitsWrite(self, filename_):
        """fitsWrite(Disk3D self, std::string filename_)"""
        return _gyoto_std.Disk3D_fitsWrite(self, filename_)


    def file(self, *args):
        """
        file(Disk3D self, std::string const & f)
        file(Disk3D self) -> std::string
        """
        return _gyoto_std.Disk3D_file(self, *args)


    def zsym(self, *args):
        """
        zsym(Disk3D self, bool t)
        zsym(Disk3D self) -> bool
        """
        return _gyoto_std.Disk3D_zsym(self, *args)


    def tPattern(self, *args):
        """
        tPattern(Disk3D self, double t)
        tPattern(Disk3D self) -> double
        """
        return _gyoto_std.Disk3D_tPattern(self, *args)


    def omegaPattern(self, *args):
        """
        omegaPattern(Disk3D self, double t)
        omegaPattern(Disk3D self) -> double
        """
        return _gyoto_std.Disk3D_omegaPattern(self, *args)


    def setEmissquant(self, pattern):
        """
        setEmissquant(Disk3D self, double * pattern)



        Set Disk3D::emissquant_.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.Disk3D_setEmissquant(self, pattern)


    def setVelocity(self, pattern):
        """
        setVelocity(Disk3D self, double * pattern)



        Set Disk3D::velocity__.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.Disk3D_setVelocity(self, pattern)


    def copyEmissquant(self, pattern=None, naxes=0):
        """
        copyEmissquant(Disk3D self, double const *const pattern=None, size_t const [4] naxes=0)
        copyEmissquant(Disk3D self, double const *const pattern=None)
        copyEmissquant(Disk3D self)



        Set Disk3D::emissquant_.

        Disk3D::emissquant_ is freed if not NULL, reallocated, and pattern is
        copied into emission_.

        If Disk3D::velocity_ or has been set previously with mismatching
        sizes, it is deallocated too.

        Finally, Disk3D::nnu_, Disk3D::nphi_, Disk3D::nz_ and Disk3D::nr_ are
        set according to naxes.

        Parameters:
        -----------

        pattern:  Array to copy as emission_. May be NULL in which case
        emission_ is simply deallocated and set to NULL.

        naxes:  { nnu_, nphi_, nz_, nr_ }. 
        """
        return _gyoto_std.Disk3D_copyEmissquant(self, pattern, naxes)


    def getEmissquant(self):
        """
        getEmissquant(Disk3D self) -> double const *



        Get Disk3D::emissquant_. 
        """
        return _gyoto_std.Disk3D_getEmissquant(self)


    def getEmissquantNaxes(self, naxes):
        """
        getEmissquantNaxes(Disk3D self, size_t [4] naxes)



        Get { Disk3D::nnu_, Disk3D::nphi_, Disk3D::nz_, Disk3D::nr_ }. 
        """
        return _gyoto_std.Disk3D_getEmissquantNaxes(self, naxes)


    def copyOpacity(self, pattern=None, naxes=0):
        """
        copyOpacity(Disk3D self, double const *const pattern=None, size_t const [4] naxes=0)
        copyOpacity(Disk3D self, double const *const pattern=None)
        copyOpacity(Disk3D self)
        """
        return _gyoto_std.Disk3D_copyOpacity(self, pattern, naxes)


    def opacity(self, *args):
        """
        opacity(Disk3D self, double * pattern)
        opacity(Disk3D self) -> double const *



        Get Disk3D::opacity_. 
        """
        return _gyoto_std.Disk3D_opacity(self, *args)


    def copyVelocity(self, pattern=None, naxes=0):
        """
        copyVelocity(Disk3D self, double const *const pattern=None, size_t const [3] naxes=0)
        copyVelocity(Disk3D self, double const *const pattern=None)
        copyVelocity(Disk3D self)



        Set Disk3D::velocity_.

        Disk3D::velocity_ is first freed if not NULL and set to NULL.

        If pattern is not NULL, Disk3D::emissquant_ must have been set
        previously with matching dimensions. Disk3D::velocity_ is then
        reallocated, and pattern is copied into velocity_.

        Parameters:
        -----------

        pattern:  Array to copy as velocity_. May be NULL in which case
        velocity_ is simply deallocated and set to NULL.

        naxes:  { nphi_, nz_, nr_ }. 
        """
        return _gyoto_std.Disk3D_copyVelocity(self, pattern, naxes)


    def repeatPhi(self, *args):
        """
        repeatPhi(Disk3D self, size_t n)
        repeatPhi(Disk3D self) -> size_t



        Get Disk3D::repeat_phi_. 
        """
        return _gyoto_std.Disk3D_repeatPhi(self, *args)


    def nu0(self, *args):
        """
        nu0(Disk3D self, double freq)
        nu0(Disk3D self) -> double



        Get Disk3D::nu0_. 
        """
        return _gyoto_std.Disk3D_nu0(self, *args)


    def dnu(self, *args):
        """
        dnu(Disk3D self, double dfreq)
        dnu(Disk3D self) -> double



        Get Disk3D::dnu_. 
        """
        return _gyoto_std.Disk3D_dnu(self, *args)


    def rin(self, *args):
        """
        rin(Disk3D self, double rrin)
        rin(Disk3D self) -> double



        Get Disk3D::rin_. 
        """
        return _gyoto_std.Disk3D_rin(self, *args)


    def rout(self, *args):
        """
        rout(Disk3D self, double rout)
        rout(Disk3D self) -> double



        Get Disk3D::rout_. 
        """
        return _gyoto_std.Disk3D_rout(self, *args)


    def zmin(self, *args):
        """
        zmin(Disk3D self, double zmin)
        zmin(Disk3D self) -> double



        Get Disk3D::zmin_. 
        """
        return _gyoto_std.Disk3D_zmin(self, *args)


    def zmax(self, *args):
        """
        zmax(Disk3D self, double zmax)
        zmax(Disk3D self) -> double



        Get Disk3D::zmax_. 
        """
        return _gyoto_std.Disk3D_zmax(self, *args)


    def phimin(self, *args):
        """
        phimin(Disk3D self, double phimin)
        phimin(Disk3D self) -> double



        Get Disk3D::phimin_. 
        """
        return _gyoto_std.Disk3D_phimin(self, *args)


    def phimax(self, *args):
        """
        phimax(Disk3D self, double phimax)
        phimax(Disk3D self) -> double



        Get Disk3D::phimax_. 
        """
        return _gyoto_std.Disk3D_phimax(self, *args)


    def Impact(self, ph, index, data):
        """
        Impact(Disk3D self, Photon ph, size_t index, AstrobjProperties data) -> int



        Does a photon at these coordinates impact the object?

        Impact() checks whether a Photon impacts the object between two
        integration steps of the photon's trajectory (those two steps are
        photon->getCoord(index, coord1) and photon->getCoord(index+1,
        coord2)). Impact returns 1 if the photon impacts the object between
        these two steps, else 0. In many cases of geometrically thick obects,
        the implementation Astrobj::Standard::Impact() will be fine.

        Impact will call Generic::processHitQuantities() (which is virtual and
        may be re-implemented) to compute observable properties on demand: if
        the data pointer is non-NULL, the object will look in it for pointers
        to properties which apply to its kind. If a pointer to a property
        known to this object is present, then the property is computed and
        store at the pointed-to address. For instance, all objects know the
        "intensity" property. If data->intensity != NULL, the instensity is
        computed and stored in *data->intensity.

        If data is non-NULL and only in this case, processHitQuantities() will
        also call ph->transmit() to update the transmissions of the Photon
        (see Photon::transmit(size_t, double)). This must not be done if data
        is NULL (see Astrobj::Complex::Impact() for an explanation).

        Parameters:
        -----------

        ph:   Gyoto::Photon aimed at the object;

        index:  Index of the last photon step;

        data:  Pointer to a structure to hold the observables at impact.

        1 if impact, 0 if not. 
        """
        return _gyoto_std.Disk3D_Impact(self, ph, index, data)


    def getVelocity(self, *args):
        """
        getVelocity(Disk3D self) -> double const
        getVelocity(Disk3D self, double const [4] pos, double [4] vel)



        Get fluid 4-velocity at point.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto_std.Disk3D_getVelocity(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::Disk3D self) -> Disk3D
        __init__(Gyoto::Astrobj::Disk3D self, Disk3D arg2) -> Disk3D
        __init__(Gyoto::Astrobj::Disk3D self, Astrobj base) -> Disk3D



        Copy constructor. 
        """
        this = _gyoto_std.new_Disk3D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Disk3D_swigregister = _gyoto_std.Disk3D_swigregister
Disk3D_swigregister(Disk3D)
Disk3D.properties = _gyoto_std.cvar.Disk3D_properties

class DynamicalDisk3D(Disk3D):
    """


    Geometrically thick optically thin disk read from a set of FITS files.

    This class describes a PatternDiskBB that evolves dynamically. It is
    described by a set of FITS files for different times. Its emission is
    blackbody.

    The disk is assumed to be described by a regular, constant in time,
    grid.

    The metric must be Kerr in BL coordinates.

    C++ includes: GyotoDynamicalDisk3D.h 
    """

    __swig_setmethods__ = {}
    for _s in [Disk3D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicalDisk3D, name, value)
    __swig_getmethods__ = {}
    for _s in [Disk3D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicalDisk3D, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(DynamicalDisk3D self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.DynamicalDisk3D_getProperties(self)


    def clone(self):
        """
        clone(DynamicalDisk3D self) -> DynamicalDisk3D



        Cloner. 
        """
        return _gyoto_std.DynamicalDisk3D_clone(self)

    __swig_destroy__ = _gyoto_std.delete_DynamicalDisk3D
    __del__ = lambda self: None

    def metric(self, *args):
        """
        metric(DynamicalDisk3D self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(DynamicalDisk3D self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(DynamicalDisk3D self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg)



        Get the Metric gg_. 
        """
        return _gyoto_std.DynamicalDisk3D_metric(self, *args)


    def file(self, *args):
        """
        file(DynamicalDisk3D self, std::string const & f)
        file(DynamicalDisk3D self) -> std::string
        """
        return _gyoto_std.DynamicalDisk3D_file(self, *args)


    def tinit(self, *args):
        """
        tinit(DynamicalDisk3D self, double t)
        tinit(DynamicalDisk3D self) -> double
        """
        return _gyoto_std.DynamicalDisk3D_tinit(self, *args)


    def dt(self, *args):
        """
        dt(DynamicalDisk3D self, double t)
        dt(DynamicalDisk3D self) -> double
        """
        return _gyoto_std.DynamicalDisk3D_dt(self, *args)


    def PLindex(self, *args):
        """
        PLindex(DynamicalDisk3D self, double t)
        PLindex(DynamicalDisk3D self) -> double
        """
        return _gyoto_std.DynamicalDisk3D_PLindex(self, *args)


    def floorTemperature(self, *args):
        """
        floorTemperature(DynamicalDisk3D self, double t)
        floorTemperature(DynamicalDisk3D self) -> double
        """
        return _gyoto_std.DynamicalDisk3D_floorTemperature(self, *args)


    def temperature(self, *args):
        """
        temperature(DynamicalDisk3D self, bool t)
        temperature(DynamicalDisk3D self) -> bool
        """
        return _gyoto_std.DynamicalDisk3D_temperature(self, *args)


    def withVelocity(self, *args):
        """
        withVelocity(DynamicalDisk3D self, bool t)
        withVelocity(DynamicalDisk3D self) -> bool
        """
        return _gyoto_std.DynamicalDisk3D_withVelocity(self, *args)


    def emission1date(self, nu_em, dsem, c_ph, c_obj):
        """
        emission1date(DynamicalDisk3D self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj) -> double



        Compute emission at one grid date. 
        """
        return _gyoto_std.DynamicalDisk3D_emission1date(self, nu_em, dsem, c_ph, c_obj)


    def emission(self, *args):
        """
        emission(DynamicalDisk3D self, double [] Inu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph, double [8] coord_obj=0)
        emission(DynamicalDisk3D self, double [] Inu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph)
        emission(DynamicalDisk3D self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(DynamicalDisk3D self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.DynamicalDisk3D_emission(self, *args)


    def transmission1date(self, nu_em, dsem, c_ph, c_obj):
        """
        transmission1date(DynamicalDisk3D self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj) -> double



        Compute transmission at one grid date. 
        """
        return _gyoto_std.DynamicalDisk3D_transmission1date(self, nu_em, dsem, c_ph, c_obj)


    def transmission(self, nu_em, dsem, c_obj):
        """
        transmission(DynamicalDisk3D self, double nu_em, double dsem, double [8] c_obj) -> double



        Interpolate transmission between grid dates. 
        """
        return _gyoto_std.DynamicalDisk3D_transmission(self, nu_em, dsem, c_obj)


    def getVelocity(self, *args):
        """
        getVelocity(DynamicalDisk3D self, double const [4] pos, double [4] vel)
        getVelocity(DynamicalDisk3D self) -> double const *



        Get Disk3D::velocity_. 
        """
        return _gyoto_std.DynamicalDisk3D_getVelocity(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::DynamicalDisk3D self) -> DynamicalDisk3D
        __init__(Gyoto::Astrobj::DynamicalDisk3D self, DynamicalDisk3D arg2) -> DynamicalDisk3D
        __init__(Gyoto::Astrobj::DynamicalDisk3D self, Astrobj base) -> DynamicalDisk3D



        Copy constructor. 
        """
        this = _gyoto_std.new_DynamicalDisk3D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
DynamicalDisk3D_swigregister = _gyoto_std.DynamicalDisk3D_swigregister
DynamicalDisk3D_swigregister(DynamicalDisk3D)
DynamicalDisk3D.properties = _gyoto_std.cvar.DynamicalDisk3D_properties

class DirectionalDisk(gyoto.ThinDisk):
    """


    Geometrically thin disk read from FITS file.

    This class describes a disk contained in the z=0 (equatorial) plane.
    The flux emitted at radius r, making an angle i with respect to the
    local normal, at frequency nu is given in a FITS file.

    C++ includes: GyotoDirectionalDisk.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirectionalDisk, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.ThinDisk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DirectionalDisk, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(DirectionalDisk self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.DirectionalDisk_getProperties(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(DirectionalDisk self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto_std.DirectionalDisk_fillProperty(self, fmp, p)


    def clone(self):
        """
        clone(DirectionalDisk self) -> DirectionalDisk



        Cloner. 
        """
        return _gyoto_std.DirectionalDisk_clone(self)

    __swig_destroy__ = _gyoto_std.delete_DirectionalDisk
    __del__ = lambda self: None

    def file(self, *args):
        """
        file(DirectionalDisk self, std::string const & f)
        file(DirectionalDisk self) -> std::string
        """
        return _gyoto_std.DirectionalDisk_file(self, *args)


    def averageOverAngle(self, *args):
        """
        averageOverAngle(DirectionalDisk self, bool t)
        averageOverAngle(DirectionalDisk self) -> bool
        """
        return _gyoto_std.DirectionalDisk_averageOverAngle(self, *args)


    def fitsRead(self, filename_):
        """fitsRead(DirectionalDisk self, std::string filename_)"""
        return _gyoto_std.DirectionalDisk_fitsRead(self, filename_)


    def fitsWrite(self, filename_):
        """fitsWrite(DirectionalDisk self, std::string filename_)"""
        return _gyoto_std.DirectionalDisk_fitsWrite(self, filename_)


    def setEmission(self, pattern):
        """
        setEmission(DirectionalDisk self, double * pattern)



        Set DirectionalDisk::emission_.

        The pointer is copied directly, not the array content.

        This is a low-level function. Beware that: previously allocated array
        will not be freed automatically;

        array attached when the destructor is called will be freed. 
        """
        return _gyoto_std.DirectionalDisk_setEmission(self, pattern)


    def radius(self, pattern):
        """radius(DirectionalDisk self, double * pattern)"""
        return _gyoto_std.DirectionalDisk_radius(self, pattern)


    def copyIntensity(self, pattern=None, naxes=0):
        """
        copyIntensity(DirectionalDisk self, double const *const pattern=None, size_t const [3] naxes=0)
        copyIntensity(DirectionalDisk self, double const *const pattern=None)
        copyIntensity(DirectionalDisk self)



        DirectionalDisk::emission_ is freed if not NULL, reallocated, and
        pattern is copied into emission_.

        Finally, DirectionalDisk::nnu_, DirectionalDisk::ni_, and
        DirectionalDisk::nr_ are set according to naxes.

        Parameters:
        -----------

        pattern:  Array to copy as emission_. May be NULL in which case
        emission_ is simply deallocated and set to NULL.

        naxes:  { nnu_, ni_, nr_ }. 
        """
        return _gyoto_std.DirectionalDisk_copyIntensity(self, pattern, naxes)


    def getIntensity(self):
        """
        getIntensity(DirectionalDisk self) -> double const *



        Get DirectionalDisk::emission_. 
        """
        return _gyoto_std.DirectionalDisk_getIntensity(self)


    def getIntensityNaxes(self, naxes):
        """
        getIntensityNaxes(DirectionalDisk self, size_t [3] naxes)



        Get DirectionalDisk::nnu_, DirectionalDisk::ni_, and
        DirectionalDisk::nr_. 
        """
        return _gyoto_std.DirectionalDisk_getIntensityNaxes(self, naxes)


    def copyGridRadius(self, pattern=None, nr=0):
        """
        copyGridRadius(DirectionalDisk self, double const *const pattern=None, size_t nr=0)
        copyGridRadius(DirectionalDisk self, double const *const pattern=None)
        copyGridRadius(DirectionalDisk self)
        """
        return _gyoto_std.DirectionalDisk_copyGridRadius(self, pattern, nr)


    def getGridRadius(self):
        """
        getGridRadius(DirectionalDisk self) -> double const *



        Get DirectionalDisk::radius_. 
        """
        return _gyoto_std.DirectionalDisk_getGridRadius(self)


    def copyGridCosi(self, pattern=None, ni=0):
        """
        copyGridCosi(DirectionalDisk self, double const *const pattern=None, size_t ni=0)
        copyGridCosi(DirectionalDisk self, double const *const pattern=None)
        copyGridCosi(DirectionalDisk self)
        """
        return _gyoto_std.DirectionalDisk_copyGridCosi(self, pattern, ni)


    def getGridCosi(self):
        """
        getGridCosi(DirectionalDisk self) -> double const *



        Get DirectionalDisk::cosi_. 
        """
        return _gyoto_std.DirectionalDisk_getGridCosi(self)


    def copyGridFreq(self, pattern=None, ni=0):
        """
        copyGridFreq(DirectionalDisk self, double const *const pattern=None, size_t ni=0)
        copyGridFreq(DirectionalDisk self, double const *const pattern=None)
        copyGridFreq(DirectionalDisk self)
        """
        return _gyoto_std.DirectionalDisk_copyGridFreq(self, pattern, ni)


    def getGridFreq(self):
        """
        getGridFreq(DirectionalDisk self) -> double const *



        Get DirectionalDisk::freq_. 
        """
        return _gyoto_std.DirectionalDisk_getGridFreq(self)


    def emission(self, *args):
        """
        emission(DirectionalDisk self, double arg2, double arg3, double * arg4, double arg5) -> double
        emission(DirectionalDisk self, double nu_em, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        emission(DirectionalDisk self, double nu_em, double dsem, double [8] c_ph) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto_std.DirectionalDisk_emission(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::DirectionalDisk self) -> DirectionalDisk
        __init__(Gyoto::Astrobj::DirectionalDisk self, DirectionalDisk arg2) -> DirectionalDisk
        __init__(Gyoto::Astrobj::DirectionalDisk self, Astrobj base) -> DirectionalDisk



        Copy constructor. 
        """
        this = _gyoto_std.new_DirectionalDisk(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
DirectionalDisk_swigregister = _gyoto_std.DirectionalDisk_swigregister
DirectionalDisk_swigregister(DirectionalDisk)
DirectionalDisk.properties = _gyoto_std.cvar.DirectionalDisk_properties


_gyoto_std.GYOTO_KERRBL_DEFAULT_DIFFTOL_swigconstant(_gyoto_std)
GYOTO_KERRBL_DEFAULT_DIFFTOL = _gyoto_std.GYOTO_KERRBL_DEFAULT_DIFFTOL
class KerrBL(gyoto.Metric):
    """


    Metric around a Kerr black-hole in Boyer-Lindquist coordinates.

    C++ includes: GyotoKerrBL.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Metric]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KerrBL, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Metric]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, KerrBL, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(KerrBL self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.KerrBL_getProperties(self)


    def clone(self):
        """
        clone(KerrBL self) -> KerrBL



        Virtual copy constructor. 
        """
        return _gyoto_std.KerrBL_clone(self)


    def spin(self, *args):
        """
        spin(KerrBL self, double const spin)
        spin(KerrBL self) -> double



        Returns spin. 
        """
        return _gyoto_std.KerrBL_spin(self, *args)


    def difftol(self, *args):
        """
        difftol(KerrBL self) -> double
        difftol(KerrBL self, double t)



        Set difftol_. 
        """
        return _gyoto_std.KerrBL_difftol(self, *args)


    def horizonSecurity(self, *args):
        """
        horizonSecurity(KerrBL self, double drhor)
        horizonSecurity(KerrBL self) -> double
        """
        return _gyoto_std.KerrBL_horizonSecurity(self, *args)


    def genericIntegrator(self, *args):
        """
        genericIntegrator(KerrBL self, bool arg2)
        genericIntegrator(KerrBL self) -> bool
        """
        return _gyoto_std.KerrBL_genericIntegrator(self, *args)


    def getRms(self):
        """
        getRms(KerrBL self) -> double



        Returns the marginally stable (ISCO) radius Should be implemented in
        derived classes if useful If called on the base class, returns an
        error 
        """
        return _gyoto_std.KerrBL_getRms(self)


    def getRmb(self):
        """
        getRmb(KerrBL self) -> double



        Returns the marginally bound radius Should be implemented in derived
        classes if useful If called on the base class, returns an error 
        """
        return _gyoto_std.KerrBL_getRmb(self)


    def getSpecificAngularMomentum(self, rr):
        """
        getSpecificAngularMomentum(KerrBL self, double rr) -> double



        Returns the specific angular momentum l=-u_phi/u_t Should be
        implemented in derived classes if useful If called on the base class,
        returns an error 
        """
        return _gyoto_std.KerrBL_getSpecificAngularMomentum(self, rr)


    def getPotential(self, pos, l_cst):
        """
        getPotential(KerrBL self, double [4] pos, double l_cst) -> double



        Returns potential W=-ln(|u_t|) for a cst specific angular momentum
        l_cst Should be implemented in derived classes if useful If called on
        the base class, returns an error 
        """
        return _gyoto_std.KerrBL_getPotential(self, pos, l_cst)


    def gmunu(self, *args):
        """
        gmunu(KerrBL self, double [4][4] g, double const * pos)
        gmunu(KerrBL self, double const *const x, int mu, int nu) -> double



        Metric coefficients.

        The default implementation calls Metric:: gmunu(double g[4][4], const
        double * pos) const

        Parameters:
        -----------

        x:  4-position at which to compute the coefficient;

        mu:  1st index of coefficient, 03;

        nu:  2nd index of coefficient, 03;

        Metric coefficient g, at point x 
        """
        return _gyoto_std.KerrBL_gmunu(self, *args)


    def gmunu_up(self, *args):
        """
        gmunu_up(KerrBL self, double [4][4] gup, double const * pos)
        gmunu_up(KerrBL self, double const *const x, int mu, int nu) -> double
        """
        return _gyoto_std.KerrBL_gmunu_up(self, *args)


    def christoffel(self, *args):
        """
        christoffel(KerrBL self, double const [8] coord, int const alpha, int const mu, int const nu) -> double
        christoffel(KerrBL self, double [4][4][4] dst, double const [8] coord) -> int
        christoffel(KerrBL self, double [4][4][4] dst, double const * pos) -> int



        Chistoffel symbol.

        Value of Christoffel symbol at point (x1, x2, x3). 
        """
        return _gyoto_std.KerrBL_christoffel(self, *args)


    def ScalarProd(self, pos, u1, u2):
        """
        ScalarProd(KerrBL self, double const [4] pos, double const [4] u1, double const [4] u2) -> double



        Scalar product.

        Compute the scalarproduct of the two quadrivectors u1 and u2 in this
        Metric, at point pos expressed in coordinate system sys.

        Parameters:
        -----------

        pos:  4-position;

        u1:  1st quadrivector;

        u2:  2nd quadrivector;

        u1*u2 
        """
        return _gyoto_std.KerrBL_ScalarProd(self, pos, u1, u2)


    def nullifyCoord(self, *args):
        """
        nullifyCoord(KerrBL self, double [8] coord, double & tdot2)
        nullifyCoord(KerrBL self, double [8] coord)



        Set tdot (coord[4]) such that coord is light-like. Everything is in
        geometrical units.

        Set coord[4] so that the 4-velocity coord[4:7] is lightlike, i.e. of
        norm 0. There may be up to two solutions. coord[4] is set to the
        hightest. The lowest can be retrieved using nullifyCoord(double
        coord[8], double& tdot2) const. Everything is expressed in geometrical
        units.

        Parameters:
        -----------

        coord:  8-position, coord[4] will be set according to the other
        elements; 
        """
        return _gyoto_std.KerrBL_nullifyCoord(self, *args)


    def circularVelocity(self, pos, vel, dir=1.):
        """
        circularVelocity(KerrBL self, double const [4] pos, double [4] vel, double dir=1.)
        circularVelocity(KerrBL self, double const [4] pos, double [4] vel)



        Yield circular velocity at a given position.

        Give the velocity of a massive particle in circular orbit at the given
        position projected onto the equatorial plane. Such a velocity may not
        exist everywhere (or anywhere) for a given metric. This method is
        intended to be used by Astrobj classes such as Torus or ThinDisk.

        If keplerian_ is set to true, this method should return the Keplerian
        velcity instead (derived classes should ensure this, see
        KerrBL::circularVelocity() for instance).

        The default implementation throws an error if keplerian_ is set to
        false.

        Parameters:
        -----------

        pos:  input: position,

        vel:  output: velocity,

        dir:  1 for corotating, -1 for counterrotating. 
        """
        return _gyoto_std.KerrBL_circularVelocity(self, pos, vel, dir)


    def MakeCoord(self, coordin, cst, coordout):
        """
        MakeCoord(KerrBL self, double const [8] coordin, double const [5] cst, double [8] coordout)



        Inverse function of MakeMomentumAndCst.

        Computes pr, ptheta, E and L from rdot, thetadot, phidot, tdot 
        """
        return _gyoto_std.KerrBL_MakeCoord(self, coordin, cst, coordout)


    def MakeMomentum(self, coordin, cst, coordout):
        """
        MakeMomentum(KerrBL self, double const [8] coordin, double const [5] cst, double [8] coordout)



        Transforms from Boyer-Lindquist coordinates
        [t,r,th,phi,tdot,rdot,thdot,phidot] to [t,r,th,phi,pt,pr,pth,pphi]
        where pt,pr... are generalized momenta. 
        """
        return _gyoto_std.KerrBL_MakeMomentum(self, coordin, cst, coordout)


    def myrk4(self, coor, cst, h, res):
        """
        myrk4(KerrBL self, double const [8] coor, double const [5] cst, double h, double [8] res) -> int



        Internal-use RK4 proxy. 
        """
        return _gyoto_std.KerrBL_myrk4(self, coor, cst, h, res)


    def myrk4_adaptive(self, *args):
        """
        myrk4_adaptive(KerrBL self, Worldline line, double const [8] coor, double lastnorm, double normref, double [8] coor1, double h0, double & h1, double h1max) -> int
        myrk4_adaptive(KerrBL self, Worldline line, double const [8] coor, double lastnorm, double normref, double [8] coor1, double h0, double & h1) -> int



        Internal-use adaptive RK4 proxy. 
        """
        return _gyoto_std.KerrBL_myrk4_adaptive(self, *args)


    def diff(self, y, res):
        """
        diff(KerrBL self, double const [8] y, double [8] res) -> int



        F function such as dy/dtau=F(y,cst) 
        """
        return _gyoto_std.KerrBL_diff(self, y, res)


    def setParticleProperties(self, line, coord):
        """
        setParticleProperties(KerrBL self, Worldline line, double const * coord)



        Set Metric-specific constants of motion. Used e.g. in KerrBL. 
        """
        return _gyoto_std.KerrBL_setParticleProperties(self, line, coord)


    def isStopCondition(self, coord):
        """
        isStopCondition(KerrBL self, double const *const coord) -> int



        Check whether integration should stop.

        The integrating loop will ask this the Metric through this method
        whether or not it is happy to conitnue the integration. Typically, the
        Metric should answer 0 when everything is fine, 1 when too close to
        the event horizon, inside the BH...

        Parameters:
        -----------

        coord:  8-coordinate vector to check. 
        """
        return _gyoto_std.KerrBL_isStopCondition(self, coord)


    def observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3):
        """
        observerTetrad(KerrBL self, std::string const obskind, double const [4] pos, double [4] fourvel, double [4] screen1, double [4] screen2, double [4] screen3)



        Computes the orthonormal local tetrad of the observer.

        Parameters:
        -----------

        obskind:  input: kind of observer (eg:
        "ZAMO","KeplerianObserver"...)

        pos:  input: position,

        fourvel:  output: observer 4-velocity (norm -1)

        screen1:  output: first vector in the screen plane

        screen2:  output: second vector in the screen plane

        screen3:  output: vector normal to the screen 
        """
        return _gyoto_std.KerrBL_observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3)


    def __init__(self, *args):
        """
        __init__(Gyoto::Metric::KerrBL self) -> KerrBL
        __init__(Gyoto::Metric::KerrBL self, Metric base) -> KerrBL



        Default constructor. 
        """
        this = _gyoto_std.new_KerrBL(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_KerrBL
    __del__ = lambda self: None
KerrBL_swigregister = _gyoto_std.KerrBL_swigregister
KerrBL_swigregister(KerrBL)
KerrBL.properties = _gyoto_std.cvar.KerrBL_properties

class KerrKS(gyoto.Metric, gyoto.WIP):
    """


    Metric around a Kerr black-hole in Kerr-Schild coordinates Warning:
    this metric is seldom used and may be buggy.

    By default, uses the generic integrator ( Metric::Generic::myrk4()).
    Use to use the specific integretor which is, as of writting, buggy.

    C++ includes: GyotoKerrKS.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Metric, gyoto.WIP]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KerrKS, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Metric, gyoto.WIP]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, KerrKS, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(KerrKS self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.KerrKS_getProperties(self)


    def clone(self):
        """
        clone(KerrKS self) -> KerrKS



        Copy constructor. 
        """
        return _gyoto_std.KerrKS_clone(self)


    def spin(self, *args):
        """
        spin(KerrKS self, double const spin)
        spin(KerrKS self) -> double



        Returns spin. 
        """
        return _gyoto_std.KerrKS_spin(self, *args)


    def horizonSecurity(self, *args):
        """
        horizonSecurity(KerrKS self, double drhor)
        horizonSecurity(KerrKS self) -> double
        """
        return _gyoto_std.KerrKS_horizonSecurity(self, *args)


    def genericIntegrator(self, *args):
        """
        genericIntegrator(KerrKS self, bool arg2)
        genericIntegrator(KerrKS self) -> bool
        """
        return _gyoto_std.KerrKS_genericIntegrator(self, *args)


    def gmunu(self, *args):
        """
        gmunu(KerrKS self, double const * x, int alpha, int beta) -> double
        gmunu(KerrKS self, double [4][4] g, double const * pos)



        Metric coefficients.

        The default implementation calls double gmunu(const double * x, int
        mu, int nu) const.

        Parameters:
        -----------

        g:  4x4 array to store the coeefficients

        x:  4-position at which to compute the coefficients;

        Metric coefficient g, at point x 
        """
        return _gyoto_std.KerrKS_gmunu(self, *args)


    def gmunu_up(self, gup, pos):
        """
        gmunu_up(KerrKS self, double [4][4] gup, double const * pos)



        The inverse matrix of gmunu. 
        """
        return _gyoto_std.KerrKS_gmunu_up(self, gup, pos)


    def jacobian(self, dst, x):
        """
        jacobian(KerrKS self, double [4][4][4] dst, double const * x)



        The derivatives of gmunu.

        Used in the test suite 
        """
        return _gyoto_std.KerrKS_jacobian(self, dst, x)


    def christoffel(self, *args):
        """
        christoffel(KerrKS self, double const [8] coord, int const alpha, int const mu, int const nu) -> double
        christoffel(KerrKS self, double [4][4][4] dst, double const [8] coord) -> int
        christoffel(KerrKS self, double [4][4][4] dst, double const * x) -> int
        christoffel(KerrKS self, double [4][4][4] dst, double const * pos, double [4][4] gup, double [4][4][4] jac) -> int



        Chistoffel symbol.

        Value of Christoffel symbol at point (x1, x2, x3). 
        """
        return _gyoto_std.KerrKS_christoffel(self, *args)


    def nullifyCoord(self, *args):
        """
        nullifyCoord(KerrKS self, double [8] coord, double & tdot2)
        nullifyCoord(KerrKS self, double [8] coord)



        Set tdot (coord[4]) such that coord is light-like. Everything is in
        geometrical units.

        Set coord[4] so that the 4-velocity coord[4:7] is lightlike, i.e. of
        norm 0. There may be up to two solutions. coord[4] is set to the
        hightest. The lowest can be retrieved using nullifyCoord(double
        coord[8], double& tdot2) const. Everything is expressed in geometrical
        units.

        Parameters:
        -----------

        coord:  8-position, coord[4] will be set according to the other
        elements; 
        """
        return _gyoto_std.KerrKS_nullifyCoord(self, *args)


    def circularVelocity(self, pos, vel, dir=1.):
        """
        circularVelocity(KerrKS self, double const [4] pos, double [4] vel, double dir=1.)
        circularVelocity(KerrKS self, double const [4] pos, double [4] vel)



        Yield circular velocity at a given position.

        Give the velocity of a massive particle in circular orbit at the given
        position projected onto the equatorial plane. Such a velocity may not
        exist everywhere (or anywhere) for a given metric. This method is
        intended to be used by Astrobj classes such as Torus or ThinDisk.

        If keplerian_ is set to true, this method should return the Keplerian
        velcity instead (derived classes should ensure this, see
        KerrBL::circularVelocity() for instance).

        The default implementation throws an error if keplerian_ is set to
        false.

        Parameters:
        -----------

        pos:  input: position,

        vel:  output: velocity,

        dir:  1 for corotating, -1 for counterrotating. 
        """
        return _gyoto_std.KerrKS_circularVelocity(self, pos, vel, dir)


    def MakeCst(self, coord, cst):
        """
        MakeCst(KerrKS self, double const * coord, double * cst)



        In Kerr-Schild coordinates [T,x,y,z,Tdot,xdot,ydot,zdot], computes the
        four constants of the movement : particule mass, energy, angular
        momentum and Carter's constant. 
        """
        return _gyoto_std.KerrKS_MakeCst(self, coord, cst)


    def __init__(self, *args):
        """
        __init__(Gyoto::Metric::KerrKS self) -> KerrKS
        __init__(Gyoto::Metric::KerrKS self, Metric base) -> KerrKS



        Default constructor. 
        """
        this = _gyoto_std.new_KerrKS(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_KerrKS
    __del__ = lambda self: None
KerrKS_swigregister = _gyoto_std.KerrKS_swigregister
KerrKS_swigregister(KerrKS)
KerrKS.properties = _gyoto_std.cvar.KerrKS_properties

class Minkowski(gyoto.Metric):
    """


    The Minkowski flat-space metric.

    Use <Cartesian> or </Spherical> to select the coordinate system kind.

    C++ includes: GyotoMinkowski.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Metric]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Minkowski, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Metric]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Minkowski, name)
    __repr__ = _swig_repr

    def spherical(self, *args):
        """
        spherical(Minkowski self, bool arg2)
        spherical(Minkowski self) -> bool
        """
        return _gyoto_std.Minkowski_spherical(self, *args)


    def getProperties(self):
        """
        getProperties(Minkowski self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.Minkowski_getProperties(self)


    def clone(self):
        """
        clone(Minkowski self) -> Minkowski



        Virtual copy constructor. 
        """
        return _gyoto_std.Minkowski_clone(self)


    def gmunu(self, *args):
        """
        gmunu(Minkowski self, double [4][4] g, double const * x)
        gmunu(Minkowski self, double const * x, int mu, int nu) -> double



        Metric coefficients.

        The default implementation calls Metric:: gmunu(double g[4][4], const
        double * pos) const

        Parameters:
        -----------

        x:  4-position at which to compute the coefficient;

        mu:  1st index of coefficient, 03;

        nu:  2nd index of coefficient, 03;

        Metric coefficient g, at point x 
        """
        return _gyoto_std.Minkowski_gmunu(self, *args)


    def christoffel(self, *args):
        """
        christoffel(Minkowski self, double [4][4][4] dst, double const * x) -> int
        christoffel(Minkowski self, double const [8] coord, int const alpha, int const mu, int const nu) -> double



        Chistoffel symbol.

        Value of Christoffel symbol at point (x1, x2, x3). 
        """
        return _gyoto_std.Minkowski_christoffel(self, *args)


    def observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3):
        """
        observerTetrad(Minkowski self, std::string const obskind, double const [4] pos, double [4] fourvel, double [4] screen1, double [4] screen2, double [4] screen3)



        Computes the orthonormal local tetrad of the observer.

        Parameters:
        -----------

        obskind:  input: kind of observer (eg:
        "ZAMO","KeplerianObserver"...)

        pos:  input: position,

        fourvel:  output: observer 4-velocity (norm -1)

        screen1:  output: first vector in the screen plane

        screen2:  output: second vector in the screen plane

        screen3:  output: vector normal to the screen 
        """
        return _gyoto_std.Minkowski_observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3)


    def __init__(self, *args):
        """
        __init__(Gyoto::Metric::Minkowski self) -> Minkowski
        __init__(Gyoto::Metric::Minkowski self, Metric base) -> Minkowski
        """
        this = _gyoto_std.new_Minkowski(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_Minkowski
    __del__ = lambda self: None
Minkowski_swigregister = _gyoto_std.Minkowski_swigregister
Minkowski_swigregister(Minkowski)
Minkowski.properties = _gyoto_std.cvar.Minkowski_properties

class PowerLaw(gyoto.Spectrum):
    """


    I_nu=constant_*nu^exponent_.

    Light emitted by e.g. a Star.

    XML stanza:

    C++ includes: GyotoPowerLawSpectrum.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PowerLaw, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PowerLaw, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(PowerLaw self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.PowerLaw_getProperties(self)


    def clone(self):
        """
        clone(PowerLaw self) -> PowerLaw



        Cloner. 
        """
        return _gyoto_std.PowerLaw_clone(self)


    def constant(self, *args):
        """
        constant(PowerLaw self) -> double
        constant(PowerLaw self, double arg2)



        Set constant_. 
        """
        return _gyoto_std.PowerLaw_constant(self, *args)


    def exponent(self, *args):
        """
        exponent(PowerLaw self) -> double
        exponent(PowerLaw self, double arg2)



        Set exponent_. 
        """
        return _gyoto_std.PowerLaw_exponent(self, *args)


    def __call__(self, *args):
        """
        __call__(PowerLaw self, double nu, double opacity, double ds) -> double
        __call__(PowerLaw self, double nu) -> double
        """
        return _gyoto_std.PowerLaw___call__(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Spectrum::PowerLaw self) -> PowerLaw
        __init__(Gyoto::Spectrum::PowerLaw self, double exponent, double constant=1.) -> PowerLaw
        __init__(Gyoto::Spectrum::PowerLaw self, double exponent) -> PowerLaw
        __init__(Gyoto::Spectrum::PowerLaw self, Spectrum base) -> PowerLaw



        Constructor setting exponent_ and optionally constant_. 
        """
        this = _gyoto_std.new_PowerLaw(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_PowerLaw
    __del__ = lambda self: None
PowerLaw_swigregister = _gyoto_std.PowerLaw_swigregister
PowerLaw_swigregister(PowerLaw)
PowerLaw.properties = _gyoto_std.cvar.PowerLaw_properties

class BlackBody(gyoto.Spectrum):
    """


    Black Body.

    Light emitted by e.g. a Star.

    Example XML entity:

    C++ includes: GyotoBlackBodySpectrum.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BlackBody, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BlackBody, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(BlackBody self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.BlackBody_getProperties(self)


    def clone(self):
        """
        clone(BlackBody self) -> BlackBody



        Cloner. 
        """
        return _gyoto_std.BlackBody_clone(self)


    def temperature(self, *args):
        """
        temperature(BlackBody self) -> double
        temperature(BlackBody self, double arg2)



        Set constant. 
        """
        return _gyoto_std.BlackBody_temperature(self, *args)


    def scaling(self, *args):
        """
        scaling(BlackBody self) -> double
        scaling(BlackBody self, double arg2)



        Set exponent. 
        """
        return _gyoto_std.BlackBody_scaling(self, *args)


    def __call__(self, *args):
        """
        __call__(BlackBody self, double nu, double opacity, double ds) -> double
        __call__(BlackBody self, double nu) -> double
        """
        return _gyoto_std.BlackBody___call__(self, *args)


    def __init__(self, *args):
        """
        __init__(Gyoto::Spectrum::BlackBody self) -> BlackBody
        __init__(Gyoto::Spectrum::BlackBody self, double T, double scaling=1.) -> BlackBody
        __init__(Gyoto::Spectrum::BlackBody self, double T) -> BlackBody
        __init__(Gyoto::Spectrum::BlackBody self, Spectrum base) -> BlackBody



        Constructor setting T_ and cst_. 
        """
        this = _gyoto_std.new_BlackBody(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_BlackBody
    __del__ = lambda self: None
BlackBody_swigregister = _gyoto_std.BlackBody_swigregister
BlackBody_swigregister(BlackBody)
BlackBody.properties = _gyoto_std.cvar.BlackBody_properties

class ThermalBremsstrahlung(gyoto.Spectrum):
    """


    Thermal brems spectrum.

    Example XML entity:

    C++ includes: GyotoThermalBremsstrahlungSpectrum.h 
    """

    __swig_setmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThermalBremsstrahlung, name, value)
    __swig_getmethods__ = {}
    for _s in [gyoto.Spectrum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThermalBremsstrahlung, name)
    __repr__ = _swig_repr

    def getProperties(self):
        """
        getProperties(ThermalBremsstrahlung self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto_std.ThermalBremsstrahlung_getProperties(self)


    def clone(self):
        """
        clone(ThermalBremsstrahlung self) -> ThermalBremsstrahlung



        Constructor setting T_ and cst_.

        Cloner 
        """
        return _gyoto_std.ThermalBremsstrahlung_clone(self)


    def __call__(self, *args):
        """
        __call__(ThermalBremsstrahlung self, double nu, double opacity, double ds) -> double
        __call__(ThermalBremsstrahlung self, double nu) -> double
        """
        return _gyoto_std.ThermalBremsstrahlung___call__(self, *args)


    def temperature(self, *args):
        """
        temperature(ThermalBremsstrahlung self) -> double
        temperature(ThermalBremsstrahlung self, double tt)
        """
        return _gyoto_std.ThermalBremsstrahlung_temperature(self, *args)


    def massdensityCGS(self, *args):
        """
        massdensityCGS(ThermalBremsstrahlung self) -> double
        massdensityCGS(ThermalBremsstrahlung self, double rho)
        """
        return _gyoto_std.ThermalBremsstrahlung_massdensityCGS(self, *args)


    def jnuCGS(self, nu):
        """
        jnuCGS(ThermalBremsstrahlung self, double nu) -> double



        Returns the emission coefficient j_nu in cgs units i.e. erg cm^-3 s^-1
        ster^-1 Hz^-1

        Parameters:
        -----------

        nu:  frequency in Hz 
        """
        return _gyoto_std.ThermalBremsstrahlung_jnuCGS(self, nu)


    def alphanuCGS(self, nu):
        """
        alphanuCGS(ThermalBremsstrahlung self, double nu) -> double



        Returns the absorption coefficient alpha_nu in cgs units [cm^-1]

        Parameters:
        -----------

        nu:  frequency in Hz 
        """
        return _gyoto_std.ThermalBremsstrahlung_alphanuCGS(self, nu)


    def __init__(self, *args):
        """
        __init__(Gyoto::Spectrum::ThermalBremsstrahlung self) -> ThermalBremsstrahlung
        __init__(Gyoto::Spectrum::ThermalBremsstrahlung self, Spectrum base) -> ThermalBremsstrahlung
        """
        this = _gyoto_std.new_ThermalBremsstrahlung(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto_std.delete_ThermalBremsstrahlung
    __del__ = lambda self: None
ThermalBremsstrahlung_swigregister = _gyoto_std.ThermalBremsstrahlung_swigregister
ThermalBremsstrahlung_swigregister(ThermalBremsstrahlung)
ThermalBremsstrahlung.properties = _gyoto_std.cvar.ThermalBremsstrahlung_properties

# This file is compatible with both classic and new-style classes.