Package jline.lang.nodes

Class Source

java.lang.Object
jline.lang.Element
jline.lang.NetworkElement
jline.lang.nodes.Node
jline.lang.nodes.StatefulNode
jline.lang.nodes.ServiceNode
jline.lang.nodes.Station
jline.lang.nodes.Source
All Implemented Interfaces:
Serializable, Cloneable, Copyable
public class Source extends Station implements Serializable
An abstraction of the external world jobs in open classes come from
See Also:

  • Field Details

  • Constructor Details

    • Source

      public Source(Network model, String name)
      Creates a new source node in the specified network. Initializes arrival processes for all job classes with Disabled distribution.
      Parameters:
      model - the network model to add this source to
      name - the name for this source node

  • Method Details

    • containsJobClass

      public boolean containsJobClass(JobClass jobClass)
      Checks if this source has an arrival process configured for the specified job class.
      Parameters:
      jobClass - the job class to check
      Returns:
      true if an arrival process exists for this job class, false otherwise

    • getArrivalDistribution

      public Distribution getArrivalDistribution(JobClass jobClass)
      Gets the arrival distribution for a specific job class.
      Parameters:
      jobClass - the job class to query
      Returns:
      the arrival distribution, or Disabled if none configured

    • getArrivalProcess

      public final Distribution getArrivalProcess(JobClass jobClass)
      Gets the arrival process distribution for a specific job class. This is an alias for getArrivalDistribution.
      Parameters:
      jobClass - the job class to query
      Returns:
      the arrival distribution, or Disabled if none configured

    • getSchedStrategy

      public SchedStrategy getSchedStrategy()
      Gets the scheduling strategy for this source node. Sources always use EXT (external) scheduling strategy.
      Overrides:
      getSchedStrategy in class Station
      Returns:
      the scheduling strategy (always SchedStrategy.EXT)

    • printSummary

      public void printSummary()
      Description copied from class: Node
      Prints a summary of this node's configuration to the console.
      Overrides:
      printSummary in class Node

    • removeArrivalProcess

      protected void removeArrivalProcess(JobClass jobClass)
      Removes the arrival process for a specific job class.
      Parameters:
      jobClass - the job class whose arrival process should be removed

    • removeJobClass

      public void removeJobClass(JobClass jobClass)
      Description copied from class: Node
      Removes all per-class configuration referencing the given job class from this node. The base implementation drops the class's output (routing) strategies; subclasses extend it to drop service, capacity, arrival and class-switching configuration. Called by Network.removeClass(jline.lang.JobClass).
      Overrides:
      removeJobClass in class Station
      Parameters:
      jobClass - the job class being removed from the model

    • setArrival

      public void setArrival(JobClass jobClass, Object distribution)
      Sets the arrival distribution for a specific job class. If distribution is null or Disabled, sets class capacity to 0. If a Workflow is provided, it will be converted to a PH distribution.
      Parameters:
      jobClass - the job class to configure
      distribution - the arrival distribution or workflow to set

    • setArrivalBatch

      public void setArrivalBatch(JobClass jobClass, DiscreteDistribution batchSize)
      Sets a batch-size law for a class, turning each arrival epoch of that class into the simultaneous release of a batch of jobs.

      The interarrival distribution set by setArrival(jline.lang.JobClass, java.lang.Object) continues to govern the spacing of the epochs; this governs how many jobs each epoch releases. A Geometric(a) interarrival time with a Geometric(beta) batch size is the Geo^X arrival process of a discrete-time queue, whose analytical counterpart is jline.api.dqsys.Dqsys_geoxgeo1.

      The batch size must be supported on {1,2,...}: an epoch that releases no job is not an arrival epoch. Batch laws are therefore rejected here if they can return zero, rather than being silently clamped.

      Parameters:
      jobClass - the job class to configure
      batchSize - the batch-size law, or null to restore single arrivals

    • getArrivalBatch

      public DiscreteDistribution getArrivalBatch(JobClass jobClass)
      Parameters:
      jobClass - the job class to query
      Returns:
      the batch-size law bound to the class, or null for single arrivals

    • setArrivalProcess

      public void setArrivalProcess(ServiceBinding arrivalProcess)
      Sets the arrival process using a service binding. Removes any existing arrival process for the same job class.
      Parameters:
      arrivalProcess - the service binding defining the arrival process

    • setMarkedArrival

      public void setMarkedArrival(MarkedMAP mmap, List<JobClass> classes)
      Binds a MarkedMAP with K marks to K open classes: mark k emits jobs of class classes.get(k-1), with all marks driven by one shared modulating chain. Mirrors MATLAB Source.setMarkedArrival.
      Parameters:
      mmap - the shared marked arrival process (M3A layout)
      classes - the K distinct open classes, ordered by mark index

    • setMarkedArrival

      public void setMarkedArrival(MMAPt mmapt, List<JobClass> classes)
      Binds a time-inhomogeneous marked arrival process with K marks to K open classes.

      Same contract as the MarkedMAP overload: mark k emits jobs of class classes.get(k-1), all marks share one modulating chain, and only the first marked class carries the arrival stream. The matrices vary with the wall clock, which changes nothing about the binding.

      Parameters:
      mmapt - the shared marked schedule
      classes - the K distinct open classes, ordered by mark index

    • setMarkedArrival

      public void setMarkedArrival(MPHt mpht, List<JobClass> classes)
      Binds a time-inhomogeneous marked phase-type process with K marks to K open classes.
      Parameters:
      mpht - the shared marked schedule
      classes - the K distinct open classes, ordered by mark index

    • setMarkedArrival

      public void setMarkedArrival(BMMAPt bmmapt, List<JobClass> classes)
      Binds a BATCH marked time-inhomogeneous process with K marks to K open classes.

      Same contract as every other overload, with one addition that matters downstream: an epoch of a BMMAPt releases a BATCH, and the batch is HOMOGENEOUS in its mark, so all of its jobs enter the class bound to that mark. The batch size comes from the process itself, which is why Source.setArrivalBatch must not also be set on the same class: the two are mutually exclusive by construction, exactly as they are for a BMAP.

      Parameters:
      bmmapt - the shared batch marked schedule
      classes - the K distinct open classes, ordered by mark index

    • clearMarkedArrival

      public void clearMarkedArrival()
      Drop the marked-arrival binding, leaving whatever per-class arrival processes are currently set.

      Used where a transformation replaces the shared marked stream by per-class renewal streams (MAPQN2RENV freezes each modulating phase into its own Exp), after which a struct still advertising markidx would claim a marked arrival the model no longer has.

    • getMarkedProcess

      public Distribution getMarkedProcess()
      Returns:
      the shared marked process bound via setMarkedArrival, or null. It is a MarkedMAP, an MMAPt or an MPHt.

    • getMarkedClasses

      public List<JobClass> getMarkedClasses()
      Returns:
      the classes bound to marks 1..K of the marked process, or null