#criticalPathCalculator {
font-family: Arial, sans-serif;
max-width: 900px;
margin: 20px auto;
padding: 20px;
border: 1px solid #ccc;
border-radius: 8px;
background-color: #f9f9f9;
}
#criticalPathCalculator h2, #criticalPathCalculator h3, #criticalPathCalculator h4 {
color: #333;
text-align: center;
}
#criticalPathCalculator p {
line-height: 1.6;
color: #555;
}
#criticalPathCalculator .task-row {
display: flex;
flex-wrap: wrap;
align-items: center;
margin-bottom: 10px;
padding: 8px;
border: 1px solid #eee;
border-radius: 4px;
background-color: #fff;
}
#criticalPathCalculator .task-row label {
margin-right: 8px;
font-weight: bold;
min-width: 80px;
}
#criticalPathCalculator .task-row input[type="text"],
#criticalPathCalculator .task-row input[type="number"] {
flex: 1;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
margin-right: 10px;
min-width: 100px;
}
#criticalPathCalculator .task-row input[type="number"] {
max-width: 80px;
}
#criticalPathCalculator button {
background-color: #007bff;
color: white;
padding: 10px 15px;
border: none;
border-radius: 5px;
cursor: pointer;
font-size: 16px;
margin-top: 10px;
margin-right: 10px;
}
#criticalPathCalculator button:hover {
background-color: #0056b3;
}
#criticalPathCalculator button.remove-btn {
background-color: #dc3545;
}
#criticalPathCalculator button.remove-btn:hover {
background-color: #c82333;
}
#criticalPathCalculator #result {
margin-top: 20px;
padding: 15px;
border: 1px solid #e0e0e0;
border-radius: 8px;
background-color: #e9f7ef;
}
#criticalPathCalculator #result table {
width: 100%;
border-collapse: collapse;
margin-top: 15px;
}
#criticalPathCalculator #result th,
#criticalPathCalculator #result td {
border: 1px solid #ddd;
padding: 8px;
text-align: left;
}
#criticalPathCalculator #result th {
background-color: #f2f2f2;
font-weight: bold;
}
#criticalPathCalculator #result p {
font-size: 1.1em;
font-weight: bold;
color: #333;
}
#criticalPathCalculator #result p strong {
color: #007bff;
}
#criticalPathCalculator .error-message {
color: red;
font-weight: bold;
margin-top: 10px;
}
@media (max-width: 768px) {
#criticalPathCalculator .task-row {
flex-direction: column;
align-items: flex-start;
}
#criticalPathCalculator .task-row label {
margin-bottom: 5px;
}
#criticalPathCalculator .task-row input {
width: calc(100% – 16px);
margin-right: 0;
margin-bottom: 10px;
}
#criticalPathCalculator .task-row button {
width: 100%;
margin-left: 0;
}
}
var taskCounter = 7; // Start from 7 because we have 7 initial rows (0-6)
function addTaskRow() {
var container = document.getElementById('taskInputsContainer');
var newRow = document.createElement('div');
newRow.className = 'task-row';
newRow.id = 'taskRow_' + taskCounter;
newRow.innerHTML = `
`;
container.appendChild(newRow);
taskCounter++;
}
function removeTaskRow(id) {
var rowToRemove = document.getElementById('taskRow_' + id);
if (rowToRemove) {
rowToRemove.parentNode.removeChild(rowToRemove);
}
}
function displayError(message) {
var resultDiv = document.getElementById('result');
resultDiv.innerHTML = 'Error: ' + message + ";
}
function calculateCriticalPath() {
var tasks = [];
var taskMap = {}; // For quick lookup by name
var taskRows = document.querySelectorAll('.task-row');
// 1. Gather Tasks and Basic Validation
for (var i = 0; i < taskRows.length; i++) {
var id = taskRows[i].id.split('_')[1];
var nameInput = document.getElementById('taskName_' + id);
var durationInput = document.getElementById('taskDuration_' + id);
var predecessorsInput = document.getElementById('taskPredecessors_' + id);
var name = nameInput.value.trim();
var duration = parseFloat(durationInput.value);
var predecessors = predecessorsInput.value.split(',').map(function(p) { return p.trim(); }).filter(function(p) { return p !== ''; });
if (name === '') {
displayError('Task name cannot be empty for row ' + (i + 1) + '.');
return;
}
if (isNaN(duration) || duration < 0) {
displayError('Duration must be a non-negative number for task "' + name + '".');
return;
}
if (taskMap[name]) {
displayError('Duplicate task name found: "' + name + '". Task names must be unique.');
return;
}
var task = {
name: name,
duration: duration,
predecessors: predecessors,
earlyStart: 0,
earlyFinish: 0,
lateStart: 0,
lateFinish: 0,
slack: 0
};
tasks.push(task);
taskMap[name] = task;
}
if (tasks.length === 0) {
displayError('Please add at least one task to calculate.');
return;
}
// Check for non-existent predecessors
for (var i = 0; i < tasks.length; i++) {
for (var j = 0; j < tasks[i].predecessors.length; j++) {
if (!taskMap[tasks[i].predecessors[j]]) {
displayError('Predecessor "' + tasks[i].predecessors[j] + '" for task "' + tasks[i].name + '" not found. Please ensure all predecessor tasks are listed.');
return;
}
}
}
// 2. Forward Pass (Early Start/Early Finish)
var changed;
var maxIterations = tasks.length * tasks.length; // Safety net for complex graphs/potential circularity
var iterationCount = 0;
do {
changed = false;
for (var i = 0; i < tasks.length; i++) {
var task = tasks[i];
var currentEarlyStart = task.earlyStart;
var currentEarlyFinish = task.earlyFinish;
if (task.predecessors.length === 0) {
task.earlyStart = 0;
} else {
var maxPredEF = 0;
var allPredsProcessed = true;
for (var j = 0; j 0 && predTask.predecessors.length > 0) {
allPredsProcessed = false;
break;
}
maxPredEF = Math.max(maxPredEF, predTask.earlyFinish);
}
if (allPredsProcessed) {
task.earlyStart = maxPredEF;
}
}
task.earlyFinish = task.earlyStart + task.duration;
if (task.earlyStart !== currentEarlyStart || task.earlyFinish !== currentEarlyFinish) {
changed = true;
}
}
iterationCount++;
if (iterationCount > maxIterations) {
displayError('Possible circular dependency or complex graph detected during forward pass. Calculation stopped. Please check your task dependencies.');
return;
}
} while (changed);
// 3. Project Duration
var projectDuration = 0;
for (var i = 0; i < tasks.length; i++) {
projectDuration = Math.max(projectDuration, tasks[i].earlyFinish);
}
// 4. Backward Pass (Late Start/Late Finish)
// Initialize late finish for all tasks to project duration
for (var i = 0; i = 0; i–) {
var task = tasks[i];
var currentLateStart = task.lateStart;
var currentLateFinish = task.lateFinish;
var minSuccLS = projectDuration;
var hasSuccessors = false;
// Find all successors for the current task
for (var k = 0; k maxIterations) {
displayError('Possible circular dependency or complex graph detected during backward pass. Calculation stopped. Please check your task dependencies.');
return;
}
} while (changed);
// 5. Slack and Critical Path
var criticalPath = [];
for (var i = 0; i < tasks.length; i++) {
var task = tasks[i];
task.slack = task.lateFinish – task.earlyFinish;
// Due to floating point arithmetic, slack might be very close to zero but not exactly zero.
// We consider it zero if it's within a small epsilon.
if (Math.abs(task.slack) < 0.0001) {
task.slack = 0; // Normalize to 0
criticalPath.push(task.name);
}
}
// Sort critical path tasks by early start to show correct sequence
criticalPath.sort(function(a, b) {
return taskMap[a].earlyStart – taskMap[b].earlyStart;
});
// 6. Display Results
var resultDiv = document.getElementById('result');
var html = 'Critical Path Analysis Calculator
The Critical Path Method (CPM) is a project management technique used to determine the sequence of project activities that will take the longest time to complete. This "critical path" represents the minimum time required to complete the project. Any delay in a critical path activity will directly delay the entire project.
Use this calculator to input your project tasks, their estimated durations, and their dependencies (predecessors). The calculator will then determine the total project duration, identify the critical path, and provide detailed timing for each task, including early start/finish, late start/finish, and slack.
Enter Your Project Tasks
Provide a unique name for each task, its duration (in any consistent unit like days, hours, weeks), and a comma-separated list of task names that must be completed before this task can start. For tasks with no predecessors, leave the field blank. We've pre-filled an example for you.
Understanding Critical Path Analysis
Critical Path Analysis (CPA) is a powerful project management tool that helps in planning, scheduling, and controlling complex projects. It provides a visual representation of the project's timeline and highlights the most crucial activities.
Key Concepts:
- Task/Activity: A specific piece of work that needs to be completed as part of the project.
- Duration: The estimated time required to complete a task. This calculator assumes durations are fixed and known.
- Predecessors: Tasks that must be completed before another task can begin. Dependencies are crucial for determining the flow of work.
- Early Start (ES): The earliest possible time a task can begin, assuming all its predecessors are completed as early as possible.
- Early Finish (EF): The earliest possible time a task can be completed (ES + Duration).
- Late Start (LS): The latest possible time a task can begin without delaying the overall project completion date.
- Late Finish (LF): The latest possible time a task can be completed without delaying the overall project completion date (LF – Duration).
- Slack (Float): The amount of time a task can be delayed without delaying the project's completion date. It's calculated as LF – EF or LS – ES. Tasks with zero slack are on the critical path.
- Critical Path: The longest sequence of tasks in the project network, where each task has zero slack. These tasks are "critical" because any delay in them will directly delay the entire project.
How This Calculator Works:
- Input Collection: You provide task names, their durations, and their direct predecessors.
- Forward Pass: The calculator starts from the beginning of the project and moves forward, calculating the Early Start (ES) and Early Finish (EF) for each task. The ES of a task is the maximum EF of all its immediate predecessors.
- Project Duration: Once all ES and EF values are determined, the total project duration is the maximum EF among all tasks (or the EF of a designated "End" task).
- Backward Pass: Starting from the project's determined completion time and moving backward, the calculator calculates the Late Finish (LF) and Late Start (LS) for each task. The LF of a task is the minimum LS of all its immediate successors.
- Slack Calculation: For each task, slack is calculated as the difference between its Late Finish and Early Finish (LF – EF).
- Critical Path Identification: Any task with a slack of zero is identified as a critical task. The sequence of these critical tasks forms the critical path.
Benefits of Using CPA:
- Improved Planning: Provides a clear roadmap of project activities and their dependencies.
- Accurate Scheduling: Helps in estimating realistic project completion times.
- Resource Management: Allows project managers to allocate resources effectively, especially to critical tasks.
- Risk Management: Highlights critical tasks, enabling proactive management of potential delays.
- Performance Monitoring: Serves as a baseline for tracking project progress and identifying deviations.
Example Explained:
The pre-filled example demonstrates a simple project flow:
- Start: A dummy task with 0 duration, marking the project's beginning.
- A (5 units), B (7 units): These tasks can start immediately after "Start".
- C (3 units): Depends on "A".
- D (6 units): Depends on both "A" and "B". It can only start once both A and B are finished.
- E (4 units): Depends on both "C" and "D".
- End: A dummy task with 0 duration, marking the project's completion, depending on "E".
When you click "Calculate Critical Path" with this example, you'll see the total project duration and the specific path of tasks that cannot be delayed without impacting the overall project timeline.
Calculation Results
'; html += 'Total Project Duration: ' + projectDuration + ' units'; html += 'Critical Path: ' + criticalPath.join(' → ') + "; html += 'Task Details:
'; html += '| Task Name | Duration | Predecessors | Early Start (ES) | Early Finish (EF) | Late Start (LS) | Late Finish (LF) | Slack | On Critical Path? |
|---|---|---|---|---|---|---|---|---|
| ' + task.name + ' | '; html += '' + task.duration + ' | '; html += '' + (task.predecessors.length > 0 ? task.predecessors.join(', ') : 'None') + ' | '; html += '' + task.earlyStart + ' | '; html += '' + task.earlyFinish + ' | '; html += '' + task.lateStart + ' | '; html += '' + task.lateFinish + ' | '; html += '' + task.slack + ' | '; html += '' + onCriticalPath + ' | '; html += '