User Interface

Basic Modeling and Constraint

Advanced Modeling and Constraint

Scheduling Rules

Scheduling System Integration




FLEXSCHE GP Advanced Options




FLEXSCHE Communicator

Product Configurations and Prices

Information for Developers



New Features of Each Version

New Features of Version 16

New Features of Version 15

New Features of Version 14

FLEXSCHE - production scheduler and production planning > Products > FLEXSCHE Version 15 New Features

New functions added in FLEXSCHE Version 15

FLEXSCHE Version 15.0 was released on June 12, 2015. Many functions are newly added or improved. Here are some major ones. (Differences from Version 14.0)

Signboard rows

Signboard rows are the newly added time series chart rows. Currently four types of signboard rows are implemented: resource signboard rows, item signboard rows, order signboard rows, and process signboard rows. They can be utilized as parts to configure the charts freely such as having them as measures to bundle the time series charts by hierarchy and show them in an organized manner or displaying any information.

The contents can be displayed on the signboard are the following four types.

String display
The format of a string to be displayed on a chart row's body part can be specified. Strings are displayed on the same positions even if the chart is scrolled horizontally.
Values to be displayed in cells can freely be defined with expressions.
*1 With this specification, values are calculated in real time while drawing a chart. If the volume of calculations is too big and the drawing load is too high, please use data cubes mentioned in the next section.
Data cube [FLEXSCHE Analyzer is required]
Values of data cubes that are generated with FLEXSCHE Analyzer in advance are displayed.
MPS data [FLEXSCHE d-MPS is required] *Item signboard rows only
Values of any field of FLEXSCHE d-MPS data (such as shipping demand quantity, request quantity) are displayed.

On the next screen, "String display" item signboard (1) by product is shown bundling the lower hierarchies, and indicates the sum of the number of orders and order quantities included. Under that signboard, "Expression" item signboard ((2)) that displays the number of orders whose due time is a day of corresponding columns and order Gantt charts for manufacturing the product are listed.

As the background color can be decided for each cell with expressions, a screen with high visibility can be prepared.

For reference, the expression specified at this "Expression" item signboard is the following.

Order.Records.Select([.Item=$$_object and
  .LatestEndTime.IsInRange( Time.RangeCO( $_time, $_time+#P1D# ) )] ).Count

Parameterizing works

In FLEXSCHE, there are various "work execution" such as scheduling or data input/output. In most cases, it is enough to execute works whose contents are defined in advance, however, for some certain works, targets of works or conditions may need to be specified at each execution time.

In version 15, targets or conditions for a work can be provided as "parameters" at execution time. The followings are the works that can be parameterized.

In order to use this, parameters need to be defined for each definition of works. Entries at execution time can be omitted by setting default values (values or expression) to parameters.

Defined parameters are considered as variables from works, and these variables are referred to in expressions.

When a work is executed, parameter value entries are prompted as necessary. If a parameter type is an object, then the entry can be made by selecting from the list of existing objects. Not only immediate values but expressions can be entered.

FLEXSCHE will allow users to utilize it more finely and flexibly by executing parameterization.


From popup menus on various objects on the FLEXSCHE screen, parameterized works can be executed with the objects that are used as parameter values.

After defining parameterized works in advance, positions that corresponding menus are shown or how to pass parameters can be specified in detail.

Calling parameterized executions

Parameterized works can be executed from the command execution method in the scheduling rule with parameters prepared in advance. It means that various works can be utilized like subroutines with parameters.

Customizing parameter entry form (details are mentioned later)

Parameter entry dialogs are general-purpose, and users may actually find it difficult to use. By using the script template generation tool, special entry forms can be generated automatically at a certain level without programming. If some additional improvements are made to the code, it will provide an environment which can be operated more simply and safely.

Enhancing functions of user interface

[According to resource's operating day] for non-workday settings of charts

Like some facilities can operate even on non-workdays, "non-workday" on charts and "non-operating time" on calendars are not linked, and they are managed separately in FLEXSCHE.

However, when a day on which resources don't operate needs to be defined as a "non-workday" on a chart, it needs to be set on both the chart and the calendar previously.

In order to avoid such a redundancy, non-workdays on charts can be set according to certain resources' operating days.

Specifying the first day of week or chart rows

Previously, it is fixed that the first day is Sunday for weekly display and the first day of month for monthly display, but now the first day of week (month) can be specified for weekly (monthly) display of charts.

Connection lines of order Gantt for bundling operation graphs

When the same operation graph code is specified to multiple orders, they can be displayed on one order Gantt chart row, and now connection lines are displayed for all orders shown in that manner.

Enhancing functions of the auto row composition - recurrence specification and "job Gantt chart" template

Rows can be composed recursively with the auto row composition.

For example, it is easily realized that an inventory chart row is displayed for an item group, and an inventory chart row for an item which belongs to the item group is displayed as a lower level, and another inventory chart row for an item which belongs to the item group is displayed as a lower level, and so on.

With this recursive work, job Gantt charts can be generated by the auto row composition. A new template for that is also added.

Enhancing functions of the auto row composition - property value settings

Values can be set to properties of charts or chart rows during the auto row composition.

By utilizing this function, for example, if settings are configured to refer to properties of a chart and highlight certain operations, it is possible to switch targets to be highlighted and compose rows automatically every time.

Enhancing functions of FLEXSCHE Analyzer

Speeding up evaluation data generation

Internal processes and memory structures are improved, and data generation for data cube and data set is speeded up significantly. With the sample data ([GP Sample] 100,000 operations), it takes about 8 seconds to generate data cubes for radar charts in Version 14.0, but it is shorten to about 2.5 seconds in Version 15.0. (CPU: Core i7 3820, RAM: 16GB)

Stacked graph

Stacked bar graph and stacked line (area) graph are added to the types of Analyzer graphs. The contents of the structure can be expressed intuitively.

Example: operating time by resource for each product item
Example: weekly operating time by item

Enhancing functions of radar charts

Filtering for tally items
As common filters for the entire system, the filters can be used to narrow down objects only to the ones planned for a certain year and month, or to tally operations only which are planned on certain resources. It is also possible to filter by item or use individual filters.
Allowing to subdivide tally items
For example, by dividing a tally item "average working time" into two items and setting filters to each, they can be like "average working time for Product A" and "average working time for Product B," and radar charts will have more output items.

Filtering for graph definition axes

Now filters are available for components of definition axes (layer value), and it is possible to "eliminate components with no output value" on the axis.

Since the filtering is available at graph generation, it is no longer necessary to regenerate data cubes according to the graph. Graphs with many variations can be generated from one data cube.

Enhancing data cube viewer

Displaying all values at once
Now all field values can be displayed at once. When "--- All ---" is selected at the value of the tool bar, rows of all fields are added for each element.
Displaying the dimension information other than vertical and horizontal axes on the tool bar
Dimension values other than vertical and horizontal axes can be displayed in the new version. Tallied values can be referred to from various aspects by switching the values.
Specifying text and background colors
Text and background colors can freely be set. For example, cells with a certain value or above can be highlighted by field. In the following example, the background color is red for the cells whose on-time delivery rate is 50% or less, and blue for the cells which on-time delivery rate is 100%.
Hiding rows and columns whose values are not specified
Rows and columns whose values are not specified can be hidden in the new version. Only the necessary information can be displayed while hiding the rows and columns with no tallied value because of such as holidays.

Enhancing functions of FLEXSCHE Editor

Importing style settings

Style settings can be imported in the new version. Styles which are used in the other projects can be selected and incorporated so that the settings don't need to be redone from scratch.

Adding field formats

The format of display strings of cells can be configured in the new version. For example, booleans can be displayed with circle and cross icons, or the number of digits after the decimal point of real number values can be specified.

Simple filters for tables

Displayed records can be filtered with values of certain fields. Previously, filter settings needed to be added from configuration screens in order to filter records, but now filtering can be executed easily with a right-click on a cell.

Adding new records all together

New rows can be added as many as specified all together. For newly added rows, records can be added quickly by using copy and paste or autofill functions in the new version.

Enhancing functions of scheduling

Enhancing order pegging

The advanced option "automatic order pegging" is enhanced. Now by-products and gaps of split operations can be pegged automatically. Also, pegging relations can be specified on the operation connection table.

Replenishment order codes by expressions

In the "generate replenishment orders method" which detects future inadequate inventories and generates replenishment orders, codes of replenishment orders can be specified by expressions flexibly.

Enhancing expression related things

Adding comma (,) operator to takt expression

Comma (,) operator is newly added. Previously, declarations and usages of local variables were written in one sentence and it was not easy to read, but now expressions can be described in more understandable ways such as separating the declarations and usages.


($x := .LinkQty(LinkKey.Input)) > 50
  and ($y := .LinkQty(LinkKey.Output)) < 10
  ? $x + $y : $x - $y
$x := .LinkQty(LinkKey.Input),
$y := .LinkQty(LinkKey.Output),
$x > 50 and $y < 10 ? $x + $y : $x - $y

Enhancing programming related things (for developers)

New functions such as enhancing script template generation tools, calling various FLEXSCHE functions, and executing takt expressions easily are added as follows. All of them contribute to reduce man-hours in the development of scheduling logics and add-ins.

Enhancing FLEXSCHE Scripting Form

As described at Parameterizing works, parameters can be passed at execution time of various works in the FLEXSCHE.

However, built-in dialogs to enter parameters are general-purpose, and users who just want to make simple entries may find it difficult to use.

Now parameter entry dialogs can be switched freely with FLEXSCHE Scripting Form (FSF) so that simple entries can be made on simple dialogs. The templates for that can easily be generated with the script template generation tool.

[Standard dialog]

For example, just by using a template, [Standard dialog] can be replaced with a screen such as [Special dialog].

This enables more intuitional entry than before.

[Special dialog]

Also, the following functions are enhanced so that parameter entries with FSF can be even simpler.

General-purpose function to execute various works: ExecutableEntity

Functions to execute rules or call various works easily such as EDIF are newly added. FLEXSCHE functions can easily be incorporated into the codes as subroutines.

set entity = gpManager.CreateExecutableEntity( fsProject, _
  "scheduling-rule", “Target GUID" ) 
entity.ParameterValue("resource")="Machine 1" 

For the cases such as executing EDIF or scheduling rules with add-ins, they can be realized with fewer steps than previous versions.

Also, submethods can be registered within the method for calling external method. They can be called from external methods as ExecutableEntity. For example, scheduling can be prepared with scripts without using structuring method.

New way of executing takt expressions

A new function which interprets and executes takt expressions easily from programming codes is added.

By utilizing takt expressions, FLEXSCHE data can easily be handled. For example, data can be extracted without implementing controls such as loops.

When takt expressions don't depend on context or variables, it can be executed with only one step, and even the other cases can also be executed with a few steps like the following.

  1. Preparing expression objects (specifying context type and return value type)
  2. Variable definitions and variable contents settings
  3. Setting takt expression strings
  4. Specifying context objects and executing expressions
' Simple pattern
set orders = sdSpace.Calculate( "Order.Records.Select([.Qty<100])" )

' Pattern with specifying context objects
set order = sdSpace.OrderSet.OrderRecByCode("N0008")
set ex = _
ex.Parse ".Operations.MaxAt([.ProcLevel])" 'Obtaining the upper operation
set topOp = ex.CalculateFor( order ) 

' Pattern with specifying variables
qty = 100
set ex2 = sdSpace.CreateTypedExpression(SDVTypeNone,SDVTypeOrderList)
ex2.DeclareVariable "qty", SDVTypeDouble
ex2.Parse "Order.Records.Select([.Qty<$qty])"
ex2.VariableValue("qty") = qty
set orders = ex2.Calculate