Project bayesian-priors
-----------------------

Invoke with: ``import icecube.bayesian_priors``

C++ ServiceFactorys
^^^^^^^^^^^^^^^^^^^

.. js:data:: I3ConstantZenithWeightServiceFactory

    ``"I3ConstantZenithWeightServiceFactory"`` *(C++ ServiceFactory)*

    *<undocumented>*

    :param CosZenithRange: *Default* = ``[-1.0, 1.0]``,
        Minimum and maximum value of cos(zenith) (before any flipping).

    :param FlipTrack: *Default* = ``False``,
        Boolean option: if you set this to true, then the weight will be computed as if
        the track pointed in the opposite direction.

    :param PenaltySlope: *Default* = ``0.0``,
        If your goal is to force a reconstruction to end up within within a specific
        zenith range, but you don't like setting bounds on the parameters, then you can
        stimulate the reconstruction to 'roll' back to the allowed range via a sloped
        penalty value, i.e. a penalty which gets worse farther away from the allowed
        zenith range, then you should set a negitive value here, e.g. -1000.

    :param PenaltyValue: *Default* = ``-200.0``,
        LogLikelihood value outside the cos(zenith) range. Should be a large negative
        number.


.. js:data:: I3PolynomialZenithWeightServiceFactory

    ``"I3PolynomialZenithWeightServiceFactory"`` *(C++ ServiceFactory)*

    *<undocumented>*

    :param Coefficients: *Default* = ``[-0.007355395666666667, 0.1899537877777778, -1.5003446333333332, 1.6376264333333335, 23.163495444444443, -61.62309222222222, 60.70669777777778, -21.576655]``,
        Coefficients for a polynomial of cos(zenith). The default uses the same
        coefficients as Ty's P7 zenith weight function for AMANDA data.

    :param CosZenithRange: *Default* = ``[-1.0, 1.0]``,
        Minimum and maximum value of cos(zenith) (before any flipping).

    :param DefaultWeight: *Default* = ``1.111111111111111e-06``,
        Default weight value for cos(zen) < MinCosZenith

    :param FlipTrack: *Default* = ``False``,
        Boolean option: if you set this to true, then the weight will be computed as if
        the track pointed in the opposite direction.

    :param MinCosZenith: *Default* = ``0.1``,
        Minimum cos(zenith) value; for lower values the default weight is used.

    :param PenaltySlope: *Default* = ``0.0``,
        If your goal is to force a reconstruction to end up within within a specific
        zenith range, but you don't like setting bounds on the parameters, then you can
        stimulate the reconstruction to 'roll' back to the allowed range via a sloped
        penalty value, i.e. a penalty which gets worse farther away from the allowed
        zenith range, then you should set a negitive value here, e.g. -1000.

    :param PenaltyValue: *Default* = ``-200.0``,
        LogLikelihood value outside the cos(zenith) range. Should be a large negative
        number.


.. js:data:: I3PowExpZenithWeightServiceFactory

    ``"I3PowExpZenithWeightServiceFactory"`` *(C++ ServiceFactory)*

    This service provides a gulliver I3EventLogLikelihoodBase which includes a prior
    probability to the liklihood as a function of zenith angle to provide a "Bayesian"
    reconstruction.

    :param Amplitude: *Default* = ``2.49655e-07``,
        Amplitude factor (a0 in w=a0*pow(z,a1)*exp(-a2/z) with z=cos(zenith))

    :param CosZenithRange: *Default* = ``[-1.0, 1.0]``,
        Minimum and maximum value of cos(zenith) (before any flipping).

    :param DefaultWeight: *Default* = ``1.3838965267367376e-87``,
        Default weight for to low cos(zenith) values

    :param ExponentFactor: *Default* = ``0.778393``,
        Numerator in the exponent of the exponent factor (a2 in
        w=a0*pow(z,a1)*exp(-a2/z) with z=cos(zenith))

    :param FlipTrack: *Default* = ``False``,
        Boolean option: if you set this to true, then the weight will be computed as if
        the track pointed in the opposite direction.

    :param PenaltySlope: *Default* = ``0.0``,
        If your goal is to force a reconstruction to end up within within a specific
        zenith range, but you don't like setting bounds on the parameters, then you can
        stimulate the reconstruction to 'roll' back to the allowed range via a sloped
        penalty value, i.e. a penalty which gets worse farther away from the allowed
        zenith range, then you should set a negitive value here, e.g. -1000.

    :param PenaltyValue: *Default* = ``-200.0``,
        LogLikelihood value outside the cos(zenith) range. Should be a large negative
        number.

    :param Power: *Default* = ``1.67721``,
        Exponent in the power factor (a1 in w=a0*pow(z,a1)*exp(-a2/z) with
        z=cos(zenith))


.. js:data:: I3TableZenithWeightServiceFactory

    ``"I3TableZenithWeightServiceFactory"`` *(C++ ServiceFactory)*

    *<undocumented>*

    :param CosZenithRange: *Default* = ``[-1.0, 1.0]``,
        Minimum and maximum value of cos(zenith) (before any flipping).

    :param FlipTrack: *Default* = ``False``,
        Boolean option: if you set this to true, then the weight will be computed as if
        the track pointed in the opposite direction.

    :param MinCosZenith: *Default* = ``0.1``,
        Minimum cos(zenith) value; for lower values the default weight is used.

    :param PenaltySlope: *Default* = ``0.0``,
        If your goal is to force a reconstruction to end up within within a specific
        zenith range, but you don't like setting bounds on the parameters, then you can
        stimulate the reconstruction to 'roll' back to the allowed range via a sloped
        penalty value, i.e. a penalty which gets worse farther away from the allowed
        zenith range, then you should set a negitive value here, e.g. -1000.

    :param PenaltyValue: *Default* = ``-200.0``,
        LogLikelihood value outside the cos(zenith) range. Should be a large negative
        number.

    :param TableValues: *Default* = ``[1.0, 200.0, 5000.0, 50000.0, 100000.0, 200000.0, 400000.0, 500000.0, 600000.0, 800000.0, 900000.0]``,
        Table values, for equidistant values of cos(zenith). The table should contain at
        least 2 values, the first the first gives the weight at the minimum cos(zenith)
        value, the first gives the weight at cos(zenith)==1. The default uses values
        originally optimized for AMANDA data.