How to Filter for Leads and Lags in Microsoft Project

Here are two macro procedures – LagFilter and LeadFilter – for creating and applying a filter to show only tasks with leads or lags above a certain threshold value.

Using Lags and/or Leads (i.e. negative lags) in Project Scheduling is discouraged for good reasons.  In most project scheduling software it is easy to identify violations by creating a filter to show only tasks with Lags (or Leads) in their predecessor relationships.

In Microsoft Project, lags are indicated by the presence of a “+” character in the task’s predecessors field.  Here is the corresponding filter specification.

You can augment the filter to show tasks on both sides of the lags:

Leads are indicated (in MSP) by the presence of a “-” character in the task’s predecessors field.  Here is the corresponding filter specification (showing both sides of the leads).

Unfortunately, these simple filters don’t help to differentiate high-lag/lead relationships from low-lag/lead relationships.  All of them are lumped together in the same filter.  It is possible to create filters for only the highest lead/lag values using a number of custom fields with complex formulas.  It is far simpler, however, to create the necessary filters using vba/macros.

Here are two macro procedures – LagFilter and LeadFilter – for creating and applying a filter to show only tasks with leads or lags above a certain threshold value.  Choosing a zero-value threshold leads to the same results as the simple filters above.  These procedures work by examining the lag of each predecessor relationship of every task in the active project, comparing it to the specified threshold value.  If the lag is high enough, then the Flag6 field of the task will be set to “yes”.  At the end, a new filter is made and applied.  Note that these macros will overwrite any values in the Flag6 field of your project, unless Flag6 is already controlled by a formula.  (In that case, the macros will crash with an error.)  You may need to edit the macros to select a different Flag field.

[I’ve edited these macros… a) to allow the user to select whether to show both sides or only one side (the successor) of each lead/lag; b) to avoid null filters (i.e. blank screens) by applying the filter only when leads or lags matching the criterion are found; and c) to allow work-time, elapsed-time, or percentage-based lead/lag criteria.]

To apply these, simply copy and paste them into a new module in your Project Visual Basic editor (VBE).  (I typically keep these modules in the global.mpt file, though that practice is not always recommended.)  You can then run them directly from the VBE or from custom buttons that you link to the macros through the  “Customize the Ribbon” dialog.

Sub LagFilter()
'Copyright 15August2018 by T.Boyle PE, PSP
'This macro collects user input and filters the active project to display only tasks
'with dependency lags that are less than the user-specified threshold.  The threshold
'may be specified in units of working time, elapsed time, or percentage.  The filter
'is applied using the Flag6 custom field.
'FLAG6 WILL BE OVER-WRITTEN, IF POSSIBLE,OR THIS MACRO WILL CRASH.

    Dim t As Task
    Dim d As TaskDependency
    Dim LagUnits As String
    Dim ElapsedUnits As Boolean
    Dim LagThreshold As Double
    Dim LagLimit As String
    Dim SuccsOnly As Boolean
    Dim Filtername As String
    Dim Found As Boolean
    
    Found = False
    'Get lag units from user
    LagUnits = (InputBox("Enter lag units (m,h,d,w,mo,em,eh,ed,ew,emo,%):"))
    'Validate units
    Select Case LagUnits
        Case "m", "h", "d", "w", "mo", "em", "eh", "ed", "ew", "emo", "%"
            'Get the filter limit from user
            LagThreshold = (InputBox("Enter lag threshold (" & LagUnits & "):"))
            LagLimit = LagThreshold & " " & LagUnits
            If Left(LagUnits, 1) = "e" Then ElapsedUnits = True
        Case Else
            MsgBox ("Invalid lag units entered (case-sensitive). Aborting.")
            Exit Sub
    End Select
    'Convert units
    Select Case LagUnits
        Case "m"
            'proceed
        Case "h"
            LagThreshold = LagThreshold * 60
        Case "d"
            LagThreshold = LagThreshold * 60 * ActiveProject.HoursPerDay
        Case "w"
            LagThreshold = LagThreshold * 60 * ActiveProject.HoursPerWeek
        Case "mo"
            LagThreshold = LagThreshold * 60 * ActiveProject.HoursPerDay * ActiveProject.DaysPerMonth
        Case "em"
            'proceed
        Case "eh"
            LagThreshold = LagThreshold * 60
        Case "ed"
            LagThreshold = LagThreshold * 60 * 24
        Case "ew"
            LagThreshold = LagThreshold * 60 * 24 * 7
        Case "emo"
            LagThreshold = LagThreshold * 60 * 24 * 30
        Case "%"
            'proceed
    End Select
    
    If MsgBox("Display both Predecessors and Successors?" & vbCrLf & "(""Yes"" shows each lag twice. Default " _
            & "shows Successors Only)", vbQuestion + vbYesNo + vbDefaultButton2, "???") = vbYes Then
        SuccsOnly = False
        Filtername = "HasLagsAboveThreshold"
    Else
        SuccsOnly = True
        Filtername = "HasPredecessorLagsAboveThreshold"
    End If
    
    For Each t In ActiveProject.Tasks
        If Not t Is Nothing Then
            Call ClearT(t)
            For Each d In t.TaskDependencies
                If (d.To = t) Or (SuccsOnly = False) Then
                    If (d.Lag > 0 And LagThreshold = 0) Or (d.Lag >= LagThreshold And LagThreshold > 0) Then
                            If (d.LagType = 19 And LagUnits = "%") Then
                                Call MarkT(t, Found)
                            ElseIf (d.LagType Mod 2 = 1 And (Not ElapsedUnits) And (LagUnits <> "%")) Then
                                Call MarkT(t, Found)
                            ElseIf (d.LagType Mod 2 = 0 And ElapsedUnits) Then
                                Call MarkT(t, Found)
                            End If
                    End If
                End If
            Next d
        End If
    Next t
    
    If Found Then
        FilterEdit Name:=Filtername, TaskFilter:=True, Create:=True, OverwriteExisting:=True, FieldName:="Flag6", _
            Test:="equals", Value:="Yes", ShowInMenu:=True, ShowSummaryTasks:=True
        FilterApply Name:=Filtername
        MsgBox ("Filter applied: " & Filtername & vbCrLf & "Filter Threshold: " & LagLimit)
    Else
        MsgBox ("No lags found above threshold (" & LagLimit & "). No filter applied")
    End If

End Sub

Sub LeadFilter()
'Copyright 15August2018 by T.Boyle PE, PSP
'This macro collects user input and filters the active project to display only tasks
'with dependency leads (i.e. negative lags) that are less than the user-specified threshold.
'The threshold may be specified in units of working time, elapsed time, or percentage.
'The filter is applied using the Flag6 custom field.
'FLAG6 WILL BE OVER-WRITTEN, IF POSSIBLE,OR THIS MACRO WILL CRASH.

    Dim t As Task
    Dim d As TaskDependency
    Dim LeadUnits As String
    Dim ElapsedUnits As Boolean
    Dim LeadThreshold As Double
    Dim LeadLimit As String
    Dim SuccsOnly As Boolean
    Dim Filtername As String
    Dim Found As Boolean
    
    Found = False
    'Get Lead units from user
    LeadUnits = (InputBox("Enter Lead units (m,h,d,w,mo,em,eh,ed,ew,emo,%):"))
    'Validate units
    Select Case LeadUnits
        Case "m", "h", "d", "w", "mo", "em", "eh", "ed", "ew", "emo", "%"
            'Get the filter limit from user
            LeadThreshold = (InputBox("Enter Lead threshold (" & LeadUnits & "):"))
            LeadLimit = LeadThreshold & " " & LeadUnits
            If Left(LeadUnits, 1) = "e" Then ElapsedUnits = True
        Case Else
            MsgBox ("Invalid Lead units entered (case-sensitive). Aborting.")
            Exit Sub
    End Select
    'Convert units
    Select Case LeadUnits
        Case "m"
            'proceed
        Case "h"
            LeadThreshold = LeadThreshold * 60
        Case "d"
            LeadThreshold = LeadThreshold * 60 * ActiveProject.HoursPerDay
        Case "w"
            LeadThreshold = LeadThreshold * 60 * ActiveProject.HoursPerWeek
        Case "mo"
            LeadThreshold = LeadThreshold * 60 * ActiveProject.HoursPerDay * ActiveProject.DaysPerMonth
        Case "em"
            'proceed
        Case "eh"
            LeadThreshold = LeadThreshold * 60
        Case "ed"
            LeadThreshold = LeadThreshold * 60 * 24
        Case "ew"
            LeadThreshold = LeadThreshold * 60 * 24 * 7
        Case "emo"
            LeadThreshold = LeadThreshold * 60 * 24 * 30
        Case "%"
            'proceed
    End Select
    
    If MsgBox("Display both Predecessors and Successors?" & vbCrLf & "(""Yes"" shows each Lead twice. Default " _
            & "shows Successors Only)", vbQuestion + vbYesNo + vbDefaultButton2, "???") = vbYes Then
        SuccsOnly = False
        Filtername = "HasLeadsAboveThreshold"
    Else
        SuccsOnly = True
        Filtername = "HasPredecessorLeadsAboveThreshold"
    End If
    
    For Each t In ActiveProject.Tasks
        If Not t Is Nothing Then
            Call ClearT(t)
            For Each d In t.TaskDependencies
                If (d.To = t) Or (SuccsOnly = False) Then
                    If (d.Lag < 0 And LeadThreshold = 0) Or (d.Lag <= -1 * LeadThreshold And LeadThreshold > 0) Then
                            If (d.LagType = 19 And LeadUnits = "%") Then
                                Call MarkT(t, Found)
                            ElseIf (d.LagType Mod 2 = 1 And (Not ElapsedUnits) And (LeadUnits <> "%")) Then
                                Call MarkT(t, Found)
                            ElseIf (d.LagType Mod 2 = 0 And ElapsedUnits) Then
                                Call MarkT(t, Found)
                            End If
                    End If
                End If
            Next d
        End If
    Next t
    
    If Found Then
        FilterEdit Name:=Filtername, TaskFilter:=True, Create:=True, OverwriteExisting:=True, FieldName:="Flag6", _
            Test:="equals", Value:="Yes", ShowInMenu:=True, ShowSummaryTasks:=True
        FilterApply Name:=Filtername
        MsgBox ("Filter applied: " & Filtername & vbCrLf & "Filter Threshold: " & LeadLimit)
    Else
        MsgBox ("No Leads found above threshold (" & LeadLimit & "). No filter applied")
    End If

End Sub

Sub ClearT(t As Task)
    t.Flag6 = "No"
End Sub
Sub MarkT(ByRef t As Task, ByRef Found As Boolean)
    t.Flag6 = "Yes"
    Found = True
End Sub

Neither the simple filter nor the macro provided here implements the algorithm used by the Project Logic Checker in our BPC Logic Filter Add-In, which incorporates a slightly different premise.  That is: a relationship (or combination of relationships) with (positive or negative) lag may be the most effective and efficient method for modeling the true sequential restraints of the work, but only when the lag represents a relatively small proportion of the durations of the related tasks.  Thus, the Project Logic Checker flags tasks where the relationship lead/lag exceeds a certain percentage of the associated task durations.

BPC Logic Filter in Microsoft Project 2013/2016

During its development, we targeted BPC Logic Filter – our Add-In for analyzing project schedules – for use with Microsoft Project (MSP) 2010.  After all, we developed the Add-In essentially for our own use, and MSP 2010 has been a regular tool for us (in Windows 7 boxes) since its inception.  Our most recent computer purchase brought with it necessary upgrades to 2016 versions of MS Office and MSP, all running the 64-bit flavor on a Windows 10 Workstation.

Now that I’ve had a chance to directly test BPC Logic Filter in an MSP 2016 environment, I must apologize to those users of our software who have suffered in silence with their MSP 2016 (and also MSP 2013) installations.  My initial testing experience with the filter functions was horribly slow, and I was finally able to repeat some crashing behavior – not encountered in MSP 2010 – that had been reported by a lone user.  No wonder the representative feedback from users on MSP 2013 and 2016 has been, love the Task Logic Inspector! (but silent on the other stuff).

With recent updates, we’ve managed to speed up the filter functions while completely eliminating the particular crashing issue.  As a result, with bar-coloring disabled, the new machine can complete a comprehensive Near-Longest Path Filter of a typical ~1000-task schedule in under 8 seconds.  This compares to an 11-second analysis of the same schedule on the old machine; I attribute the improvement primarily to the increased processing speed of the new machine.

Bar-coloring, however, remains sub optimal.  This is already time-consuming – manipulating Gantt bars and bar styles using essentially “foreground” processes.   As a result, the time to generate our comprehensive Near-Longest Path Filter on the old (MSP 2010) machine increases from 11 seconds to 33 seconds when bar-coloring with auto-ranging is selected.  Such an increase is justified by the improved communication that bar coloring allows.  Unfortunately, the time to perform the same task on the new (MSP 2016) machine increased from 8 seconds to 46 seconds, even after our optimizations and adjustments.  I would expect users with slower computers to have much worse experience.  It seems that manipulating graphic display objects involves substantially more processing power in MSP 2016 than in MSP 2010.  This is ironic in light of the general degradation in graphical output beginning with MSP 2013.  Unfortunately, we have not yet found a way around this problem.

Finally, there seems to be a bug in MSP 2016’s handling of the GanttBarFormat method when a) the method originates in a VSTO (Visual Studio Tools for Office) Add-In rather rather than in a native VBA (Visual Basic for Applications) procedure; and b) there is actual progress on the task.  (The GanttBarFormat method is used to apply format exceptions to a particular bar style of a particular task; like right-clicking on a bar and choosing “format bar”.)  Unfortunately, MSP 2016 ignores the selected bar style and applies the exception to the “Task Progress” bar if one exists.  This makes for some odd-looking outputs from our Add-In for schedules showing actual progress.  I’ll have to figure out a way to raise this issue and get it fixed.

Understand the Impact of Calendars on Schedule Slack Calculation in Microsoft Project

The most recent build of BPC Logic Filter includes improved calculation of relative floats for tasks whose Resource Calendars are substantially different from the effective Task and Project Calendars.  While reviewing those improvements, I compiled this summary of the three different Calendar types used in Microsoft Project (MSP) schedules – with particular attention to their use in logic-driven scheduling and Slack calculation.  The summary moves from the simplest (Project Calendar only) to the most complex (combined Task and Resource calendars) case.  The conclusions are based on my own (imperfect) testing in MSP Professional 2010 and 2016 environments, and I’d welcome any corrections.

Dale Howard of Sensei Project Solutions has provided an excellent general examination of Calendars in Microsoft Project.  It may prove useful to review his post before proceeding.

A. Project Calendar

  1. The Project Calendar is used to schedule all tasks in a project IN THE ABSENCE OF OTHER CALENDARS.  When present, Task Calendars supersede all of the Project Calendar’s functions, and Resource Calendars supersede some – but not all – of the Project Calendar’s functions.
  2. Without Task or Resource Calendars, each task’s early start date occurs when all logic constraints have been satisfied and the Project Calendar makes work time available.  The task’s early finish occurs when the assigned duration has been fully expended according to the Project calendar.
  3. Relationship lags are computed according to the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions is the Project Calendar.*
  6. Because only a single calendar is involved in all schedule calculations, Total Slack may be a reliable indicator of Critical Path within a single project schedule.
  7. If two projects with different project calendars are joined together with inter-project dependencies, then the interaction of working periods between linked tasks can cause Total Slack to vary along a single driving logic path.

B. Project Calendar PLUS Resource Calendars

  1. Each Resource possesses a unique Resource Calendar, which is comprised of a Base Calendar with specific modifications/exceptions.  For example, the Base Calendar for all resources in a particular country may include standard weekends and holidays for that country.  These are inherited by the Resource Calendar, while exceptions may be applied for specific Resource vacations.  By default, the Base Calendar is the Project Calendar at the time the resource is created.  An alternate Base Calendar can be assigned afterward.  The Resource Calendar has the same name as the Resource.
  2. When one or more resources are assigned to a task, the task is scheduled according to a) predecessor and successor logic, including lags; and b) the available working times in the Resource Calendars.  The task’s early start date occurs when all logic constraints have been satisfied and at least one assigned resource has available work-time.  The task’s early finish date occurs when the last resource assignment is completed.  For tasks that are not of type “Fixed Duration,” the Duration is the sum of all the intervals (from start to finish) during which at least one resource is working.  Thus, a task with multiple resources (each with a unique calendar) may have a Duration and Start/Finish dates that do not directly correspond to ANY single defined Calendar.  For Fixed-Duration tasks, the Duration is the difference between the early start and early finish as computed using the Project Calendar.  Thus, a Fixed-Duration task with 12-hours of work by a night-shift resource can have a Duration of Zero, based on the Project’s Standard calendar.  During the backward pass, Late dates are established similarly, based on (resource) working-time calendars.
  3. Relationship lags are computed using the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields remains the Project Calendar.  When used in custom Resource fields, the default calendar for these functions is the Resource’s Base Calendar, which is often the Project Calendar.*
  6. Since a resource calendar may delay a task from starting work during an available work period as defined in the Project Calendar, the task’s driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

C. Project Calendar PLUS Task Calendars (No Resource Calendars OR “Ignore Resource Calendars” Selected)

  1. A task calendar may be created and assigned to multiple tasks.  Each Task Calendar is a Base Calendar that may be created by copying and modifying an existing Base Calendar.  (Because it is a base calendar itself, a task calendar does not inherit information from other calendars.)
  2. Task Calendars may be used to refine schedule constraints based on the nature of the tasks being performed.  E.g. seasonal or environmental limitations.  Task Calendars may also be used to represent resource restrictions when no resources have been assigned (e.g. a year-end non-work period for certain tasks in a master/summary schedule.)  When “Ignore Resource Calendars” is checked, then assigned Resources will be compelled to work exactly according to the Task Calendar, possibly violating their own work time availability.
  3. Without effective Resource restrictions, the task’s early start date occurs when all logic constraints have been satisfied and the Task Calendar makes work time available.  The task’s early finish occurs when the assigned duration has been fully expended according to the Task Calendar.
  4. Relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  5. Start Slack, Finish Slack, and Total Slack for each task are computed using the Task Calendar, if it has one, or the Project Calendar.
  6. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields is the Task Calendar, if one exists, or the Project Calendar.*
  7. The interval between a driving predecessor and a driven successor may possess work time according to the predecessor’s calendar but not the successor’s.  The driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

D. Elapsed-Durations

  1. For most practical purposes, specifying a task duration using an “elapsed” unit (edays, for example), is essentially the same as: a) Applying a 24-hour task calendar with “ignore resource calendars” selected; AND b) Assigning a duration value that accounts for the project’s hours-per-day, hours-per-week, and days-per-month settings.  For example, 1 elapsed day is the same as 24 hours or 3 “days” (8-hours each) applied to a 24-hour working calendar.  (Since mixing duration “days” with 24-hour calendars routinely causes confusion, it is good practice to instead specify such durations in hours.)
  2. Any task with an elapsed duration will have the Task Calendar field disabled.  (A stored value may be visible, but it is inactive as long as the duration units are elapsed.)
  3. Since elapsed-duration tasks automatically ignore resource calendars, any assigned Resources will be compelled to work 100% without rest, possibly violating their own work time availability.  Consequently, it’s not a good idea to routinely apply elapsed durations together with resource loading.  Even machines need downtime for maintenance.
  4. Without effective Resource restrictions, the task’s early start date occurs when all logic constraints have been satisfied, period.  The task’s early finish occurs when the elapsed duration has been fully expended.
  5. Non-elapsed relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  6. Start Slack, Finish Slack, and Total Slack for each elapsed-duration task are computed on the basis of elapsed time.
  7. For tasks with elapsed durations, the default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields is the 24-Hour Calendar.*
  8. The interval between an elapsed-duration predecessor and its driven (non-elapsed) successor may possess non-working time according to the successor’s effective calendar (task, resource, or project).  The driving predecessor may possess slack.  Thus, Total Slack can vary along a single driving logic path.

E. Project Calendar PLUS Task Calendars PLUS Resource Calendars (NOT “Ignored”)

If the task’s “Ignore Resource Calendars” box is NOT checked, then:

  1. Each task is scheduled only during work time that is available in BOTH the Task Calendar and the applicable Resource Calendar for each assignment.
  2. The task’s early start date occurs when all logic constraints have been satisfied,  the Task Calendar makes work time available, AND at least one assigned resource has available work time.  The task’s early finish occurs when the last assignment is completed within the combined work time restrictions.
  3. Relationship lags are computed according to the Task Calendar of the successor task, if it has one, or the Project Calendar.
  4. Start Slack, Finish Slack, and Total Slack are computed using the Task Calendar, if any, or the Project Calendar.
  5. The default calendar for ProjDateAdd, ProjDateSub, and ProjDateDiff functions used in custom Task fields remains the Task Calendar, if one exists, or the Project Calendar.  When used in custom Resource fields, the default calendar for these functions remains the Resource’s Base Calendar.*
  6. As a result of either resource-delays or task calendar mismatches, Total Slack can vary along a single driving logic path.

*  Note: The comparable Project VBA functions (Application.) DateAdd, DateSubtract, and DateDifference always default to the Project Calendar of the ActiveProject.

F. Slack and Calendars Re-Cap

In general, the Project Calendar of a fully resource-loaded project schedule plays no direct role in role in the calculation of the Early and Late dates, but it plays a primary role in MSP’s subsequent calculation of Slack based on those dates.  Conversely, although resource calendars can fundamentally alter the logic-driven dates of a typical resource-loaded task, MSP ignores them in the Slack calculation.  As a consequence, both the calculation and interpretation of Total Slack in a resource-loaded schedule become greatly simplified, if sometimes misleading.

Alternately, whenever a task calendar is applied (with or without resource-loading), that same calendar is used to calculate the Dates AND the Slack.  Consequently, the calculation of Total Slack seems to be more correct and can be equally simple to calculate (using a Task- rather than Project-Calendar), but its interpretation can be confusing.

For example, the chart below illustrates two alternate methods for modeling a calendar-restricted Board-approval activity in a project schedule.  The Board meets on the third Wednesday of each month for, among other items, approving key project commitments.  If the project team fails to prepare the necessary documents in sufficient time for the meeting, then the approvals (and follow-on tasks) will be delayed by a month.  (This is exactly how project governance works in some organizations.)  For this example, the board-approval, preparation, and follow-up activities are not on the Critical Path for the project, finishing up about a month before the project’s finish milestone.

In the first case, the restraint on the Board Approval task is modeled by applying a Task Calendar with only the third Wednesday of each month as a working day.  In the second case, the restraint is modeled by loading a “Board Availability” resource whose Base Calendar is exactly the same as the Task Calendar applied above.  Early Dates and Late Dates for all tasks are identical for both cases, and the only difference is the Total Slack of the Board Approval task.  This value is computed as the difference between the task’s Late Finish (17Apr’19) and its Early Finish (20Mar’19).  When the restraint is applied using the Task Calendar, the Total Slack of 1 day reflects the fact that one Board Meeting/availability day exists between the two dates.  With the restraint applied using a resource calendar, the Project Calendar applies, and Total Slack of 20 days reflects the twenty weekdays between the two dates.

In either case, the example also illustrates the difficulty of identifying logic paths using Total Slack alone.

G. A Note on the Resource Availability Grid

The Resource Availability Grid (part of the Resource Information dialog window) is sometimes seen as an alternate/supplemental method for specifying resource working time.  Unlike the Resource Calendar, however, Resource Availability entries do not participate in the working-time definitions that drive the scheduling calculations.  Rather, they serve as a time-phased version of the Max Units property for identifying over-allocation of resources.  Once flagged, MSP can attempt to resolve these over-allocations through automatic resource-leveling.  This is distinct from logic-driven scheduling.

 

Extract the Logic Plan Inside Your Schedule – Project Virtual Conference 2018

In June 2018 I had the privilege of speaking at the Project Virtual Conference 2018.  The event was very well done and was supported by a number of key sponsors in the Microsoft Project consulting world.  (Surprisingly, Microsoft was not among them.)  I hope to have a chance to return in future years.  My session focused on using BPC Logic Filter to examine schedule plans.  The 55-minute session was recorded (link below).

There are a few lines I’d like to have back, especially the repeated reference to DCMA (the Defense Contract Management Agency) as the Defense Contract Management Association.  Maybe I conflated DCMA with the NDIA (the National Defense Industry Association) to create this new fiction….  Both have issued comprehensive guides related to project schedule quality, and the Planning and Scheduling Excellence Guide (PASEG) from NDIA is one of the better ones out there.

Don’t Confuse Critical Tasks with Critical Paths in Project Schedules

The “Critical” activity flags in modern project schedules often do not correctly identify the true Critical Paths.  Blind acceptance of such “Critical” flags to identify the Critical Path inhibits proper understanding, communication, and management of project schedule performance – and gives CPM a bad rap.

Basic CPM Concepts (in General):

The “Critical Path Method” (CPM) – a ~60-year-old algorithm of fairly straightforward arithmetic – lies at the core of most modern project scheduling tools, and most project managers worthy of the name have been exposed to at least the basic CPM concepts.  Any discussion of the Critical Path must address the underlying conceptual basis:

  1. A CPM project schedule is comprised of all the activities necessary to complete the project’s scope of work.
  2. Activity durations are estimated, and required/planned sequential restraints between activities are identified: e.g. Predecessor task “A” must finish before Successor task “B” can start, and Predecessor task “C” must finish before Successor task “D” can start.  The combination of activities and relationships forms a schedule logic network.  Below is a diagram of a simple schedule logic network, with activities as nodes (blocks) and relationships as arrows.
  3. Logic Relationships.  A logic relationship represents a simple (i.e. one-sided) schedule constraint that is imposed on the successor by the predecessor.  Thus, a finish-to-start (FS) relationship between activities A and B dictates only that the start of activity B may NOT occur before the finish of activity A.  (It does not REQUIRE that B start immediately after A finishes.)  Other relationship types – SS, FF, SF, which were added as part of the Precedence Diagramming Method (PDM) extension of traditional CPM – are similarly interpreted.  E.g. A–>(SS)–>B dictates only that the start of B may not occur before the start of A.  Activities with multiple predecessor relationships must be scheduled to satisfy ALL of them.
  4. Logic Paths. A continuous route through the activities and relationships of the network – connecting an earlier activity to a later one – is called a “logic path.”  Logic paths can be displayed – together or in isolation – to show the sequential plans for executing selected portions of the project.  The simple network shown has only two logic paths between the start and finish milestones: Path 1 = (StartProject) <<A><B>> (FinishProject); and Path 2 = (StartProject) <<C><D>> (FinishProject).  [Experimenting with some shorthand logic notation: “<” = logic connection to activity’s Start; “>” = logic connection to activity’s Finish.]
  5. Schedule Calculations. Schedule dates are calculated using three essential steps:
    • During the Forward Pass, the earliest possible start and finish dates of each activity are computed by considering the aggregated durations of its predecessor paths, beginning from the project start milestone and working forward in time.
    • Assuming an implicit requirement to finish the project as soon as possible, the early finish of the project completion milestone is adopted as its latest allowable finish date. This can be called the Finish Reflection.  (Most CPM summaries ignore this step.  I include it because it is the basis for important concepts and complications to be introduced later.)
    • During the Backward Pass, the latest allowable start and finish dates of each activity are computed by considering the aggregated durations of its successor paths, beginning from the project completion milestone and working backward in time.
  6. Driving and Non-Driving Logic. A logic relationship may be categorized as “Driving” or “Non-Driving” depending on its influence over the Early dates of the successor activity – as calculated during the Forward Pass.  A Driving relationship controls the Early start/finish of the successor; a Non-Driving relationship does not.  In other words, a “Driving” relationship prevents the successor activity from being scheduled any sooner than it is.  A logic path (or path segment) may be categorized as “Driving” (to its terminal activity) when all of its relationships are Driving.  [Such a path is sometimes called a “String.”]
  7. Total Float. In simplified terms, the difference between the early start/finish and late start/finish of each activity is termed the activity’s “Total Float” (or “Total Slack”).  A positive value denotes a finite range of time over which the activity may be allowed to slip without delaying “the project.”  A zero value (i.e. TF=0) indicates that the activity’s early dates and late dates are exactly equal, and any delay from the early dates may delay “the project.”  It is important to remember that Total Float/Slack is nominally computed as a property of each individual activity, not of a particular logic path nor of the project schedule as a whole.  [While computed individually for each activity, the float is not possessed solely by that activity and is in fact shared among all the activities within a driving logic path.  In the absence of certain complicating factors, it is common to refer to a shared float value as a property of that path.]
  8. Critical Path. A project’s Critical Path is the path (i.e. the unique sequence of logically-connected activities and relationships) that determines the earliest possible completion of “the project.”  I prefer to call this the “driving path to project completion.”  Other logic paths through the schedule are considered “Near-Critical Paths” if they are at risk of becoming the Critical Path – possibly extending the project – at some time during project execution.  In our simple project shown below, the Critical Path is Path 1, whose total duration of 4 weeks (20 days on a standard 5dx8h calendar) controls the Early Finish of the completion milestone.

    In unconstrained schedule models incorporating only a single calendar (and without other complicating factors), the Finish Reflection causes the activities on the Critical Path to have Late dates equal to their Early dates; i.e. Total Float = 0.  Consequently, any delay of a Critical-path activity cascades directly to delay of the project completion.  The Near-Critical Paths are then defined as those paths whose activities have Total Float more than zero but less than some threshold.  In traditional “Critical Path Management,” activities that are NOT on or near the Critical Path may be allowed to slip, while management attention and resources are devoted to protecting those activities that are on or near the Critical Path.  More importantly, acceleration of the project completion (or recovery from a prior delay) may only be accomplished by first addressing the activities and relationships on the Critical Path.

[Note: The definition of “Critical Path” has evolved with the introduction of new concepts and scheduling methods over the years.  The earliest definitions – based on robust schedule networks containing only finish-to-start relationships, with no constraints, no lags, and no calendars – were characterized by the following common elements:

  • It contained those activities that determined the overall duration of the project (i.e. the “driving path to project completion.”)
  • It contained those activities that, if allowed to slip, would extend the duration of the project (hence the word “Critical”).
  • A delay of any of its activities would be directly transmitted to an equal (matching) delay of the project completion.
  • Its activities comprised the “longest path” through the schedule network. That is, the arithmetic sum of their durations was greater than the corresponding sum for any other path in the network.
  • After completion of the forward and backward passes, its activities could be readily identified by a shared Total Float value of zero.  Thus TF=0 became the primary criterion for identifying the Critical Path.

With the incorporation of non-FS relationships, early and late constraints, lags, and calendars in modern project scheduling software, these observations are no longer consistent with each other nor sometimes with a single logic path.  Some of these inconsistencies are addressed later in this article.  Only the first of these defining elements (“driving path to project completion”) has been generally retained in recent scheduling standards and guidance publications, though implied equivalence of the others continues to persist among some professionals.]

Software – the Critical Activities / Critical Tasks:

The basic element of modern project schedules is the activity or task.  In most scheduling tools, logic paths are not explicitly defined.  Nevertheless, the obvious importance of the Critical Path dictates that software packages attempt to identify it – indirectly– by marking activities that meet certain criteria with the “Critical” flag.  Activities with the “Critical” flag are called “Critical Activities” (or “Critical Tasks”) and are typically highlighted red in network and bar-chart graphics.

Applying Critical Flags using Default Total Float Criteria

The simplest criterion for flagging a task as “Critical” is TF=0.  This is the primary method that most new schedulers seem familiar with, and it is the default criterion for some software packages.  As noted earlier, this criterion is applicable to schedules with no constraints and only a single calendar.  In Microsoft Project (MSP) and Oracle Primavera P6 (P6), the default “Critical” flag criterion is TF<=0, and the threshold value of “0” can be adjusted.  The differences between these criteria and the simpler TF=0 criterion are justified by four primary concerns:

  1. Risk Management. Due to the inherent uncertainty of activity duration estimates, the Critical Path of a real-world project schedule – as ultimately executed – often includes an unpredictable mix of activities from the as-scheduled Critical Path and Near-Critical Paths.  In the absence of quantitative schedule risk assessment, it is reasonable to consider all such (potentially-critical-path) activities equally when evaluating project schedule risks.  This purpose is easily served by applying the “Critical” flag to all activities whose Total Float value is less than or equal to some near-critical threshold.
  2. Late Constraints. Overall project completion priorities (and contractual requirements) often lead to the imposition of Deadlines (in MSP), Late Finish Constraints (in MSP and P6), or Project Constraints (in P6).  Such constraints can override the Finish Reflection and cause the Late dates of some activities to be earlier or later than they would be in the absence of the constraints.  As a result, Total Float can vary among the activities on the driving path to project completion.   In a project with multiple constrained milestones, the driving path to only one of them (the most “urgent”) can be expected to have a constant total float value (i.e. the Lowest Total Float.)  Due to intersecting logic paths, Total Float can vary along the driving paths to other constrained milestones.   Applying the “Critical” flag to activities with Total Float less than or equal to the project’s Lowest Total Float marks those activities that are on the driving path to the most urgent constrained milestone in the project.  If a Project Constraint (in P6 only) is applied, the Lowest Total Float value may be greater than zero; without a more urgent constraint, the marked activities then denote the driving path to the final activity in the project.
  3. Negative Float. Late constraints can cause Late dates to precede Early dates for certain activities.  This results in negative values for Total Float/Slack (i.e. TF<0).    In practically all cases, negative Total Float indicates that the activity cannot be scheduled in time to satisfy one or more of the Deadlines or Constraints (though which constraint is violated may not be clear); and some corrective action is necessary.  [*The concept of negative float – and the constraints that create it – were not included in the foundations of CPM and PDM.  Negative float is not universally accepted among scheduling professionals today, and not all scheduling software supports its calculation.]

    Applying the “Critical” flag to all activities with Total Float less than or equal to zero then marks all activities that:

      • Are on the driving path to an unconstrained project completion (i.e. TF=0, controlled by the project’s Finish Reflection); OR
      • Are on the driving path to a constrained project completion or intermediate milestone that is just barely met (i.e. TF=0, controlled by Deadline/Constraint); OR
      • Are on the driving path to project completion where an explicit project completion milestone is violated (i.e. TF<0, controlled by project Deadline/Constraint); OR
      • Are on the driving path to some intermediate activity whose constraint is violated (i.e. TF<0, controlled by intermediate Deadline/Constraint); OR
      • Are on any number of non/near-driving paths to one or more constrained project completion or intermediate milestones, (i.e. TF<0). Though non-driving, these paths must still be shortened (in addition to shortening the driving and nearer-driving paths) to meet the milestones.

     

  4. Working-Time Calendar Effects. When activities with different Calendars are logically connected in a schedule network, the interval between the finish of a predecessor task and the start of its successor may sometimes contain working time for the predecessor but not for the successor.  If this occurs, then a driving logic relationship exists, but the predecessor still has room to slip without delaying any other tasks or the project (i.e. it possesses float.)  Thus, Total Float may vary along a single driving logic path, including the Critical Path.  The amount of this variation depends on the size of potential offsets between calendars: from a few hours (for shift calendar offsets) to a few days (for 5-day and 7-day weekly calendars offsets) to a few months (for seasonal-shutdown calendar offsets).

    Applying the “Critical” flag to all activities with Total Float less than or equal to the largest Calendar-related offset will mark all activities that:

    • Are on the driving path to project completion with TF<=0;
    • Are on the driving path to project completion but with TF>0 (and less than the specified offset);
    • Are NOT on the driving path to project completion but have TF less than the specified offset. These are False Positives.  For these activities, Total Float could be controlled either by the Finish Reflection (TF>=0) or by some other constraint.

Critical Flags and Critical Paths

Unfortunately, applying the “Critical” flag as noted for most of these considerations has one consistent result:  the continuous sequence of activities and relationships constituting a “Critical Path” often remains obscured.  It is disappointing that the majority of project schedulers – using MSP or P6 – continue to issue filtered lists of “Critical” activities as “The Critical Path.”  Much of the time – especially in MSP – they are not.  Even among expert schedulers, there is a persistent habit of declaring Total Float as the sole attribute that defines the Critical Path rather than as a conditional indicator of an activity’s presence on that path.

When an activity is automatically marked “Critical” based on Total Float/Slack, the primary conclusion to be drawn is simply, “this activity has Total Float/Slack that is at or below the threshold value.  That is, there is insufficient working time available between the Early- and Late- Start/Finish dates.”  If Total Float/Slack is less than zero, then one might also conclude, “this activity is scheduled too late to meet one or more of the project’s deadlines/constraints.”  [If automatic resource leveling has been applied, then even these simple conclusions are probably incorrect.]  These are important facts, but a useful management response still requires knowledge of the driving logic path(s) to the specific activities/milestones whose deadlines/constraints are violated – knowledge that Total Float/Slack and its associated “Critical” flag do not always provide.

Workarounds for Total Float Criteria

P6 provides several features, not available out-of-the-box in MSP, for correctly identifying the Critical Path when Total Float Criteria do not.  Specifically:

  1. For Risk Management. P6’s Multiple-Float Path analysis (MFP) allows the identification of successive driving and near-driving paths to specified project completion milestones.  Monitoring progress on these paths is worthwhile for risk management.  I’ve previously written about MFP analysis HERE.  P6 does not support using Float Paths (the output of MFP analysis) as an explicit criterion for the “Critical” activity flag.
  2. For Late Constraints and Negative Float. P6 allows a negative Critical float threshold.  It is possible to set this threshold low enough so that only the “path of lowest total float” is marked as critical.  In the absence of working time calendar effects, this criterion can be effective in identifying the (most) Critical Path.  Thus it is possible to correctly identify the project’s Critical Path when: a) there is only a single constraint on the project; AND b) that constraint coincides with the sole project completion milestone; AND c) that constraint is violated (creating negative float).
    • MSP does not allow a negative Critical float threshold, so correct identification of the Critical Path in a negative float scenario is not possible. All tasks with negative Total Slack are automatically and unavoidably flagged as “Critical.”
    • If the P6 schedule has a Project “Must Finish by” constraint, then the activities on the Critical Path may have positive Total Float. In that case, the lowest-float criterion may be applied (using a positive threshold) to correctly identify the Critical Path.
  3. For Working-Time Calendar Effects. Unlike other project scheduling software, P6 allows the “Critical” activity flag to be assigned on the basis of some criterion other than Total Float – called Longest Path.  The name is misleading, as the method is based on driving logic rather than activity durations.  Any activity that is found on the driving logic path to project completion is flagged as “Critical.”  (The algorithm tracks driving logic backward from the task(s) with the latest early finish in the project.)  The Longest Path criterion ignores the Total Float impacts of multiple calendars and constraints.  While it is effective in identifying the project’s Critical (logic) Path, Longest Path alone is not useful for identifying near-critical paths.  MFP analysis (noted above) is useful for this purpose.  “Longest Path Value ™,” a relative-float metric available in Schedule Analyzer Software (a P6 add-in) also helps to identify near-critical paths in these circumstances.  For a more detailed review, see What is the Longest Path in a Project Schedule?

MSP provides no out-of-the-box solutions to address these weaknesses in Critical Path identification.  Total Float/Slack remains the sole basis for applying the “Critical” flag, yet the impacts of constraints, deadlines, and calendars remain unaddressed.  In MSP 2013 and later versions, the Task Path function does provide a basis for graphically identifying the driving path to a selected completion activity, and this is helpful.  Nevertheless, a logic tracing add-in (like the BPC Logic Filter program that I helped to develop) is necessary to correctly identify the controlling schedule logic – including the true Critical Path – in a complex MSP schedule.

Definitions and Recommended Practices

Defense Contract Management Agency (DCMA – 2009)

DCMA’s in-house training course, Integrated Master Plan/Integrated Master Schedule Basic Analysis (Rev 21Nov09) is the source of the “14-Point Assessment” that – because its explicit “trigger” values are easily converted to Pass/Fail thresholds and red/yellow/green dashboards – is seen as a de-facto industry standard for schedule health assessment.  The course materials contain the following definitions:

(Slide 28) “Critical Path ~ Sequence of discrete work packages that has the longest total duration through an end point.
~ has the least amount of total float
~ cannot be delayed without delaying the completion date of the contract (assuming zero float).”
(Slide 98) “Critical Path – Definition: a sequence of discrete tasks/activities in the network that has the longest total duration through the contract with the least amount of float.
~ A contract’s critical path is made up of those tasks in which a delay of one day on any task along the critical path will cause the project end date to be delayed one day (assuming zero float).
(Slide 99) “The critical path is ‘broken’ whenever there is not a sequence of connected critical path tasks that goes from the first task of the schedule until the last task.  A broken Critical Path is indicative of a defective schedule.” 

These definitions are mostly (though not entirely) consistent with each other.  They do share a common emphasis on the … “Longest”… “Sequence” … with “lowest total float” AND direct transmission of delay from any critical-path task directly to the project’s completion.  Obviously, the reliance on Total Float makes them incompatible with any project schedule that incorporates multiple calendars, late constraints, or resource leveling.

(Slide 97) “Critical Task:  Some tasks possess no float…they are known as critical tasks.
~Any delay to a critical task on the critical path will cause a delay to the project’s end date.”

Unlike most of the later definitions, DCMA’s appears to contemplate the existence of Critical Tasks that are NOT on the Critical Path.  Obviously, the expectation that such Critical Tasks possess “no float” is not compatible with negative-float regimes.

AACE International (2010 & 2018)

AACE International (formerly the Association for the Advancement of Cost Engineering) maintains and regularly updates its Recommended Practice No. 10S-90: Cost Engineering Terminology.  The most recent issue of RP 10S-90 (June 2018) includes the following definitions:

“CRITICAL PATH – The longest continuous chain of activities (may be more than one path) which establishes the minimum overall project duration. A slippage or delay in completion of any activity by one time period will extend final completion  correspondingly. The critical path by definition has no “float.” See also: LONGEST PATH (LP). (June 2007)”

CRITICAL ACTIVITY – An activity on the project’s critical path. A delay to a critical activity causes a corresponding delay in the completion of the project. Although some activities are “critical,” in the dictionary sense, without being on the critical path, this meaning is seldom used in the project context. (June 2007)”

Unfortunately, these definitions fall apart in the presence of multiple calendars, multiple late constraints, or negative total float – when the second and third clauses in both definitions no longer agree with the first.  They appear distinctly out of sync with modern project scheduling practices, and (according to AACE International’s Planning and Scheduling Subcommittee Chair) an update is pending.

AACE International’s RP No. 49R-06, Identifying the Critical Path (last revised in March 2010) instead defines the Critical Path as

the longest logical path through the CPM network and consists of those activities that determine the shortest time for project completion.  Activities within this [group (sic)] or list form a series (or sequence) of logically connected activities that is called the critical path.” 

Aside from the apparently inadvertent omission of a word, I don’t have any problem with this definition.  It is certainly better, in my opinion, than the first.

RP 49R-06 notes the existence of “several accepted methods for determining the critical path” and goes on to describe the four “most frequently used” methods:

  1. Lowest Total Float. This is as I described under Workarounds for Total Float Criteria, above.  Although this method is listed first, the RP spends four pages detailing the issues that make Total Float unreliable as a CP indicator.  As long as the CP is to be defined only with respect to the most urgent constraint in the schedule (including the Finish Reflection) – and there are no Calendar issues –  then this method provides a useful result.
  2. Negative Total Float.  In apparent acquiescence to the limitations of MSP, the RP describes this method by first abandoning the fundamental definition of the Critical Path as a specific logic path.  It then allows the “Critical” classification for any activity that must be accelerated in order to meet an applied deadline or constraint.  Ultimately, the RP attempts to justify this method based solely on certain legal/contractual considerations of concurrent delay.  It is NOT useful for those whose primary interest is timely completion of the project, or a particular part of the project, using Critical Path Management principles.
  3. Longest Path.  This “driving path to project completion” algorithm, as I described above in Workarounds for Total Float Criteria, has been implemented in versions of (Oracle) Primavera software since P3 (2.0b).  It is the preferred method for P6 schedules with constraints and/or multiple activity calendars.  A similar algorithm is included in BPC Logic Filter, our Add-In for Microsoft Project.  While the method is nominally aimed at finding the driving path(s) to the last activity(ies) in the schedule, it can be combined with other techniques (namely a super-long trailing dummy activity) to derive the driving path to any specific activity, e.g. a specific “substantial completion” or “sectional-completion” milestone.
  4. “Longest Path Value.”  This is an expanded method for identifying the driving and near-driving paths to project completion.  The method works by adding up relationship floats leading to a specific substantial completion milestone.  If the aggregate value of these floats along a specific logic path (i.e. “Longest Path Value”) is zero, then that path is identified as the Critical Path.  While the RP suggests that this method can be performed manually (presumably by “click-tracing” through the network of a P6 schedule), manual implementation in complex schedules is tedious and error prone.  As implemented in Schedule Analyzer Software, this method is essentially an improved version of  P6’s Longest Path method (except that the Add-in cannot change the “Critical” flag for activities.)  It is a preferred method in P6 for those possessing the Schedule Analyzer Software.  BPC Logic Filter performs similar analyses – using “Path Relative Float” instead of “Longest Path Value” – for MSP schedules.

While not listed among the “most frequently used” methods, P6’s MFP analysis option is briefly addressed by the RP in the context of identifying near-critical paths.  BPC Logic Filter performs similar analyses for MSP schedules.

None of the four methods described are useful for identifying the Resource Critical Path (or Resource-Constrained Critical Path) of a leveled schedule.

Project Management Institute (PMI-2011)

PMI’s Practice Standard for Scheduling (Second Edition, 2011) explicitly defines the Critical Path as

“Generally, but not always, the sequence of schedule activities determining the duration of the project.  Generally, it is the longest path through the project.  However, a critical path can end, as an example, on a schedule milestone that is in the middle of the schedule model and that has a finish-no-later-than imposed date schedule constraint.” 

Unlike the RP (49R-06) from AACE International, PMI’s Practice Standard provides no meaningful method for quantitatively identifying the activities of the Critical Path (or any logic paths) in a particular schedule model.  In fact, in its description of the Precedence Diagram Method (PDM – the modern version of CPM used by most modern scheduling software) the Practice Standard acknowledges the complicating factors of constraints and multiple calendars but notes that “today’s computerized scheduling applications complete the additional calculations without problems.”  Then it concludes, “In most projects the critical path is no longer a zero float path, as it was in early CPM.”  The Practice Standard goes on to scrupulously avoid any explicit link between Total Float and the Critical Path.  The impact of all this is to just take the software’s word for what’s “Critical” and what isn’t.  That’s not particularly helpful.

Finally, educating senior stakeholders on the subtle difference between “schedule critical” and “critical” is always one of the first issues faced when implementing systematic project management in non-project focused organizations.  The Practice Standard’s several conflicting definitions of Critical Activities tend to confuse rather than clarify this distinction.

U.S. Government Accountability Office (GAO-2015)

The GAO’s Schedule Assessment Guide: Best Practices for Project Schedules (GAO-16-89G, 2015) has been taken to supersede the earlier DCMA internal guidance in many formal uses.  (Nevertheless, the GAO’s decision to discard any formal trigger/threshold values – a good decision in my view – means that the DCMA-based assessments and dashboards remain popular.)  The GAO document contains the following formal definitions:

“Critical path: The longest continuous sequence of activities in a schedule. Defines the program’s earliest completion date or minimum duration.” [With some minor reservations related to meaning of “longest,” I believe this is a good definition.]

“Critical activity: An activity on the critical path. When the network is free of date constraints, critical activities have zero float, and therefore any delay in the critical activity causes the same day-for-day amount of delay in the program forecast finish date.”   [Unfortunately, the caveats after the first clause are insufficient, ignoring the complicating effects of multiple calendars.]

For the most part – and despite the float-independent formal definition above – the Schedule Assessment Guide’s “Best Practices” tend to perpetuate continued reliance on Total Float as the sole indicator of the Critical Path.  In fact, “Best Practice 6: Confirming That the Critical Path Is Valid” does a good job of illustrating the complicating factors of late constraints and multiple calendars, but this review leads essentially to the differentiation of “Critical Path” (based on total float alone) from “longest path” (based on driving logic).  This is a direct contradiction of the formal definition above.  In general, the text appears to be written by a committee comprised of P6 users (with robust driving/Longest Path analysis tools) and MSP users (without such tools.)  Thus, for every “longest path is preferred,” there seems to be an equal and opposite, “the threshold for total float criticality may have to be raised.”  This is silly.

National Defense Industrial Association (NDIA-2016)

The NDIA’s Integrated Program Management Division has maintained a Planning & Scheduling Excellence Guide (PASEG), with Version 3.0 published in 2016.  The PASEG 3.0 includes the following key definitions:

“Critical Path: The longest sequence of tasks from Timenow until the program end. If a task on the critical path slips, the forecasted program end date should slip.” 

“Driving Path(s): The longest sequence of tasks from Timenow to an interim program milestone.  If a task on a Driving Path slips, the forecasted interim program milestone date should slip.”

The second clause of each definition – which presumes a single calendar – is included in the Schedule Analysis chapter but is excluded from the formal definition in Appendix A.  Timenow is effectively the Data Date / Status Date.  The PASEG does not define or mention critical task/activity as distinct from a “task on the critical path.”

The PASEG notes, “Some of the major schedule software tools have the ability to identify and display critical and driving paths. Additionally, there are many options available for add-in/bolt-on tools that work with the schedule software to assist in this analysis.”  [I suppose BPC Logic Filter would be one of the mentioned add-in tools for Microsoft Project.]

The PASEG also mentions some manual methods for identifying critical and driving paths, e.g.:

a. Imposing a temporary, super-aggressive late constraint and grouping/sorting the output (presumably by Total Float and early start.  Though not explicitly mentioned in the method description, Total Float is the key output affected by the imposed constraint.)  Obviously, this method isn’t reliable when more than one calendar is used.

b. Building a custom filter by manually “click-tracing” through driving logic and marking the activities.  This method is most reliable in P6, with some caveats.  It is reliable in MSP only under some fairly restrictive conditions.

In general, these methods are non-prescriptive, though the emphasis on driving logic paths (rather than Total Float) seems clear.

Guild of Project Controls (GPC, “The Guild” – 2018)

The Guild is a relatively young (~2013) international community of project controls practitioners – initially associated with the PlanningPlanet.com web site – whose founding members have assembled a Project Controls Compendium and Reference (GPCCaR).  The GPCCar takes the form (more or less) of an introductory training course on Project Controls, including Planning and Scheduling.  The GPCCaR includes no formal Glossary, Terminology, or Definitions section, so “Critical Path” and “Critical Path Activities” accumulate several slightly varying definitions in the applicable Modules (07-01, 07-7, and 07-8).  In general, “Zero Total Float” and “Critical Path” are used interchangeably, and the complications of multiple calendars and multiple constraints in P6 and MSP are ignored.  This is not a suitable reference for complex projects that are scheduled using these tools.

Recap

  1. A full understanding of driving and non-driving schedule logic paths for major schedule activities is useful for managing and communicating a project execution plan.
  2. The most important logic path in the project schedule is the “Critical Path,” i.e. the driving path to project completion.  Overall acceleration (or recovery) of a project is ONLY made possible by first shortening the Critical Path.  Acceleration of activities that are NOT on the Critical Path yields no corresponding project benefit to project completion.  Multiple Critical Paths may exist.
  3. Some traditional notions of Critical Path path behavior – e.g. Critical Path activities possess no float; slippage or acceleration of Critical Path activities always translates directly to project completion – are not reliable in modern project schedules.
  4. Total Float remains a valuable indicator of an activity’s scheduling flexibility with respect to completion constraints of the project.  An activity with TF=0 may not be allowed to slip if all project completion constraints are to be met.  Activities with TF<0 MUST be accelerated if all the constraints are to be met.
  5. Project scheduling software typically defines individual activities as “Critical” without fully accounting for common complicating factors like multiple constraints and calendars.  As a result, the collection of “Critical” tasks/activities in a complex project schedule often fails to identify a true Critical Path.
  6. A Critical task/activity is best defined (in my opinion) as EITHER:
    1. An activity that resides on the Critical Path; OR
    2. An activity whose delay will lead to unacceptable delay of the Project Completion; OR
    3. An activity whose delay will lead to unacceptable delay of some other constrained activity or milestone.
    4. In general, these conditions are mutually exclusive, and different activities within a single project schedule may satisfy one or more of them.
  7. Professional project managers and schedulers should be careful not to automatically characterize “Critical” tasks (i.e. those with low Total Float) as indicators of a project’s Critical Path when complicating factors are present.

 

Recent Improvements to BPC Logic Filter (Feb 2018)

We developed BPC Logic Filter – our Add-In for Microsoft Project – primarily for our own use, and we continue to make modifications mainly when we see the need.  This entry is intended to highlight several recent improvements that have been specifically made to serve the needs of other users.

Region and Language Adaptability (Jan’18)

As its name implies, BPC Logic Filter creates special views of the project schedule that rely on unique filters and formatting to highlight important, logic-related information.  Until recently, these unique filters and formatting were unavailable to Microsoft Project users with non-English display languages.  In response to specific requests from French-language users of the software, we made substantial changes to the underlying code and settings to account for the ways that filters, views, and Gantt bars work in different languages.  Subsequently, we systematically incorporated several other European languages.  As a result, BPC Logic Filter works without limitations in the default French, German, Italian, Spanish, and Portuguese (Brazilian) languages in addition to English.  [Mar’19 Edit: While the program interface is restricted to English, the group of usable language packs has been expanded to nine, including Russian and Hebrew.  Other Unicode-compliant language packs can be added if requested by specific users.]

User-Selectable Fields in Task Logic Inspector (Feb’18)

As shown in a previous post, the Task Logic Inspector provides a rich table of information concerning predecessor and successor tasks; including dates, progress, slack, calendar, and resources.  The default fields are shown below.  (The resources of the current task are highlighted because the task has been delayed by resource leveling.)

While task calendars and resources can be important for determining the basis of a task’s current schedule dates, they are not present in all schedules.  In most schedules, they provide no value in the table.

Recent versions of BPC Logic Filter have made these last two columns available as user-selectable, optional fields.  Thus, in cases where the Task Calendar or Resources are not important, the user may display other information from the related tasks.  Users can select the two option fields using the pull-down lists in the General Settings.  To keep things compact, the pull-down lists are restricted to the fields contained in the current task table.

Here, the Text3 field (used for a Responsibility code) and the task Work field have been selected.  Typically, this information may be useful for the analyst to evaluate the details of the relationship – or to guide further navigation through the network using the Jump button.

Jumping through Sub-Projects with Task Logic Inspector (Feb’18)

Unlike logic tracing within a standalone project schedule, logic tracing through inter-project links is problematic.  BPC Logic Filter was developed to trace such links as long as the connected projects are linked together in a master-subproject structure.

The vast majority of Microsoft Project schedules encountered in the world – including most projects that we work with from day to day – are in fact standalone, and the Task Logic Inspector was initially developed to meet that need.  When used within linked master-subproject structures, the initial release of Task Logic Inspector would correctly report the logical relationships, but the Jump button did not work across inter-project links.

Some users make extensive use of very large linked master-subproject structures, so recent releases have removed this limitation.  The Jump button now works as intended, selecting and activating the selected predecessor or successor (as long as it is visible in the current view).  Jumping across inter-project links can involve more number-crunching, however, especially if the two related tasks are many rows apart.

The example below is taken from the linked master-subproject structure described in the Introduction to BPC Logic Filter on our website.

 

The Right Way to Construct Level of Effort (LOE) Activities in Primavera P6

This short entry demonstrates why Level of Effort activities in Oracle Primavera P6 should be constructed using predecessor successor relationships only – especially when designating Critical activities using the Longest Path algorithm. 

P6 LOE Activities

Level-of-Effort (LOE) activities in Oracle Primavera P6 project scheduling software are useful for summarizing the schedule dates of other (primary) activities.  They are effectively a replacement for the “hammock” activities that existed in prior versions of Primavera products, including Primavera Project Planner (P3) and SureTrak Project Manager.

In prior software versions, hammocks were constructed by establishing a group of start-controlling activities as SS predecessors and a separate group of finish-controlling activities as FF successors.  To avoid circular logic, the same activity could not be included in both predecessor (i.e. Start) and successor (i.e. Finish) groups.

In P6, LOE activities can be constructed using practically any mix of predecessors and successors, and the help file implies that the two can be used almost interchangeably.  Although the same activity may not be included as both a predecessor and a successor, it MAY be included multiple times (e.g. as both an SS and FF predecessor) in either group.  This allows for more flexibility in modeling activities that are not strictly hammocks.

P6 Help – Level of effort activity

Here’s a portion of the LOE Help topic in P6, which seems indifferent to the types of relationships used in specifying primary activities.

A level of effort activity is similar to but different from a hammock activity.

  • A level of effort activity uses its assigned calendar to summarize its dates. Hammocks are not scheduled using their own calendar.
  • Any type of relationship can be assigned to a level of effort activity. Only a start-to-start and finish-to-finish relationship can be assigned to a hammock activity.
  • A level of effort activity’s duration is calculated from the earliest early start of its predecessors/successors (linked to the start end of the level of effort activity) to the latest early finish of its predecessors/successors (linked to the finish end of the level of effort activity).A hammock activity’s duration is calculated from the earliest early start of its predecessors to the latest early finish of its successor activities.

Problems with LOEs and Longest Path

Despite the increased flexibility afforded by LOE activities in P6 – and its implied indifference to predecessor or successor relationships – many users continue to use SS-predecessors and FF-successors when establishing LOE dates.  This can create issues when the project’s Critical Path is defined using the Longest Path option.

Here is a simple example project comprising a Critical Path of activities A-B-C-D-E-F-G with a side branch of associated activities A1-B1-C1-D1-E1-F1.  The side activities must be completed before the final activity G can start.  All activities are on the same calendar, and there are no constraints or resources.  The corresponding Critical Path, as determined by Total Float (TF=0), is highlighted red on the Gantt Chart.

Critical Path by Total Float

For this simple project, the Critical Path based on Total Float should be identical to the Critical Path based on “Longest Path” – i.e. the “driving path to project completion.”  Unfortunately, this is not the case, as activities A1 (TF=10) and B1 (TF=8) are now included – incorrectly – on the Longest Path.

Critical Path by Longest Path (Driving Logic)

This error is caused by the Level of Effort activity LOE-1, which summarizes the dates of the side activities in Branch 1.  Similar to P3 hammocks, this LOE activity is constructed using SS-predecessors to govern its start and FF-successors to govern its finish.  The resulting dates are correct, but two complications are introduced.

P3 Hammock-Type Relationships
  1. As a rule, P6 marks all relationships to and from LOE activities as “Driving,” even when the relationship does not control any of the LOE’s dates.
  2. The Longest Path algorithm, which traces driving logic backward from the project completion, does not differentiate LOE driving relationships from other driving relationships during the trace.

As a result of these complications, the Longest Path calculation traces driving logic backward from activity F1 through LOE-1 to its two driving predecessors A1 and B1.  The latter two – along with their entire chains of driving predecessor logic, if any – are now included on the Longest Path.  P6 automatically removes the LOE activity and its relationships from the Longest Path (after the backward pass), but the “Critical” flag on its “driving” predecessors remains.

Activities that are incorrectly included on the Longest Path may be identified by first noting those “Critical” activities whose successor relationships are NOT BOTH “Driving” and “Critical.”  Then their “driving” predecessors are traced until either 1) there are no more driving predecessors, or 2) an activity is reached that has a separate successor relationship that is BOTH “Driving” and “Critical,” provided that this successor does not ultimately lead to another incorrect LOE predecessor.  Such an examination can be tedious.

A quicker identification is obtained by re-calculating the schedule using Multiple Float Paths (Free Float option), with no End activity specified.  Unlike the erroneous LP algorithm, MFP analysis correctly truncates the backward trace at LOE activities.  Consequently, the true driving path to project completion (i.e. the correct Longest Path) of our simple project is identified as “Float Path 1,” and activities A1 and B1 are correctly relegated to Float Paths 6 and 5, respectively.

Multiple Float Path (FF)

When analyzing Multiple Float Paths under the Longest Path regime: if a “Critical” activity has a Float Path that is higher than the Float Path of even one non-critical activity (all computed using the Free Float option), then that “Critical” flag may be incorrect.*

[Edit:  Unfortunately, similar symptoms are produced by MFP analysis when P6 incorrectly assigns legitimate members of the Longest Path to much higher Float Path numbers.  See details in Relationship Free Float and Float Paths in Multi-Calendar Projects (P6 MFP Free Float Option).]

Avoiding the Problem

The simplest way to avoid this Longest Path LOE bug is to avoid including a mix of predecessors and successors when specifying the primary references for LOE activities.  That is, use ONLY predecessors or ONLY successors.  Since LOEs are technically inheriting their dates entirely from the primary activities, my initial preference was to use only predecessor relationships in the LOE.

Using Predecessor-Only Relationships

As shown here, the Longest Path of our simple example project is fixed by re-constructing LOE-1 logic using predecessors only.  The two activities that were formerly “FF” successors of the LOE are now “FF” predecessors of the same LOE.  The dates and float calculations are essentially unchanged, but the Longest Path is now correct.

Predecessor-Only Relationships – LOE-1

Sometimes we want to make an LOE activity whose finish corresponds to the finish date of the project.  Creating such an LOE using predecessor-only relationships doesn’t work as intended, however, because P6 picks the new LOE as the starting point of its Longest Path trace during the backward pass.  Thus, our intention to stop logic flow through the LOE is foiled.  In the next figure, this is shown by the new LOE-2 activity, whose finish is determined by the finish milestone (FM) of the project.  Since LOE-2 is the latest-finishing activity with no successors, P6 starts the backward pass with it, ultimately including its non-critical predecessors A1 and B1 (incorrectly) on the Longest Path.

Predecessor-Only Relationships – LOE-2

Using Successor-Only Relationships

In contrast, if LOE-2 is constructed using successor-only relationships, then P6 will never choose it as the starting point of the Longest Path trace.  Moreover, the absence of predecessors will ensure that when P6 does encounter such an LOE during the backward pass, the Longest Path trace will not continue past the LOE.  As shown below, constructing LOE-2 using successor-only relationships leads to dates, float calculations, and Longest Path calculation that are all correct.  This example suggests that successor-only relationships should be the preferred method for specifying LOE activities in P6.*

Successor-Only Relationships – LOE-2

*Thanks to astute reader A Lou Gonzalez, who pointed out the special issue with using predecessor-only relationships to define LOE activities at the project completion date.

Late Cost Curves for LOE Activities

While using predecessors-only to specify LOE activity dates seems to fix the logic-flow issues, it has no effect on another defect of LOE activities.  As Wail Menesi, has described in his LinkedIn Pulse entry,  P6 incorrectly computes the remaining late start dates of certain in-progress LOE activities.  As a consequence, the “Remaining Late” resource distribution for the affected activity is skewed to the left of the data date.  In other words, P6 indicates that certain incomplete work must be completed in the past to avoid delaying the project, even when there is no negative float.  That’s clearly incorrect.  Fortunately, the issue seems to be limited to LOE activities who’s start dates are determined by Finish-to-Start relationships – a relatively rare structure in practice.

P6 Multiple Float Path Analysis – Why Use Free Float Option

In Oracle Primavera P6, Multiple Float Path analysis is useful for identifying and organizing logic paths leading to a selected End activity in a schedule.  If the Driving Logic to the End activity is desired, then the Free Float option should be selected. 

When I wrote about P6’s Multiple Float Path (MFP) analysis here, I suggested using the Free Float option for identifying driving logic paths.  Since then, I’ve encountered more than a few professionals who believe that the Total Float option also identifies driving logic.  This entry provides a simple example illustrating why that is not always the case.

This “Testing Project – MFP”  is a simple project that includes no constraints and only a single calendar (5dx8h).  Both “Longest Path” and “Total Float” criteria lead to the same Critical Path: A-B-C-D-E-FINISH.  There are several non-critical branches from the Critical Path: namely A1, B1, and C1 are successors to A, B, and C respectively.  C1 is the start of the non-critical branch: C1-C2-C3.  It has both A1 and B1 as predecessors, and it is driven by B1.

For this project, it is obvious (and a trivial exercise to demonstrate) that the driving logic path for any Critical Path activity is comprised of its “Critical” predecessors; i.e. those activities that are predecessors of the selected End activity and which have zero Total Float (TF=0).

What if we are primarily interested in the driving logic to an End activity that is NOT on the Critical Path – activity C3 for example?  By simple inspection of the schedule (or by click-tracing from C3 backward through “driving” relationships), it is easy to see that C3’s driving logic path is comprised of the following activities: A-B-B1-C1-C2-C3.  Since Total Float varies along this path (0-0-17-17-17-17), it is clear that driving logic for C3 is not associated with Total Float.

Another way to examine the logic controlling activity C3 is to re-schedule the project while calculating multiple float paths.  MFP analysis examines the predecessor activities leading to a selected End activity (C3 in this case) in order of their logic sequence and assigns each of these (excluding LOE activities) to a numbered Float Path.  Float Path 1 is “the most critical path.”  The analysis stops when the specified number of float paths is reached.  Afterward, organizing the schedule by Float Path and sorting by Float Path Order leads to a clear differentiation of logic sequence paths.  I also routinely filter-out activities without float path assignment and activities with ALAP constraints.  The construction of the various float paths is governed by which float option is selected – either Total Float or Free Float – in the advanced schedule options.

Total Float Option

This is what the P6 Help file says for the Total Float option.

Total Float – Choose this option to identify critical paths based on the total float of activity relationships. To calculate the most critical path, the module first determines which relationship has the most critical total float. Using this relationship as the starting point, the module determines which predecessor and successor activities have the most critical relationship total float, among all possible paths, until an activity is reached that does not have any relationships. The path that contains these activities is the most critical path.

Using the Total Float option and the other parameters shown for our simple project leads to the result shown below.  Float Path 1 is limited to those activities that 1) are predecessors of C3, AND 2) have a Total Float of 0.  According to P6, this is “the most critical path.”  Float Path 2 is comprised of C3’s predecessors (and C3 itself) that have a Total Float of 17.  Float Path 3 comprises the single logical predecessor of C3 with TF = 24.  Thus, float paths appear to correspond to Total Float alone.

[Sep’19 Edit] I’ve recently read the only public foundation document for the Total Float algorithm – originally called “Enhanced” PDM in 2004 – and the observed behavior is as expected according to that algorithm.  Essentially, Float Path 1 is “seeded” by whichever predecessor of C3 has the lowest total float (subject to some tie breakers.)  Once seeded, the path is defined/traced  by “bi-directional driving” relationships from the seed point.  A “bi-directional driving” relationship exists when:

  • The Relationship Total Float equals the total float of the predecessor activity; AND
  • Relationship Successor Free Float = 0. (P6 support docs point to the “most critical” Relationship Successor Total Float here, but I don’t see the difference.)

Subsequent float paths are seeded and traced using the same priorities.

Fundamentally, the algorithm was developed to a) differentiate float-based critical paths and near-critical paths in the presence of multiple calendars; and b) differentiate independent driving logic paths, including multiple critical paths, that share the same total float.  So here in the absence of calendars or parallel critical paths, the alignment of the calculated float paths and total float is exactly as expected.

Clearly, none of the 3 float paths from the Total Float option correspond to the actual Driving Path to activity C3.  Path 1 includes activity C, which although it is on the Project’s Critical Path is NOT on the Driving Path to activity C3.  The actual Driving Path has been split between Float Path 1 and Float Path 2.

Thus, using Total Float option, Float Path 1 – “the most critical path” – comprises those activities that are predecessors of activity C3 and have the lowest total float.  C3’s own driving/controlling logic path is not defined by the float paths assigned.

Free Float Option

This is what the P6 Help file says for the Free Float option.

Free Float – Choose this option to define critical float paths based on longest path. The most critical path will be identical to the critical path that is derived when you choose to define critical activities as Longest Path in the General tab. In a multicalendar project, the longest path is calculated by identifying the activities that have an early finish equal to the latest calculated early finish for the project and tracing all driving relationships for those activities back to the project start date. After the most critical path is identified, the module will calculate the remaining sub-critical paths.

Using the Free Float option and the other parameters shown for our simple project leads to the result shown below.  Float Path 1 exactly corresponds to the known Driving Path to activity C3: i.e. A-B-B1-C1-C2-C3.  Float Path 2 is comprised of activity C only, while Float Path 3 is comprised of activity A1 only.  Float paths clearly have no correspondence to Total Float.

The key decision point in allocating float paths seems to occur at the predecessors to activity C1: i.e. C, A1, and B1.

  • C has an activity Total Float of 0.  The C-C1 relationship has a Relationship Total Float of 20 and a Relationship Free Float of 3.
  • A1 has an activity Total Float of 24.  The A1-C1 relationship has a Relationship Total Float of 24 and a Relationship Free Float of 7.
  • B1 has an activity Total Float of 17.  The B1-C1 relationship has a Relationship Total Float of 17 and a Relationship Free Float of 0.

Although the Help file is essentially silent on the issue, the MFP analysis appears to allocate these predecessor activities to the three float paths on a basis that correlates to Relationship Free Float.  Here, a Relationship Free Float of zero indicates a Driving Relationship.  Successively higher values of relationship free float correspond to less-driving relationships and result in assignment to higher-numbered float paths.

Thus, using Free Float option, Float Path 1 – “the most critical path” – comprises the driving path to the selected end activity.  Higher-numbered float paths correspond to “sub-critical” paths, or to successively less-driving paths to the selected end activity.

[Jul’18 Amendment – Unfortunately, the ordering of these “sub-critical” paths can be counter-intuitive, with true “Longest Path” activities sometimes being relegated to high-numbered float paths.  See Relationship Free Float and Float Paths in Multi-Calendar Projects (P6 MFP Free Float Option).]

Significance of Total Float

The “Critical Path” of a logic driven project schedule is the collection of activities that determine the earliest possible completion date of the project – i.e. the driving logic path to project completion.  In the original Critical Path Method and its variants, the Critical Path was reliably correlated to a Total Float value of zero, and delay (or acceleration) of any Critical Path activity cascaded directly to the project completion milestone.  Near-critical paths were defined by successively higher values of Total Float.  In simple projects, therefore, Total Float is a reliable indicator of the logical association between any given activity and the project’s Completion.

Because of Total Float’s significance in the traditional definition of Critical and Near-Critical Paths, it is easy – but generally incorrect – to presume a logical association between two activities on the basis of their Total Float values.  In the absence of any late constraints, multiple calendars, or resource leveling, then such associations may exist between certain critical or lower-float successors and their higher-float predecessors.  Thus, running MFP analysis using the Total Float option may be expected to reveal driving and near-driving logic when the selected End activity is on the float-defined Critical Path.  As shown in the example above, however, such an analysis does not reveal driving and near-driving logic when the selected End activity is not Critical.

When a project schedule includes multiple calendars, resource leveling, or a late constraint on any activity except the final one, then Total Float becomes unreliable for indicating the driving path to project completion.  Similarly, it becomes less useful for identifying driving and near-driving logic paths to selected activities even when they are on the “Critical Path”.  In projects with multiple calendars and modest progress updates, the float paths defined using the Total Float option can deviate substantially from both the known driving paths and simple Total Float-based paths.  Under these conditions, the Free Float option is almost certain to provide a clearer view of the schedule logic driving an activity, regardless of its criticality.

 

An Alternate Approach to Hammock Tasks in Microsoft Project

This entry describes the basis for hammock-type summary tasks and introduces an alternate method (and UpdateHammocks macro) for creating and maintaining such tasks in Microsoft Project (MSP) schedules.

Hammocks and LOE Tasks

“Hammock”* and “Level of Effort” (LOE) tasks in project schedules provide two similar approaches to summarizing and reporting the overall time consumed by a collection of other tasks.  Typically, hammock or LOE tasks are used to represent the indirect management and other support activities associated with the primary tasks, and they are often loaded with management and other indirect resources.  Hammock and LOE tasks are essentially the same, though minor differences exist in the implementation by different software.  Since hammocks and LOE tasks do not possess any driving logic, they should be excluded from any formal definition of the Critical Path for the project.

* The “hammock” name refers to the simple method of suspending a sleeping net or cloth (i.e. the hammock) between two trees.  When first described in hand-drawn activity-on-arrow (AOA) network diagrams, the time-summarizing activity took the shape of a simple curved line slung between two nodes – i.e. a hammock.

Hammocks in Primavera

Primavera scheduling tools have long provided explicit activity types for specifying hammock or LOE activities.  Primavera Project Planner (P3) and Primavera SureTrak Project Manager, for example, both included specific hammock activity types that would be specially treated in the schedule calculations.  The start dates for a hammock were defined by its Start-Start predecessors; finish dates came from its Finish-Finish successors; the same activity could not be included in both groups.  Oracle’s Primavera P6, a newer application, allows for LOE activities that inherit their dates from the primary tasks that are included in their “predecessors” and “successors” lists.  They are substantially more flexible than P3’s hammocks.  In most respects the scheduling aspects of these LOE activities are similar to the scheduling of summary bars in P6 schedules (and summary tasks in MSP), with the key difference being that there is no need for common hierarchical structure or activity coding of the related primary activities.

Hammocks in Other Tools

Most other major project scheduling tools also have special-purpose hammock task types.  For example, Phoenix Project Manager, Spider Project, and Deltek Open Plan all provide traditional hammock activity types, whose start and finish are defined by specific logical relationships.  Asta PowerProject also includes a “hammock” task whose construction is more like that of an independent summary activity.  That is, it is not necessary to indicate start/finish relationships.  In general, the number of activities being summarized by the hammocks (or LOEs in P6) are not practically limited.

OLE Hammocks in MSP

MSP has never included an explicit Hammock or LOE task type, and since summary tasks do not provide the needed solution in many cases, a subtle method for constructing simple hammock tasks was created.  As described here, the method involves copying the start/finish dates from two primary tasks and using a paste-special command to link these dates to the dates of the “hammock” task.  The resulting “links” – based on common Windows OLE (object linking and embedding) technology rather than explicit logical schedule relationships – remain essentially hidden and cannot be easily described or audited in an MSP schedule.

MSP’s response to changes in the linked dates is similar to its response when dates are entered manually: i.e. it sets an early constraint (SNET or FNET) and adjusts the task duration so that the task spans between the two linked dates.  Unfortunately, even if the links remain stable and updated (which is not guaranteed), the sources of these adjustments remain hidden.

MSP OLE Hammock Issues

In addition to the absence of auditable schedule information, regular users of linked hammocks may have noticed the following issues, which are present in MSP Professional 2010 and later releases:

  1. OLE hammocks are limited to summarizing only two tasks, one task providing the start date and the other providing the finish.  This limitation seems most consistent with the original description of hammocks in AOA networks, but it doesn’t exist in other modern software.  Often the activities being summarized are potentially concurrent, and it is preferred to allow the software to select dates from the group.
  2. MSP does not prevent the assignment of additional logical links or other constraints that may conflict with the OLE links.
  3. Creating new linked hammocks by copying and modifying existing linked hammocks – say as part of a fragnet replication – doesn’t work well. The resulting links may be subject to corruption and won’t update reliably.  The only reliable way to create such links is to copy and paste-link them one-at-a-time.
  4. Even “automatic” updating of links sometimes fails, with repeated pounding of the F9 key having no affect. In these cases, it’s useful to open the Links window, select all the links, and force an update. (To open the window, the “Edit Links” command needs to be available on one of the ribbons.  It can be added through the “customize the ribbon” dialog.)  This tool is absolutely necessary to make OLE hammocks even slightly bearable.
  5. Resource leveling of linked hammocks can result in unintended consequences. Although most of these can be corrected by a forced update of the links, some changes require that the hammock task be reconstructed.  E.g. removing leveling splits.  The safest course is to assign a priority of 1000 to all linked hammock tasks, thereby exempting them from any leveling actions.

MSP Alternate Hammocks

An alternate approach to hammocks in MSP involves the following steps:

  1. Create the proposed hammock task as either a Fixed Units or Fixed Work task, depending on the nature of the resource loading required.
  2. Specify two predecessors to the proposed hammock task: one Start-to-Start and one Finish-to-Finish, without lags. (These are the same tasks that would otherwise be the sources of the Start and Finish paste-links. Here they are visible and auditable. Do Not paste links.)
  3. Avoid specifying any successors to the hammock.
  4. Create a custom flag field named “Hammock,” and assign a value of “Yes” to the Hammock flag for this task.
  5. Adjust the duration of the task such that it spans between the associated start and finish predecessor dates. (This is done automatically with the macro code below.)
  6. Ensure that the task is assigned a Priority of 1000, which prevents it from being resource-leveled. (This is done automatically with the macro code below.)
  7. Load indirect resources to the task as appropriate.

This alternate approach has the key benefit of presenting an explicit logical basis for the hammock task’s schedule dates, which can be easily checked and modified if necessary.  It also supports the use of Fixed-Work hammocks for allocation of fixed contract costs.  While this alternate approach is no more robust than OLE hammocks when summarizing tasks with potential concurrency, it is far easier to review, modify, and update the associated hammock links when the controlling activities change.

The macro/vba code below is intended to automatically update the durations of all hammock tasks in the active project.  It also automatically removes constraints on hammocks and assigns a priority of 1000 to prevent resource leveling.

This macro/vba code comprises a subroutine and a custom function that should be pasted together into a single module in the Visual Basic Editor.  The “UpdateHammocks” macro may then be assigned to a “hotkey” or ribbon command as appropriate.

[Edit March 2018.  Our MSP add-in, BPC Logic Filter, excludes Hammocks constructed using this method from Longest-Path and Near-Longest-Path reports.  This satisfies the requirement that such tasks not be included in any calculations of the project’s Critical Path.  Since some users have reported inadvertent introduction of splits into hammock tasks during cost updating, I added a little mini-procedure to close all such splits that are 100% in the future, prior to updating the hammock duration.  I also updated the duration calculator to accommodate an assigned resource with a non-standard calendar.  ]

Sub UpdateHammocks()
'15Sep'17 coded by TM Boyle, PSP.
'A code to routinely update the Durations of unlinked, user-managed "hammock" tasks in Microsoft Project.
'A "hammock" task is an indirect/support task that may be resource loaded.  Its schedule
'depends solely on the tasks that it supports/summarizes.
'For this code to work:
'   - All hammock tasks are coded using a custom Flag field (named "Hammock"); Alternately Flag1 is assumed.
'   - Each hammock task has exactly one or two predecessors:
'       - The "Start" predecessor has a Start-to-Start relationship with no lag
'       - The "Finish" predecessor has a Finish-to-Finish relationship with no lag
'       - If there is only one predecessor, then both start and finish of the hammock will come from it.
'   - Each hammock should have NO successors, although this condition is not enforced.
'       - Successors on the hammock can synthetically lengthen the backward path to its "Start" predecessor,
'           thereby reducing Total Slack in that predecessor and its driving chain.
'[21Mar'18 added code to remove splits in hammocks.]
'[22Mar'18 added code for hammock scheduling using a single resource calendar.]


Dim t As Task
Dim d As TaskDependency
Dim StartH As Date
Dim FinishH As Date
Dim i As Integer 'Added 21Mar'18
        
If Not HammockFieldExists Then
    MsgBox ("Couldn't find a Hammock Flag. Aborting")
    Exit Sub
Else
    'Proceed
End If


For Each t In ActiveProject.Tasks
    If Not t Is Nothing Then
        
        StartH = 0
        FinishH = 0
        If t.GetField(FieldNameToFieldConstant("Hammock")) = "Yes" Then
        'If t.Flag1 = True Then 'Flag1 is used to designate Hammock Activities
        
            'Added 21Mar'18
            'First Close Splits if any
            On Error GoTo 0
            If "Proceed" = "Proceed" Then '(change second "Proceed" to another word to bypass for troubleshooting)
                Do While t.SplitParts.Count > 1
                    i = t.SplitParts.Count
                    'Don't remove any splits that begin in the past
                    If ActiveProject.StatusDate < ActiveProject.ProjectFinish Then 'StatusDate Exists
                        If t.SplitParts(i - 1).Finish < ActiveProject.StatusDate Then Exit Do
                    Else ' Use now date
                        If t.SplitParts(i - 1).Finish < Now() Then Exit Do
                    End If
                        t.SplitParts(i).Start = t.SplitParts(i - 1).Finish
                Loop
            End If
            
            If t.PredecessorTasks.Count = 2 Or t.PredecessorTasks.Count = 1 Then
                For Each d In t.TaskDependencies
                    If d.To = t Then
                        If d.Type = pjFinishToStart Or d.Type = pjStartToFinish Then
                            MsgBox ("Hammocks may only have SS or FF predecessors (Check predecessors): " & t.ID & " " & t.Name)
                        Else
                            If d.Type = pjStartToStart Then StartH = d.From.Start
                            If d.Type = pjFinishToFinish Then FinishH = d.From.Finish
                            If t.PredecessorTasks.Count = 1 Then
                                If StartH = 0 Then StartH = d.From.Start
                                If FinishH = 0 Then FinishH = d.From.Finish
                            End If
                            If d.Lag <> 0 Then MsgBox ("Hammocks should not have lag (Check lag): " & t.ID & " " & t.Name)
                        End If
                    Else
                        MsgBox ("Hammocks should not have successors (Check successors): " & t.ID & " " & t.Name)
                    End If
                Next d
            
                    On Error Resume Next
                        t.Duration = Application.DateDifference(StartH, FinishH, t.CalendarObject)
                        If Err.Number <> 0 Then
                            Err.Clear
                            'Added 22Mar'18 - allow for resource calendar controlling task schedule
                            t.Duration = Application.DateDifference(StartH, FinishH, t.Assignments(1).Resource.Calendar)
                            If Err.Number <> 0 Then
                                Err.Clear
                                t.Duration = Application.DateDifference(StartH, FinishH)
                                If Err.Number <> 0 Then
                                    MsgBox ("Failed to update Hammock (Check predecessors): " & t.ID & " " & t.Name)
                                End If
                            End If
                        End If
                        If Err.Number = 0 Then
                            t.Priority = 1000
                            t.ConstraintType = 0
                        End If
            Else
                MsgBox ("There must be 1 or 2 predecessors for this hammock activity. Not Updating: " & t.ID & " " & t.Name)
                
            End If
        End If
    End If
Next t
Application.CalculateProject


End Sub


Function HammockFieldExists() As Boolean
    Dim StrTest As String
    Dim FlagTemp As String

    StrTest = "Hammock"
    On Error Resume Next
        FlagTemp = ActiveProject.ProjectSummaryTask.GetField(FieldNameToFieldConstant(StrTest))
    If Err.Number = 0 Then 'The fieldname exists and will be used
        HammockFieldExists = True
    Else
        HammockFieldExists = False
    End If
End Function

How to Find Multiple Critical Paths in a Single CPM Schedule

In complex project schedules, multiple critical paths can exist between the project’s start and finish milestones.  Additionally, integrated projects with multiple phased scopes of delivery often have several distinct, contractually-mandated deliverables and corresponding delivery dates.   Each possesses its own critical/driving path.

[Note to searchers: This article has a slight mention of Microsoft Project’s Advanced Calculation Option – “Calculate Multiple Critical Paths.”  It’s near the end, in the section called A Note About Open Ends.] 

A key tenet of the original Critical Path Method (CPM) of project scheduling is that each project has one and only one “Critical Path” (CP) that extends continuously from the project start milestone to the project finish milestone.  The CP is defined by the collection of activities that determine the finish date of the project, such that a delay of any one of them will delay the project.  Traditional methods identify the CP based on Total Slack/Float.  [Note: in many cases, the CP is not defined by the collection of “Critical” activities from the software.]

Single Finish Milestone w/ Parallel Drivers

It is possible for the “critical path” between the start milestone and the finish milestone to have several parallel branches of equivalent length.  These can be described as “multiple critical paths.”

Depending on the details of the schedule model, it is not uncommon to have at least a few activities that are both concurrent and critical.  That is, they comprise parallel branches of a common logic path that drives the completion of the project.  For example, the construction schedule for a residential building may include one activity for “plumbing rough-ins” and another activity for “electrical rough-ins” (where “rough-in” is another term for “first fix” work.)  The two activities have the same driving predecessors (e.g. structural framing) and driven successors (e.g. wall finishes), and they take the same amount of time to complete.  If the wall finishes are on the driving path to project completion, then the two rough-in activities form parallel branches of the “Critical Path” for the project.  Such parallel branches might be repeated for each floor of a multi-story building.  In practice, instances of parallelism/concurrency that comprise only a few activities like those described here seem rarely, if ever, to be identified as “multiple critical paths.”  This is because a) the parallel activities are seen as closely related; and b)traditional methods of identifying and depicting critical activities do not differentiate between the associated logic paths, typically sorting by dates and filtering primarily on the software’s “critical” flag and/or Total Slack/Float.

Multiple critical paths are also created by efforts to accelerate the project completion, such as crashing or fast-tracking exercises, after the initial development of the schedule.  For example, a large scale construction project must be accelerated by 40 days to meet contract commitments.  The critical path of the initial project schedule runs through building construction, while underground utility development activities possess 30 days of Total Float.

Additional resources (and costs) may be applied to compress the building construction activities by 30 days and yield a corresponding acceleration of the project completion.  At that point, the building construction and utility development activities must both be compressed by an additional 10 days (and at additional cost) to obtain the necessary 40-day acceleration of the project.  After the exercise, the building construction and utility development activities are equally driving the project completion, and the schedule possesses two critical paths.

Further crashing or fast-tracking exercises may add more critical paths.  The associated activities all possess the same total float/slack, and all are marked as “critical.”  Differentiating between the various paths requires a method for separately tracing and coding driving logic, either analytically or by visual inspection.  Such methods are explored later in this article.

In practice, multiple critical paths are also created during project execution, as float is completely consumed by unplanned delays in activities that were previously non-critical.  Exploration of such delays will have to wait for another article.  (Notions of the “Critical Path” are sometimes suspended in the late stages of major/mega projects, as virtually every incomplete activity may delay the ultimate completion of the project and is therefore “Critical”.)

Ultimately, all three of these instances of multiple critical paths can be traced to a certain simplification (or presumed simplification) of resource utilization in the project.  In the first example, plumbing and electrical crews are presumed to have exactly the same productivity, resulting in the same duration for both activities.  In fact, one of the crews may be capable of completing the work sooner but paces its effort in order to match the scheduled duration.  In the second example, it is presumed that the building construction activities and utility development activities may be compressed by exactly 40 days and 10 days, respectively.  In fact, optimum resource usage often follows a step-wise rather than linear (or even continuous) function; consistent with adding discrete crews or substituting higher-capacity equipment.  Thus, the building construction may be optimally compressed by 35 days or 45 days (not 40 days), and the utility development may be optimally compressed by 9 days or 12 days (not 10 days).  As a result, the project completion is optimally accelerated by 42 days (not 40 days), with the critical path being governed by utility development.  The crashed building construction activities get 3 days of float.

When taken to this level of detail, a single critical path may indeed be re-established.  Depending on the needs of the project, such detail may or may not be justified in light of various project uncertainties and the increased management effort involved.

Multiple Delivery Milestones

When a project involves the parallel or interim delivery of multiple scopes of work, each delivery may be construed to have its own “critical path”  – i.e. the sequence of activities and relationships determining the delivery date for the particular scope of work.  More importantly, any particular activity in the project schedule may be expected to participate in more than one of these multiple critical paths.  Examples include design, setup, or testing activities that may be common to several deliveries.

Here is a simple example project comprising six “phases” of inter-related tasks in a Microsoft Project (MSP) schedule.

MSP identifies the CP for the project on the basis of Total Slack (TS<=0), and it colors the associated bars red.  The table includes six columns identifying the critical/driving tasks for each of the phase-completion milestones (CP1 through CP6).  For example, the critical/driving tasks for the Phase 1 Completion (ID #6) are flagged “yes” and highlighted yellow in the CP1 column.  This path comprises the following sequence, which is easily verified by inspection: 1->13->14->5->6.  Interestingly, the first Phase 1 task — ID #3 – “1A” —  is marked “critical” for the overall project but is not critical for the Phase 1 Completion.  A delay of this task would delay the project but would not immediately delay Phase 1.  Coincidentally, since Phase 6 is the last phase to finish, its critical path (column CP6) corresponds to the critical path for the overall project – i.e. the red bars and TS=0.

The project is scheduled identically using Oracle Primavera P6 (P6).

As a result of the modest number of inter-phase relationships, the critical/driving paths for five of the six phases include activities from other phases.  The exception, Phase 3, is essentially self-contained, although several of its tasks are also driving the completion of Phase 1.

So, how are these six different critical paths identified?

Identifying Multiple Critical Paths

There is in fact no way to simultaneously define the six phase critical paths of the example project using Total Slack alone without manipulation.  The paths must be identified individually and directly reported (in the manner of BPC Logic Filter) or manually marked.

Deadlines / Late Constraints

It is common to apply deadlines (or late constraints in P6) to key completion milestones that are contractually defined – typically with financial consequences for delay.  Deadlines have the potential to reduce Total Slack/Float, which MSP and P6 use to identify Critical tasks.  When deadlines are applied to tasks and milestones that – together with their predecessor chains – are logically and organizationally separate, then Total Slack/Float can provide a reasonable indication of the driving path to each “deadlined” task or milestone.  This is a rare circumstance.  With only a single deadline applied, the Total Slack/Float for any task will be potentially influenced by the Project Completion date and by the deadline date, with the more “urgent” of the two forcing a lower Total Slack/Float value.  With more deadlines and intersecting logic paths, the issue is multiplied.

In the present example, each phase completion task has been given a deadline corresponding to its current finish date.  Consequently, all except two tasks in the entire project are given a Total Slack value of Zero and marked “Critical.”  The delay of any of these tasks is certain to violate at least one of the deadlines, although the deadlines to be violated are not obvious without the table.  The actual driving path to each phase completion remains obscured.  Although not completely reliable for defining individual driving paths, deadlines (and late constraints in P6) remain useful for flagging those tasks whose delay could affect (or already have affected) a contractually significant milestone.

If the project already includes multiple deadlines (for contractually significant milestones), then the critical/driving path for each milestone can be identified (one at a time) by forcing the milestone onto the MOST critical path, i.e.:

  • Temporarily accelerating the deadline date to the point that it becomes the most “urgent” deadline in the schedule network for all affected tasks.  The Total Slack of the milestone and its driving predecessors is then easily distinguished from that of other tasks; and then
  • Marking the tasks identified by the lowest Total Slack value.  Here, the deadline for the Phase 1 completion was accelerated by 9 work days, resulting in a Total Slack of -9 days for the completion task and its driving predecessors.  The CP1 custom flag field could then be marked accordingly.

As shown here, a nearly-identical process (using an accelerated Finish-on-or-before constraint) can be used for a P6 project schedule with multiple late constraints.

A similar approach can be used by adding a deadline or late constraint (in P6) if the project has none.

In fact this is the “Constraint Method” that was promulgated by the Defense Contract Management Agency (DCMA) as the only valid method for defining a program critical path as part of its 14-point schedule assessment.

As shown above, using deadlines or constraints to generate negative slack/float is an effective way to identify multiple critical paths.  In Microsoft Project, however, these paths are difficult to distinguish on the Gantt charts because their red bars are not uniquely differentiated from others.  Both MSP and P6 can set the “Critical” flag – resulting in the red bars – for any tasks whose Total Slack/Float is below a certain user-specified threshold.  Unlike P6, MSP does not permit this threshold to be less than zero.  Consequently, all tasks with negative Total Slack – even those which are not driving anything – are flagged as “Critical” and given the red bar in MSP.

Trailing Dummy

An alternate approach to overcome this limitation for presentation purposes uses a “super-long trailing dummy” task.  In this approach, all deadlines and late constraints in the project must be removed (at least temporarily).  Then a “trailing dummy” task is assigned as a successor to the first key completion milestone, forcing the milestone onto the critical path.  The duration of the trailing dummy must be long enough to extend the completion of the project, creating positive Total Slack for all tasks that are not part of the dummy’s predecessor chain.  As shown in the following two figures, adding the 100-day Trailing Dummy task as a successor to the Phase 1 completion milestone effectively creates a new critical path for the project – one which is easily recognized as the Phase 1 critical path on the Gantt chart.  Moving the trailing dummy successor from phase to phase – one at a time – reveals the unique critical path for each phase.   

So far all of these approaches rely on temporary manipulation of Total Slack or Total Float, and it is important that such temporary changes be reversed prior to sharing or distributing schedule files.  Obviously, these approaches can be labor-intensive and error-prone, making them impractical when the schedule status (and logic) is in flux – as during regular weekly/monthly updating.  Even when the complications of multiple deadlines or late constraints are removed, Total Slack also becomes unreliable as an indicator of critical/driving relationships whenever multiple task/resource calendars or resource leveling are applied.

Driving Logic Tracing

The “Longest Path” algorithm in P6 defines the project’s Critical Path by automatically tracing driving logic backward from project completion.  This avoids the complications that late constraints and multiple calendars introduce to the interpretation of Total Float, and it is the preferred calculation method when these factors exist.  (It is unfortunate that P6 seems to be the only mainstream project scheduling tool to implement it.)  Since the algorithm always begins the backward trace with the project completion activity, using it with the trailing dummy method above is useful for identifying multiple critical paths on the basis of driving logic.  Driving logic can also be traced in other ways.

Driving Path Trace / Filter (P6)

P6 automatically identifies driving and non-driving relationships in the task details.  It also allows users to automatically add activities to existing filters by simply selecting them.  The combination of these two features allows users to manually construct a filtered view of the critical path to any completion milestone by simply clicking backward through the driving relationships.

The first step is to construct a custom filter to isolate the completion milestone of interest.  Here we are focusing on the Phase 1 completion milestone.

Next, the chain of driving activities (i.e. the driving path) is added to the view by stepping backward through the driving relationships using the “GoTo” button in the predecessors pane.  Here is the view after taking the first backward step.

Here is the view after tracing the network all the way back to the first driving relationship.  This is the driving (i.e. “critical”) path for the Phase 1 completion milestone. 

This click-tracing technique can become tedious when the project schedule is complex and there are numerous branches to the logic paths.  For example, if an activity along the driving path has two driving predecessors, then the analyst must make a note to return to the second one after the first is fully explored.  In addition, P6 routinely marks all links to Level-of-Effort (LOE) activities and links to ALAP-constrained predecessors as driving.  The LOE activities must be ignored during the trace, and the ALAP constrained activities need to be evaluated separately.  Finally, near-driving logic paths can be identified by the “relationship free float” field in the predecessors table, but isolating driving and near-driving paths involves creating and marking a number of new activity fields.

Fortunately, P6 includes an advanced scheduling option for calculating multiple float paths, which I’ve previously written about here.  This option effectively automates the click-tracing technique.

Combined with a view/layout/filter that depicts the “Float Path” field, this option provides a robust and repeatable method for defining the driving and near driving paths to each phase completion milestone in a P6 schedule.  (The “free float” option must be used.)  Float Path number 1 identifies the (first) driving path.  Higher Float Path numbers identify any parallel driving paths and near-driving paths.  Like the click-tracing technique, Multiple-Float Path analysis works without modifying the schedule network, so reversing temporary changes is not a concern prior to sharing the schedule.  Neither of these techniques affects P6’s assignment of the “critical” flag, however, so red-bars on the Gantt charts are not meaningful.

Task Path (MSP)

If you are using a recent version of Microsoft Project (2013+), then the driving path to each phase completion milestone can be visually identified and highlighted on the bar chart using the “Task Path” function with the “driving predecessors” switch selected.  (Task ID6 is selected, and the tasks in its “Driving Predecessors” Task Path are highlighted orange.)  The user can then manually enter a code (like the custom flag fields shown above) to mark the highlighted tasks.  It is fairly straightforward to automate the generation of a task path filter using a macro, and some macro snippets have been published.  (E.g. here.)  Unfortunately, Task Path’s “Driving Predecessors” are not reliable for most complex projects (e.g. when non-Finish-to-Start links, in-progress tasks, or manually-scheduled tasks are present.)  Those issues are discussed in my other blog entry here.

Logic-Tracing Add-ins

BPC Logic Filter (an MSP add-in) was developed in part to offset the absence of the Longest Path and multiple float path analysis in MSP.  The chart below shows driving and near-driving paths to Phase 1 completion – depicted by altering the bar chart.  The driving path is indicated by dark red bars with the zero indicating zero relative float.  Consistent with the trailing-dummy results, the two non-driving tasks that are part of Phase 1 are depicted as having 2 days and 3 days, respectively, of float relative to the Phase 1 completion milestone.  That is, they could slip 2 or 3 days before affecting the milestone.  Similar depictions of the driving and near-driving paths for the other five phases, and for the project as a whole, are made possible with a few clicks.  Since the schedule network is not manipulated in any way, Total Slack remains unchanged, and there is no need to reverse any analysis-based modifications prior to sharing the data file.

A Note About Open Ends

Some experts have suggested using open-ended logic along with a built-in software calculation setting to automatically mark multiple critical paths.  The proposal is as follows:

  1.  Ensure that each of the Phase completion milestones is sequenced so that a) it is a logical successor to all the activities in the phase, and b) it has no successors.
  2. Enable a calculation setting that forces activities with no successors to have zero total float.  In P6, this setting is the “Make open-ended activities critical” schedule option.  In MSP, the setting is the “Calculate multiple critical paths” advanced calculation option.

Effectively, this is the same as assigning a deadline to each completion milestone at a date that exactly equals its early finish date – an example of which was already explored above.  It is subject to the same drawbacks of that approach, but with none of the advantages.  I.e. If there are intersecting logic paths between phases (as shown in the example), then which activities are driving which milestone cannot be determined based on total float alone.  One merely sees a bunch of zero-float activities in all the phases.  Moreover, the basic technique of accelerating the milestone’s deadline/late-constraint date to reveal its driving predecessor path (through negative float) is not available when no deadline or late constraints have been applied.  Between this and other failings, I just don’t see any advantages to this open-ends approach.

Recap

A project schedule can possess multiple critical paths for one of two primary reasons:

  1. There is a single key completion milestone at the end of the project, and multiple, concurrent, parallel driving paths to that milestone exist.  In this case, the multiple critical paths often reflect a schedule model that is simpler than the actual execution of the project.  Correctly accounting for productivity of the assigned resources may remove the apparent concurrency and restore the single Critical Path, but the increased overhead of developing and managing a more detailed schedule would need to be justified.
  2.  The project possesses multiple key completion milestones, each with its own legitimate driving/critical path.  In this case, the correct identification and status reporting for the multiple Critical Paths is often beyond the capabilities of the scheduling software.  Then specialized logic tracing techniques are required.

These factors can also be combined in some project schedules.