Author: Tom Boyle

Mandatory waiting times between certain tasks are a common feature of many project schedules.  In construction, the typical example is concrete curing time.  That is the time interval (typically under a week) after a batch of concrete is placed but before it gains sufficient strength to remove/strip the formwork and continue working.  Similar wait times can be required in non-construction projects. Common features of such waiting times are:

• The waiting time is not associated with productive work;
• The waiting time is independent of any Project, Task, or Resource calendar.  That is, it takes place around the clock, independent of weekends and holidays.

Consider a 5-day curing time in a Microsoft Project (MSP) schedule using the default Standard calendar (i.e. 5dx8h Monday-Friday work week).  The curing process always occurs over a mix of working and non-working (night and weekend) time.  Since the number of workdays included in this period varies from three to five depending on the time and day of the week that the concrete placement finishes, it is not possible to specify a fixed curing duration (in Standard-calendar workdays) without introducing an unnecessary delay in the schedule.

Instead, there are four obvious modeling techniques to accurately schedule the curing and follow-on activities:

1. Create a “cure” task with a “5-day” duration and assign a 7-day x 24-hour calendar to the task.
2. Create a “cure” task and assign a duration of 5 “elapsed” days.
3. Don’t create a “cure” task.  Instead model the curing time as a 5-elapsed-day lag between the “place concrete” and “strip forms” tasks.
4. Create a “cure” task with a 5-day duration and assign a modified 7-day weekly calendar to the task.

As shown in the figures, all four techniques can be used to generate the same (early) schedule dates for the project.  Which technique to use depends on a few factors.

•  Within MSP, a “day” is fundamentally defined according to the “hours per day” setting for the project, and any “day” entries are automatically converted to minutes using that setting.  With default settings, one “day” is 8 hours (i.e. 480 minutes).  This can lead to confusion when calendars are changed or assigned without taking the setting into account.  For example, when a 24-hour calendar is assigned to a 3-day-duration task in a project with default (i.e. 8 hours/day) settings, then the task will finish in 24 hours (i.e. 1 calendar day).   Under the same conditions, a curing time of 5 calendar days (i.e. 120 hours) would require a specified task “duration” of 120/8 = 15 days.  To minimize such confusion, it is a good practice to specify durations in hours when 24-hour calendars are applied, as shown in the figure.
• For most purposes, assigning an “elapsed days” duration is functionally equivalent to applying a 24-hour calendar to the task and making the necessary duration adjustments.  This can reduce confusion associated with the hours per day setting.  The two techniques yield identical results in the example.
•  Using an elapsed-lag instead of a dedicated task is functionally simple to implement, and many project schedulers routinely use this approach.  Nevertheless, lags are generally discouraged or prohibited by some scheduling specifications and recommended practices for good reasons.  Chiefly, lags can substantially affect schedule dates while remaining relatively invisible on typical schedule documents – this makes them easy to abuse for date-manipulation.  In addition, unlike tasks, lags are not easily incorporated into external algorithms for evaluation or manipulation of project schedules – e.g. for risk simulation. This can substantially degrade the value of such algorithms.
• Total Slack calculations are substantially complicated by the impacts of multiple calendars (including the use of elapsed durations).  Since MSP relies solely on Total Slack to identify “Critical” tasks, the true Critical Path for the project can be inadequately described for any of these techniques.  For example, when the curing time finishes at the end of a workday in the middle of the work week, the “cure” task (on a 24-hour calendar) possesses 15 hours of Total Slack – MSP therefore excludes it from the Critical Path.  If instead of a 24-hour calendar, a modified (i.e. 7d x 8h, no-weekend) calendar is applied to the curing task, then the positive Total Slack is eliminated in this case, and the Critical Path is correct.  (This is shown at the top of the figure below.)  Unfortunately, the modified calendar is no better than the others if the curing time finishes on the weekend.  The 1 day of Total Slack causes the Critical Path to be truncated.  (See the lower half of the figure below.) 

Unfortunately, the only out-of-the-box method to ensure that the entire critical path is captured is to raise the Total Slack threshold from the default value (zero) to some number that is judged high enough to capture all the truly critical tasks. I have found such an approach unsatisfactory for a variety of reasons.  In any case, the true Critical Path – i.e. the driving logical path to project completion – remains obscured.

Fortunately, the Longest Path algorithm in BPC Logic Filter is indifferent to which modeling approach is used.  As shown in the figure below, the driving logical paths are correctly identified for each case.  (The number to the right of each bar is the task’s path relative float with respect to the project completion task – zero for the longest path.  BPC Logic Filter typically depicts logical driving paths with a dark red bar.)

BPC Logic Filter – an add-in for Microsoft Project (desktop) – includes an advanced Logic Inspector feature to greatly simplify the examination and navigation of logic-driven schedule activities.

When building or managing a complex project schedule, it’s often necessary to examine the logical relationships between tasks for a variety of reasons.  Particular questions for any given task include:

1. What other tasks must finish (or start) before this task may start (or finish)? (i.e. what are its predecessors and how are they related?)
2. Of all the task’s predecessors, which ones are actually controlling the scheduled dates for this task? – i.e. what are its driving predecessors?
3. For the task’s non-driving predecessors, how much may each be allowed to slip before it becomes driving (for this task)? – i.e. what is the relative float?
4. a)What other tasks must wait for this task to finish (or start) before they can proceed? – i.e. what are its successors?  b)Which successors are driven? c)How much relative float exists?

For users of Microsoft Project (MSP), questions 1 and 4a are most easily answered using the “Predecessors and Successors” view of one of the Task Forms in the lower pane.  For simple schedules, question 2 can be answered by the “Predecessors” list of the Task Inspector pane.  For more complex schedules – and for all other questions – the user must visually cross-reference the scheduled dates of the various linked tasks from several views, estimating relative floats and identifying driving relationships.  This can be time consuming and error prone.  Beginning with the 2013 version, MSP provides “Task Path” bar styles, which visually identify driving and non-driving predecessor and successor paths (i.e. logically connected task chains) of any selected task on the bar chart.  These can be difficult to read, however, when the project logic is complex.

BPC Logic Filter has always answered these questions on the way to visualizing logic flow through a schedule, and several of the tracer analyses can be easily customized to examine only a single task and its links.  Since the tracers generally apply a custom filter to the schedule, however, the time to examine a single task could become unwieldy for a very large project.

The native MSP predecessor and successor tables provide only limited information: ID, Name, Type, and Lag – all sorted according to the order the links were initially created.  Here they are shown as part of the Task Details Form.  Further examination of any linked task can be achieved by double-clicking an entry in the Predecessor or Successor list to open the corresponding Task Information dialog.

In the LLI Edition of  BPC Logic Filter, clicking the Logic Inspector button creates two new floating windows that summarize logic-related information about the selected task as well as its predecessor and successor tasks.

Logic-related properties for the selected task – remaining duration, total slack, constraints, deadlines, scheduled dates, resources, and calendar – are included for reference above each table.  Colored highlighting and other indicators are used to emphasize properties with notable influence or relevance to the current schedule.  E.g. summary or inactive status, effective constraints, violated constraints and deadlines, actualized dates, and leveled resources.

In contrast to the native forms, Logic Inspector provides a richer relationship table, including scheduled dates (with Actual indicators), % complete, total slack, and two user-selected fields for each predecessor and successor task.  Inactive tasks (in MS Project Pro 2010+) are also highlighted gray.  The scroll and fix buttons allow dynamic resizing and other controls of window appearance.  In the LLI Edition, the predecessor and successor tasks are ordered the same as in the native lists, which generally reflect the sequence in which the relationships have been added to the model.

Most importantly, the JUMP button allows logic-based navigation forward and backward through the schedule network one task at a time.  Jumping to another task using the button automatically updates the predecessor and successor forms.  [See also Video – Inspect and Jump through Network Logic Links Using BPC Logic Filter – LLI Edition]

While the LLI (for Limited Logic Inspector) Edition of BPC Logic Filter is aimed at schedulers looking to quickly inspect and jump through relationships, the STD Edition adds robust analysis and reporting of driving logic in the schedule.  Thus, the Logic Inspector of the STD Edition also analyzes and sorts relationships on the basis of driving logic flow.

As a result, driving logic relationships are highlighted yellow and shown at the top of each list.  The first of these becomes the default target for the Jump button, allowing quick navigation through driving logic paths.  The relationships that are furthest from driving are shown at the bottom.  (As a corollary to this, Inactive tasks in MSP 2010 are relegated to the bottom of the list, while Inactive tasks in later versions may sometimes be shown as driving or near driving, depending on their dates.)  The Std Edition also allows display of MSP’s internal “driving/driven” flag for each relationship: the basis of the corresponding Task Path bar styles as well as the Predecessors portion of the Task Inspector pane.  These internal flags are sometimes incorrect, leading to a false “Driving Predecessors” Task Path.    Finally, several types of hierarchical driving logic can be added to the Logic Inspector Windows.

The Std Edition also adds the ability to Jump to and/or through tasks that are hidden in the current view and to build a custom task filter using Jump.

The Pro version adds extensive capabilities for analysis of relationship and path relative float.  Within the Logic Inspector, this means additional columns to display up to four different types of relative float for each relationship.  More importantly, late-driving and bi-directional-driving relationships are highlighted by default.  These are particularly useful for prioritizing multiple driven successors of a particular task.  In the example, this option leads to a re-sorting of the successor tasks, with one of the two driven successors from the Std Edition now being flagged and prioritized.  (This successor task, 1439, controls the late-dates of the selected task; the relationship is driving in both directions.)

Since implementation, I’ve found Logic Inspector to be an invaluable – and fast – complement to the rest of the features in BPC Logic Filter.  The two new windows are passive readers of existing project data; they are not for adding, removing, or modifying relationships.  MSP already provides a number of different approaches there.

Here’s another, older video showing an earlier, less-capable version of the feature in action.

Using Logic Inspector to examine resource drivers is addressed in another post.

Regular users of BPC Logic Filter will have noticed some modest changes with the recent release of version 1.2.  The ribbon has been slightly revised, and two new buttons have been added: “Project Logic Checker” and “Logic Quick Check”. The second is essentially an abbreviated version of the first.

The Project Logic Checker examines every task in the project and flags the following logic issues for closer review or action:

Task Definition Issues

• Manually-scheduled tasks (By definition, these are incompatible with logic-driven scheduling.)
• Inactive tasks (In MSP 2010, these are essentially ignored. In MSP 2013+ they are essentially included in the schedule calculations as zero-duration tasks.)
• External tasks and external links (Scheduling of tasks with external links can change depending on whether the source schedules of the external tasks are available and open.)
• (Hammock) tasks made with OLE links (OLE links typically impose persistent logic constraints.)
• Summary tasks with Logic (Hierarchical logic can override precedence logic in the schedule calculations and cause confusion.)
• Tasks with Logic on Parent Summaries  (These tasks may be controlled by non-precedence logic.)
• Constraints and Deadlines (“Must Start/Finish On” constraints are “Hard” constraints since they can override logic.  In addition, “Start/Finish No Later Than” constraints are included as “Hard” constraints ONLY when “Tasks will always honor their constraint dates” is checked (i.e. the default value).  These are always “Hard” constraints according to 2009 DCMA 14-Point Assessment guidance.)
• Duplicate Task Names (Duplicate task names force reliance on a task’s outline hierarchy for recognition of task scope.  Development and analysis of the project logic then becomes inefficient or impossible.)    

TASK Relationship ISSUES

• Missing logic; that is “Open Ends,” including Dangling Starts and Finishes.  (Schedules with these conditions are unreliable.)
• Relationship Lags and Leads (i.e. negative lags) that that are excessive with respect to the associated task durations (Ideally, logic driven schedules use explicit tasks for all time-consuming activities.  Substantial leads and lags are incompatible with schedule risk assessment and are generally considered poor practice.)
• Relationships that are not Finish-to-Start (Some scheduling philosophies mandate only Finish-to-Start relationships.)
• Relationships that are Start-to-Finish (These relationships are extremely rare in actual project schedules, but they are often used incorrectly.)
• Merge Points in the schedule (i.e. tasks with a high number of immediate predecessors)
• Reverse Logic Flow through the task’s duration; i.e. shortening the task delays the successor, and lengthening the task may accelerate the successor.  (See this entry).
• Neutral Logic Flow through the task’s duration; i.e. shortening or lengthening the task has no impact on the successor.
• Links to inactive tasks  (Depending on the MSP version being used, such links can alter the schedule unexpectedly.)

Task Update ISSUES

• Invalid Dates, including incomplete work in the past and completed work in the future (with respect to the Status Date)
• Splits
• Out-of-sequence progress
• Tasks that have missed their target/baseline finish date (as of the status date.)

Other TASK ISSUES

• Overlong task durations
• False Milestones (i.e. “Milestones” with non-zero durations)
• Excessive or negative values for Total Slack

Users can include or exclude any desired checks from the analysis – or adjust associated thresholds – using the Checker Preferences.

The tool automatically restricts the view to show only tasks with logic issues, then it presents an output form that a) summarizes the analysis, and b) allows the user to dynamically modify the filter for pinpoint focus.

For example, here is a highly summarized, ~3300-task, proposed recovery schedule for a troubled international construction project. The Settings window confirms that the logic checker will examine most non-resource-related issues but will ignore the long-duration and high-slack checks for now.

Running the Project Logic Checker identifies and presents over 1500 tasks with logic issues (perhaps a hint to the source of the project’s “troubles.”) The user can then use the output form to reduce or expand the view.

Here’s a close-up of the output/filter form, slightly improved from the one shown in the other figures:

For example, by un-checking all but the Dangling Start box and then clicking filter, I can choose to see only the tasks with Dangling Starts, i.e. tasks with predecessors but without start-predecessors.

Then, I can check only the False Milestones box to see – and correct – the 17 tasks that are coded as milestones but possess a non-zero duration.

Of course, if I’m only interested in one issue – Logic on Summary Tasks for example, than I can begin by excluding all the other issues from the analysis. The result is a (slightly) less cluttered picture.  This one highlights the four summary tasks with logic and the forty-four subtasks that are (or may be) affected.

The dynamic re-filtering requires full data persistence (in the general settings), and the bar labeling only works if “Re-color Bars” is selected (in the bar settings).

For schedulers and schedule reviewers, the new Project Logic Checker provides an action-focused basic schedule health check functionality that can be leveraged off the various logic tracers included in the tool.  There is no fancy dashboard and no pass/fail metrics based on odd ratios.  For now I think I prefer it that way.