Overview | Package | Class | Tree | Deprecated | Index | Help
| ContactCenters V. 0.9.9.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD | DETAIL: ENUM CONSTANTS | FIELD | METHOD

## umontreal.iro.lecuyer.contactcenters.app
Enum ArrivalProcessType

    java.lang.Object
      java.lang.Enum<ArrivalProcessType>
          umontreal.iro.lecuyer.contactcenters.app.ArrivalProcessType

All Implemented Interfaces:
  Serializable, Comparable<ArrivalProcessType>

    public enum ArrivalProcessType

extends Enum<ArrivalProcessType>

Represents the type of arrival process for a blend/multi-skill call center. This process defines at which times a new call occurs during the simulation. The used arrival process determines how the parameters, usually given using an array of double-precision values, are used. All the arrival processes defined in [3] are supported.

Note that when simulating on an infinite horizon, only arrival processes capable of generating arrivals following parameters not evolving with time are allowed. The recommended arrival processes for such simulations are `POISSON` and `PIECEWISECONSTANTPOISSON`.

If the busyness generator for B is undefined, then B is replaced by a deterministic constant = 1.

Enum Constant Summary
`CUBICSPLINE` Non-homogenous Poisson arrival process using a cubic spline to model the time-varying arrival rate.
`DIRICHLET` Dirichlet arrival process.
`DIRICHLETCOMPOUND` Dirichlet compound arrival process.
`FIXEDCOUNTS` Uniform arrival process with pre-determined arrival counts Cp in each period.
`NORTADRIVEN` Represents a NORTA-driven arrival process with negative binomial marginals.
`PIECEWISECONSTANTPOISSON` Non-homogeneous Poisson arrival process with piecewise-constant arrival rates.
`PIECEWISECONSTANTPOISSONINT` Non-homogeneous Poisson arrival process with piecewise-constant arrival rates that can change at arbitrary times.
`POISSON` Poisson arrival process.
`POISSONGAMMA` Poisson process with piecewise-constant randomized arrival rates [13].
`POISSONGAMMANORTARATES` Doubly-stochastic Gamma-Poisson process with piecewise-constant randomized correlated Gamma arrival rates.
`UNIFORM` Uniform arrival process with piecewise-constant arrival rates.

Method Summary
`String` | `toString()`
`static ArrivalProcessType` | `valueOf(String name)` Returns the enum constant of this type with the specified name.
`static ArrivalProcessType[]` | `values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
`clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf`

Methods inherited from class java.lang.Object
`getClass, notify, notifyAll, wait, wait, wait`

Enum Constant Detail

### POISSON

    public static final ArrivalProcessType POISSON

  Poisson arrival process. See `PoissonArrivalProcess` for more information. Inter-arrival times are generated independently from the exponential distribution with fixed rate Bλ, where λ is the base arrival rate given by the first value of the `arrivals` element, and B is a global busyness factor given by `busynessGen` element in call center parameters. The λ parameter can be estimated from data.

### PIECEWISECONSTANTPOISSON

    public static final ArrivalProcessType PIECEWISECONSTANTPOISSON

  Non-homogeneous Poisson arrival process with piecewise-constant arrival rates. See `PiecewiseConstantPoissonArrivalProcess` for more information. Inter-arrival times are independent exponential variates with rate λ(t) = Bλp(t), where p(t) is the period corresponding to simulation time t, and λp is the base arrival rate for period p. The values in `arrivals` element give the base arrival rate for each main period, while the rates for preliminary and wrap-up periods are always 0. The λp parameters can be estimated from data by assuming that the periods are independent, and the per-period numbers of arrivals follow the Poisson distribution. The arrival rates can also be estimated together with a busyness factor following the gamma (α0, α0) distribution. In this case, the number of arrivals is assumed to follow the negative multinomial distribution with parameters α0, ρ1,…, ρP, where

  ρp =

  for p = 1,…, P. The above method for the λp is equivalent to

  λp = Xk, p,

  where n is the number of days.

### PIECEWISECONSTANTPOISSONINT

    public static final ArrivalProcessType PIECEWISECONSTANTPOISSONINT

  Non-homogeneous Poisson arrival process with piecewise-constant arrival rates that can change at arbitrary times. See `PoissonArrivalProcessWithTimeIntervals` for more information. This process is similar to `PIECEWISECONSTANTPOISSON`, except arrival rates can change at any time, not only at period boundaries. More specifically, let t0 < ... < tL be an increasing sequence of simulation times, and let Bλj, for j = 0,…, L - 1, be the arrival rate during time interval [tj, tj+1). The arrival rate is 0 for t < t0 and t≥tL. The sequence of times is given using the `times` element while the sequence of rates is given using `lambdas`. Of course, the length of the sequence of rates must be one less than the length of the the sequence of times.

### UNIFORM

    public static final ArrivalProcessType UNIFORM

  Uniform arrival process with piecewise-constant arrival rates. See `PoissonUniformArrivalProcess` for more information. For each main period p = 1,…, P, round(Bλp) arrivals are generated uniformly in the period, and arrival times are sorted in increasing order. The values in the `arrivals` element give the base arrival rate λp for each main period, while the rates for preliminary and wrap-up periods are always 0. The λp parameters can be estimated from data by assuming that the periods are independent, and the per-period numbers of arrivals follow the Poisson distribution.

### FIXEDCOUNTS

    public static final ArrivalProcessType FIXEDCOUNTS

  Uniform arrival process with pre-determined arrival counts Cp in each period. Represents a counts-driven arrival process. See `FixedCountsArrivalProcess` for more information.
  For each main period p = 1,…, P, the Cp arrivals are generated uniformly in the period, and arrival times are sorted in increasing order. The values in the `counts` element give the number of arrivals for each main period, while the counts for preliminary and wrap-up periods are always 0.

### POISSONGAMMA

    public static final ArrivalProcessType POISSONGAMMA

  Poisson process with piecewise-constant randomized arrival rates [13]. See `PoissonGammaArrivalProcess` for more information. As with `PIECEWISECONSTANTPOISSON`, the arrival rate is given by λ(t) = Bλp(t). The base arrival rates λp are constant during each main period, but they are not deterministic: for main period p, the base rate of the Poisson process is defined as a gamma random variable with shape parameter αG, p, and scale parameter λG, p (mean αG, p/λG, p). Shape parameters are stored in element `poissonGammaShape` while scale parameters are stored in `poissonGammaScale`. As with the Poisson process with deterministic arrival rates, the generated base arrival rates are multiplied by a busyness factor B to get the arrival rates, and the arrival rate is 0 during preliminary and wrap-up periods. The αG, p and λG, p parameters can be estimated from data by considering that the number of arrivals during period p follow the negative binomial distribution with parameters (αG, p, λG, p/(αG, p + λG, p)), independently of the other periods. However, the parameters of the distribution of the busyness factor cannot be estimated at the same time as the gamma parameters.

### POISSONGAMMANORTARATES

    public static final ArrivalProcessType POISSONGAMMANORTARATES

  Doubly-stochastic Gamma-Poisson process with piecewise-constant randomized correlated Gamma arrival rates. See `PoissonGammaNortaRatesArrivalProcess` for more information.

  The base arrival rates λp are constant during each period, but they are not deterministic: for period p, the base rate of the Poisson process is defined as a correlated gamma random variable. The marginal distribution of the rate is gamma with shape parameter αG, p, and scale parameter λG, p (and mean αG, p/λG, p). The correlation structure is modelled using the normal copula model with positive definite correlation matrix having elements in [- 1, 1]. If αG, p or λG, p are 0, the resulting arrival rate during period p is always 0. The Gamma shape parameters are stored in element `poissonGammaShape` while the Gamma scale parameters are stored in `poissonGammaScale`. A correlation matrix must be given by `copulaSigma`. As with the Poisson process with deterministic arrival rates, the generated base arrival rates are multiplied by a busyness factor B to get the arrival rates, and the arrival rate is 0 during preliminary and wrap-up periods. The parameters of the distribution of the busyness factor cannot be estimated at the same time as the gamma parameters.

### DIRICHLETCOMPOUND

    public static final ArrivalProcessType DIRICHLETCOMPOUND

  Dirichlet compound arrival process. See `DirichletCompoundArrivalProcess` for more information.
  The values in `arrivals` element are used to store the αp parameters. These parameters, along with the γ parameter of the busyness factor, can be estimated from the data.

### DIRICHLET

    public static final ArrivalProcessType DIRICHLET

  Dirichlet arrival process. See `DirichletArrivalProcess` for more information.

  The values in `arrivals` element are used for the αp parameters. If a busyness factor B is generated for the day, the generated Ap's are multiplied by B and rounded to the nearest integer to get the modified number of arrivals. The parameters αp can be estimated from data, but one needs to specify a distribution for A to estimate parameters from. This arrival process cannot estimate parameters of the busyness factor.

### NORTADRIVEN

    public static final ArrivalProcessType NORTADRIVEN

  Represents a NORTA-driven arrival process with negative binomial marginals. See `NORTADrivenArrivalProcess` for more information.

  To use this process, a correlation matrix must be given by `nortaSigma`, and parameters for the negative binomials must be supplied by `nortaGamma` and `nortaP`. If a busyness factor B is generated for the day, the generated Ap's are multiplied by B and rounded to the nearest integer to get the modified number of arrivals. This arrival process does not support parameter estimation from data.

### CUBICSPLINE

    public static final ArrivalProcessType CUBICSPLINE

  Non-homogenous Poisson arrival process using a cubic spline to model the time-varying arrival rate. The λ(t) function which represents the arrival rate at any time t is a cubic spline created from a sequence of n points (ti, λ(ti)) also called nodes. A cubic spline is a set of cubic polynomials linked by some continuity constraints. The ith polynomial of such a spline, for i = 0,…, n - 2, is defined as

  si(t) = ai(t - ti)3 + bi(t - ti)2 + ci(t - ti) + di,

  while the complete spline is defined as

  s(t) = si(t) for t∈[ti, ti+1].

  For t < t0 and t > tn-1, the spline is undefined, but the implementation performs linear extrapolation.

  Interpolating splines are forced to pass through every point, i.e., si(ti) = λ(ti) for i = 0,…, n - 2, and sn-2(tn-1) = λ(tn-1). On the other hand, smoothing splines tolerate some error, i.e., the spline minimizes

  L = ρ(λ(ti) - s(ti))2 + (1 - ρ)(s''(x))2dx.

  The value ρ in previous equation is the smoothing factor of the spline.

  Both kinds of splines enforce the three following continuity constraints:

  si(ti+1) | = | si+1(ti+1), |
  si(ti+1) | = | si+1(ti+1), |
  and si(ti+1) | = | si+1(ti+1), for i = 0,…, n - 2. |

  The cubic splines used are named natural splines, because s(t0) = s(tn-1) = 0.

  To use this arrival process, one must specify the ti's with the `times` element, the λ(ti)'s with `lambdas` element, and the smoothing factor with `smoothingFactor` attribute. For this arrival process, `times` and `lambdas` must share the same length.

Method Detail

### values

    public static ArrivalProcessType[] values()

  Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:

      for (ArrivalProcessType c : ArrivalProcessType.values())
          System.out.println(c);

  Returns:
    an array containing the constants of this enum type, in the order they are declared

### valueOf

    public static ArrivalProcessType valueOf(String name)

  Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

  Parameters:
    `name` - the name of the enum constant to be returned.
  Returns:
    the enum constant with the specified name
  Throws:
    `IllegalArgumentException` - if this enum type has no constant with the specified name
    `NullPointerException` - if the argument is null

### toString

    public String toString()

  Overrides:
    `toString` in class `Enum<ArrivalProcessType>`

Overview | Package | Class | Tree | Deprecated | Index | Help
| ContactCenters V. 0.9.9.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD | DETAIL: ENUM CONSTANTS | FIELD | METHOD

To submit a bug or ask questions, send an e-mail to Richard Simard.