From 9db07883b7edc65929bb7a89349583fdf99d4cf4 Mon Sep 17 00:00:00 2001 From: Dion Moult Date: Fri, 25 Mar 2022 15:53:05 +1100 Subject: [PATCH] Scheduling calculations no longer calculate from midnight and now handle a single 9-5 day as a duration of 1 day, as per industry standard practice. --- .github/workflows/ci.yml | 1 + .../api/sequence/cascade_schedule.py | 77 +++-- .../api/sequence/edit_task_time.py | 27 +- .../api/sequence/recalculate_schedule.py | 175 ++++++++--- .../api/sequence/test_cascade_schedule.py | 100 +++--- .../test/api/sequence/test_edit_task_time.py | 64 ++-- .../api/sequence/test_recalculate_schedule.py | 284 ++++++++++++++++++ 7 files changed, 576 insertions(+), 152 deletions(-) create mode 100644 src/ifcopenshell-python/test/api/sequence/test_recalculate_schedule.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e4347d993f..563db5dd14 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -83,6 +83,7 @@ jobs: sudo /usr/bin/python -m pip install pytest sudo /usr/bin/python -m pip install isodate sudo /usr/bin/python -m pip install lark + sudo /usr/bin/python -m pip install networkx - name: Test run: | diff --git a/src/ifcopenshell-python/ifcopenshell/api/sequence/cascade_schedule.py b/src/ifcopenshell-python/ifcopenshell/api/sequence/cascade_schedule.py index d578cb0c43..99fc616e33 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/sequence/cascade_schedule.py +++ b/src/ifcopenshell-python/ifcopenshell/api/sequence/cascade_schedule.py @@ -47,15 +47,32 @@ class Usecase: for rel in task.IsSuccessorFrom: predecessor = rel.RelatingProcess + predecessor_duration = ( + ifcopenshell.util.date.ifc2datetime(predecessor.TaskTime.ScheduleDuration) + if predecessor.TaskTime.ScheduleDuration + else datetime.timedelta() + ) if rel.SequenceType == "FINISH_START": finish = self.get_task_time_attribute(predecessor, "ScheduleFinish") if not finish: continue + days = 0 if predecessor_duration.days == 0 else 1 + duration_type = "WORKTIME" if rel.TimeLag: - days = self.get_lag_time_days(rel.TimeLag) + days += self.get_lag_time_days(rel.TimeLag) duration_type = rel.TimeLag.DurationType - starts.append(self.offset_date(finish, days, duration_type, self.get_calendar(task))) - starts.append(self.offset_date(finish, days, duration_type, self.get_calendar(predecessor))) + if days: + starts.append( + datetime.datetime.combine( + self.offset_date(finish, days, duration_type, self.get_calendar(task)), datetime.time(9) + ) + ) + starts.append( + datetime.datetime.combine( + self.offset_date(finish, days, duration_type, self.get_calendar(predecessor)), + datetime.time(9), + ) + ) else: starts.append(finish) elif rel.SequenceType == "START_START": @@ -84,25 +101,31 @@ class Usecase: start = self.get_task_time_attribute(predecessor, "ScheduleStart") if not start: continue + days = -1 + duration_type = "WORKTIME" if rel.TimeLag: - days = self.get_lag_time_days(rel.TimeLag) + days += self.get_lag_time_days(rel.TimeLag) duration_type = rel.TimeLag.DurationType - finishes.append(self.offset_date(start, days, duration_type, self.get_calendar(task))) - finishes.append(self.offset_date(start, days, duration_type, self.get_calendar(predecessor))) + if days or rel.TimeLag: + finishes.append( + datetime.datetime.combine( + self.offset_date(start, days, duration_type, self.get_calendar(task)), datetime.time(17) + ) + ) + finishes.append( + datetime.datetime.combine( + self.offset_date(start, days, duration_type, self.get_calendar(predecessor)), + datetime.time(17), + ) + ) else: finishes.append(start) if starts and finishes: start = max(starts) finish = max(finishes) - potential_finish = datetime.datetime.combine( - ifcopenshell.util.sequence.get_finish_date( - start, - duration, - task.TaskTime.DurationType, - self.get_calendar(task), - ), - datetime.datetime.min.time(), + potential_finish = ifcopenshell.util.sequence.get_start_or_finish_date( + start, duration, task.TaskTime.DurationType, self.get_calendar(task), date_type="FINISH" ) if potential_finish > finish: start_ifc = ifcopenshell.util.date.datetime2ifc(start, "IfcDateTime") @@ -116,11 +139,8 @@ class Usecase: return task.TaskTime.ScheduleFinish = finish_ifc task.TaskTime.ScheduleStart = ifcopenshell.util.date.datetime2ifc( - ifcopenshell.util.sequence.get_finish_date( - finish, - -duration, - task.TaskTime.DurationType, - self.get_calendar(task), + ifcopenshell.util.sequence.get_start_or_finish_date( + finish, duration, task.TaskTime.DurationType, self.get_calendar(task), date_type="START" ), "IfcDateTime", ) @@ -131,11 +151,8 @@ class Usecase: return task.TaskTime.ScheduleFinish = finish_ifc task.TaskTime.ScheduleStart = ifcopenshell.util.date.datetime2ifc( - ifcopenshell.util.sequence.get_finish_date( - finish, - -duration, - task.TaskTime.DurationType, - self.get_calendar(task), + ifcopenshell.util.sequence.get_start_or_finish_date( + finish, duration, task.TaskTime.DurationType, self.get_calendar(task), date_type="START" ), "IfcDateTime", ) @@ -146,11 +163,8 @@ class Usecase: return task.TaskTime.ScheduleStart = start_ifc task.TaskTime.ScheduleFinish = ifcopenshell.util.date.datetime2ifc( - ifcopenshell.util.sequence.get_finish_date( - start, - duration, - task.TaskTime.DurationType, - self.get_calendar(task), + ifcopenshell.util.sequence.get_start_or_finish_date( + start, duration, task.TaskTime.DurationType, self.get_calendar(task), date_type="FINISH" ), "IfcDateTime", ) @@ -167,10 +181,7 @@ class Usecase: return self.calendar_cache[task.id()] def offset_date(self, date, days, duration_type, calendar): - return datetime.datetime.combine( - ifcopenshell.util.sequence.get_finish_date(date, datetime.timedelta(days=days), duration_type, calendar), - datetime.datetime.min.time(), - ) + return ifcopenshell.util.sequence.offset_date(date, datetime.timedelta(days=days), duration_type, calendar) def get_task_time_attribute(self, task, attribute): if task.TaskTime: diff --git a/src/ifcopenshell-python/ifcopenshell/api/sequence/edit_task_time.py b/src/ifcopenshell-python/ifcopenshell/api/sequence/edit_task_time.py index 6aa19feadf..ff0511e03a 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/sequence/edit_task_time.py +++ b/src/ifcopenshell-python/ifcopenshell/api/sequence/edit_task_time.py @@ -40,13 +40,21 @@ class Usecase: del self.settings["attributes"]["ScheduleFinish"] duration_type = self.settings["attributes"].get("DurationType", self.settings["task_time"].DurationType) - if self.settings["attributes"].get("ScheduleFinish", None): - self.settings["attributes"]["ScheduleFinish"] = ifcopenshell.util.sequence.get_soonest_working_day( - self.settings["attributes"]["ScheduleFinish"], duration_type, self.calendar + finish = self.settings["attributes"].get("ScheduleFinish", None) + if finish: + if isinstance(finish, str): + finish = datetime.datetime.fromisoformat(finish) + self.settings["attributes"]["ScheduleFinish"] = datetime.datetime.combine( + ifcopenshell.util.sequence.get_soonest_working_day(finish, duration_type, self.calendar), + datetime.time(17), ) - if self.settings["attributes"].get("ScheduleStart", None): - self.settings["attributes"]["ScheduleStart"] = ifcopenshell.util.sequence.get_soonest_working_day( - self.settings["attributes"]["ScheduleStart"], duration_type, self.calendar + start = self.settings["attributes"].get("ScheduleStart", None) + if start: + if isinstance(start, str): + start = datetime.datetime.fromisoformat(start) + self.settings["attributes"]["ScheduleStart"] = datetime.datetime.combine( + ifcopenshell.util.sequence.get_soonest_working_day(start, duration_type, self.calendar), + datetime.time(9), ) for name, value in self.settings["attributes"].items(): @@ -76,20 +84,21 @@ class Usecase: ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=self.task) def calculate_finish(self): - finish_date = ifcopenshell.util.sequence.get_finish_date( + finish = ifcopenshell.util.sequence.get_start_or_finish_date( ifcopenshell.util.date.ifc2datetime(self.settings["task_time"].ScheduleStart), ifcopenshell.util.date.ifc2datetime(self.settings["task_time"].ScheduleDuration), self.settings["task_time"].DurationType, self.calendar, + date_type="FINISH", ) - self.settings["task_time"].ScheduleFinish = ifcopenshell.util.date.datetime2ifc(finish_date, "IfcDateTime") + self.settings["task_time"].ScheduleFinish = ifcopenshell.util.date.datetime2ifc(finish, "IfcDateTime") def calculate_duration(self): start = ifcopenshell.util.date.ifc2datetime(self.settings["task_time"].ScheduleStart) finish = ifcopenshell.util.date.ifc2datetime(self.settings["task_time"].ScheduleFinish) current_date = datetime.date(start.year, start.month, start.day) finish_date = datetime.date(finish.year, finish.month, finish.day) - duration = datetime.timedelta() + duration = datetime.timedelta(days=1) while current_date < finish_date: if self.settings["task_time"].DurationType == "ELAPSEDTIME" or not self.calendar: duration += datetime.timedelta(days=1) diff --git a/src/ifcopenshell-python/ifcopenshell/api/sequence/recalculate_schedule.py b/src/ifcopenshell-python/ifcopenshell/api/sequence/recalculate_schedule.py index 31e29bcbd8..93082a39f8 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/sequence/recalculate_schedule.py +++ b/src/ifcopenshell-python/ifcopenshell/api/sequence/recalculate_schedule.py @@ -116,14 +116,12 @@ class Usecase: predecessor_types = [rel.SequenceType for rel in task.IsSuccessorFrom] successor_types = [rel.SequenceType for rel in task.IsPredecessorTo] - if not predecessor_types or ( - "FINISH_START" not in predecessor_types and "START_START" not in predecessor_types - ): + if not predecessor_types: self.edges.append(("start", task.id(), {"lag_time": 0, "type": "FS"})) if task.TaskTime and task.TaskTime.ScheduleStart: self.start_dates.append(ifcopenshell.util.date.ifc2datetime(task.TaskTime.ScheduleStart)) - if not successor_types or ("FINISH_START" not in successor_types and "FINISH_FINISH" not in successor_types): - self.edges.append((task.id(), "finish", {"lag_time": 0, "type": "FS"})) + if not successor_types: + self.edges.append((task.id(), "finish", {"lag_time": 0, "type": "FF"})) def update_task_times(self): for ifc_definition_id in self.g.nodes: @@ -149,7 +147,7 @@ class Usecase: ) def offset_date(self, date, days, node): - return ifcopenshell.util.sequence.get_finish_date( + return ifcopenshell.util.sequence.offset_date( date, datetime.timedelta(days=days), node["duration_type"], node["calendar"] ) @@ -170,45 +168,74 @@ class Usecase: finish = predecessor_data.get("early_finish") if finish is None: return - if not edge["lag_time"]: - starts.append(finish) + days = 0 if predecessor_data["duration"] == 0 else 1 + if edge["lag_time"]: + days += edge["lag_time"] + if days: + starts.append(datetime.datetime.combine(self.offset_date(finish, days, data), datetime.time(9))) + starts.append( + datetime.datetime.combine( + self.offset_date(finish, days, predecessor_data), datetime.time(9) + ) + ) else: - starts.append(self.offset_date(finish, edge["lag_time"], data)) - starts.append(self.offset_date(finish, edge["lag_time"], predecessor_data)) + starts.append(finish) elif edge["type"] == "SS": start = predecessor_data.get("early_start") if start is None: return - if not edge["lag_time"]: - starts.append(start) - else: + if edge["lag_time"]: starts.append(self.offset_date(start, edge["lag_time"], data)) starts.append(self.offset_date(start, edge["lag_time"], predecessor_data)) + else: + starts.append(start) elif edge["type"] == "FF": finish = predecessor_data.get("early_finish") if finish is None: return - if not edge["lag_time"]: - finishes.append(finish) - else: + if edge["lag_time"]: finishes.append(self.offset_date(finish, edge["lag_time"], data)) finishes.append(self.offset_date(finish, edge["lag_time"], predecessor_data)) + else: + finishes.append(finish) elif edge["type"] == "SF": start = predecessor_data.get("early_start") if start is None: return - if not edge["lag_time"]: - finishes.append(start) + days = -1 + if edge["lag_time"]: + days += edge["lag_time"] + if days or edge["lag_time"]: + finishes.append( + datetime.datetime.combine(self.offset_date(start, days, data), datetime.time(17)) + ) + finishes.append( + datetime.datetime.combine( + self.offset_date(start, days, predecessor_data), datetime.time(17) + ) + ) else: - finishes.append(self.offset_date(start, edge["lag_time"], data)) - finishes.append(self.offset_date(start, edge["lag_time"], predecessor_data)) + finishes.append(start) if starts and finishes: data["early_start"] = max(starts) data["early_finish"] = max(finishes) - if self.offset_date(data["early_start"], data["duration"], data) > data["early_finish"]: - data["early_finish"] = self.offset_date(data["early_start"], data["duration"], data) + potential_finish = ifcopenshell.util.sequence.get_start_or_finish_date( + data["early_start"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="FINISH", + ) + if potential_finish > data["early_finish"]: + data["early_finish"] = potential_finish else: - data["early_start"] = self.offset_date(data["early_finish"], -data["duration"], data) + data["early_start"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["early_finish"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="START", + ) elif finishes: data["early_finish"] = max(finishes) elif starts: @@ -217,9 +244,21 @@ class Usecase: print("How did this happen?") if data.get("early_finish") is None: - data["early_finish"] = self.offset_date(data["early_start"], data["duration"], data) + data["early_finish"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["early_start"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="FINISH", + ) elif data.get("early_start") is None: - data["early_start"] = self.offset_date(data["early_finish"], -data["duration"], data) + data["early_start"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["early_finish"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="START", + ) return True @@ -241,25 +280,36 @@ class Usecase: start = successor_data.get("late_start") if start is None: return - if not edge["lag_time"]: - finishes.append(start) + days = 1 + if edge["lag_time"]: + days += edge["lag_time"] + if days or edge["lag_time"]: + finishes.append( + datetime.datetime.combine(self.offset_date(start, -days, data), datetime.time(17)) + ) + finishes.append( + datetime.datetime.combine(self.offset_date(start, -days, successor_data), datetime.time(17)) + ) else: - finishes.append(self.offset_date(start, -edge["lag_time"], data)) - finishes.append(self.offset_date(start, -edge["lag_time"], successor_data)) + finishes.append(start) free_floats.append( self.calculate_free_float( - data["early_finish"], successor_data["early_start"], edge["lag_time"], data, successor_data + data["early_finish"].date() + datetime.timedelta(days=1), + successor_data["early_start"].date(), + edge["lag_time"], + data, + successor_data, ) ) elif edge["type"] == "SS": start = successor_data.get("late_start") if start is None: return - if not edge["lag_time"]: - starts.append(start) - else: + if edge["lag_time"]: starts.append(self.offset_date(start, -edge["lag_time"], data)) starts.append(self.offset_date(start, -edge["lag_time"], successor_data)) + else: + starts.append(start) free_floats.append( self.calculate_free_float( data["early_start"], successor_data["early_start"], edge["lag_time"], data, successor_data @@ -269,11 +319,11 @@ class Usecase: finish = successor_data.get("late_finish") if finish is None: return - if not edge["lag_time"]: - finishes.append(finish) - else: + if edge["lag_time"]: finishes.append(self.offset_date(finish, -edge["lag_time"], data)) finishes.append(self.offset_date(finish, -edge["lag_time"], successor_data)) + else: + finishes.append(finish) free_floats.append( self.calculate_free_float( data["early_finish"], successor_data["early_finish"], edge["lag_time"], data, successor_data @@ -283,11 +333,18 @@ class Usecase: finish = successor_data.get("late_finish") if finish is None: return - if not edge["lag_time"]: - starts.append(finish) + days = 0 if successor_data["duration"] == 0 else -1 + if edge["lag_time"]: + days += edge["lag_time"] + if days: + starts.append( + datetime.datetime.combine(self.offset_date(finish, -days, data), datetime.time(9)) + ) + starts.append( + datetime.datetime.combine(self.offset_date(finish, -days, successor_data), datetime.time(9)) + ) else: - starts.append(self.offset_date(finish, -edge["lag_time"], data)) - starts.append(self.offset_date(finish, -edge["lag_time"], successor_data)) + starts.append(finish) free_floats.append( self.calculate_free_float( data["early_start"], successor_data["early_finish"], edge["lag_time"], data, successor_data @@ -297,9 +354,21 @@ class Usecase: data["late_start"] = min(starts) data["late_finish"] = min(finishes) if self.offset_date(data["late_start"], data["duration"], data) < data["late_finish"]: - data["late_finish"] = self.offset_date(data["late_start"], data["duration"], data) + data["late_finish"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["late_start"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="FINISH", + ) else: - data["late_start"] = self.offset_date(data["late_finish"], -data["duration"], data) + data["late_start"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["late_finish"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="START", + ) elif finishes: data["late_finish"] = min(finishes) elif starts: @@ -308,9 +377,21 @@ class Usecase: print("How did this happen?") if data.get("late_finish") is None: - data["late_finish"] = self.offset_date(data["late_start"], data["duration"], data) + data["late_finish"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["late_start"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="FINISH", + ) elif data.get("late_start") is None: - data["late_start"] = self.offset_date(data["late_finish"], -data["duration"], data) + data["late_start"] = ifcopenshell.util.sequence.get_start_or_finish_date( + data["late_finish"], + datetime.timedelta(days=data["duration"]), + data["duration_type"], + data["calendar"], + date_type="START", + ) if data["duration_type"] == "WORKTIME": data["total_float"] = datetime.timedelta( @@ -320,8 +401,14 @@ class Usecase: ) else: data["total_float"] = data["late_finish"] - data["early_finish"] + # If the float is within the span of a single day, it may show as a 8 hours + if data["total_float"].seconds == 60 * 60 * 8: + data["total_float"] = datetime.timedelta(days=data["total_float"].days + 1) data["free_float"] = min(free_floats) if free_floats else None + # If the float is within the span of a single day, it may show as a 8 hours + if data["free_float"] and data["free_float"].seconds == 60 * 60 * 8: + data["free_float"] = datetime.timedelta(days=data["free_float"].days + 1) return True diff --git a/src/ifcopenshell-python/test/api/sequence/test_cascade_schedule.py b/src/ifcopenshell-python/test/api/sequence/test_cascade_schedule.py index c3811b3758..48e101559b 100644 --- a/src/ifcopenshell-python/test/api/sequence/test_cascade_schedule.py +++ b/src/ifcopenshell-python/test/api/sequence/test_cascade_schedule.py @@ -32,10 +32,10 @@ class TestCascadeSchedule(test.bootstrap.IFC4): task2 = self._create_task("P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" def test_only_cascading_to_successors_not_predecessors(self): task = self._create_task("P1D") @@ -45,13 +45,13 @@ class TestCascadeSchedule(test.bootstrap.IFC4): self._create_sequence(task, task3, "FINISH_START", lag="P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task2) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-04T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" # We assert that these start finish times have not cascaded - assert task3.TaskTime.ScheduleStart == "2000-01-02T00:00:00" - assert task3.TaskTime.ScheduleFinish == "2000-01-05T00:00:00" + assert task3.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-04T17:00:00" def test_cascading_finish_to_start(self): task = self._create_task("P1D") @@ -61,12 +61,27 @@ class TestCascadeSchedule(test.bootstrap.IFC4): self._create_sequence(task, task3, "FINISH_START", lag="P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-04T00:00:00" - assert task3.TaskTime.ScheduleStart == "2000-01-03T00:00:00" - assert task3.TaskTime.ScheduleFinish == "2000-01-06T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" + assert task3.TaskTime.ScheduleStart == "2000-01-03T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-05T17:00:00" + + def test_cascading_finish_to_start_for_milestones(self): + task = self._create_task("P0D") + task2 = self._create_task("P2D") + task3 = self._create_task("P3D") + self._create_sequence(task, task2, "FINISH_START") + self._create_sequence(task, task3, "FINISH_START", lag="P1D") + + ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-02T17:00:00" + assert task3.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-04T17:00:00" def test_cascading_finish_to_finish(self): task = self._create_task("P1D") @@ -76,12 +91,12 @@ class TestCascadeSchedule(test.bootstrap.IFC4): self._create_sequence(task, task3, "FINISH_FINISH", lag="P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "1999-12-31T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task3.TaskTime.ScheduleStart == "1999-12-31T00:00:00" - assert task3.TaskTime.ScheduleFinish == "2000-01-03T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "1999-12-31T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task3.TaskTime.ScheduleStart == "1999-12-31T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-02T17:00:00" def test_cascading_start_to_start(self): task = self._create_task("P1D") @@ -91,12 +106,12 @@ class TestCascadeSchedule(test.bootstrap.IFC4): self._create_sequence(task, task3, "START_START", lag="P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-03T00:00:00" - assert task3.TaskTime.ScheduleStart == "2000-01-02T00:00:00" - assert task3.TaskTime.ScheduleFinish == "2000-01-05T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-02T17:00:00" + assert task3.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-04T17:00:00" def test_cascading_start_to_finish(self): task = self._create_task("P1D") @@ -106,15 +121,32 @@ class TestCascadeSchedule(test.bootstrap.IFC4): self._create_sequence(task, task3, "START_FINISH", lag="P1D") ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) - assert task.TaskTime.ScheduleStart == "2000-01-01T00:00:00" - assert task.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" - assert task2.TaskTime.ScheduleStart == "1999-12-30T00:00:00" - assert task2.TaskTime.ScheduleFinish == "2000-01-01T00:00:00" - assert task3.TaskTime.ScheduleStart == "1999-12-30T00:00:00" - assert task3.TaskTime.ScheduleFinish == "2000-01-02T00:00:00" + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.ScheduleStart == "1999-12-30T09:00:00" + assert task2.TaskTime.ScheduleFinish == "1999-12-31T17:00:00" + assert task3.TaskTime.ScheduleStart == "1999-12-30T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + + def test_cascading_start_to_finish_for_milestones(self): + task = self._create_task("P0D") + task2 = self._create_task("P2D") + task3 = self._create_task("P3D") + self._create_sequence(task, task2, "START_FINISH") + self._create_sequence(task, task3, "START_FINISH", lag="P1D") + + ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleStart == "1999-12-30T09:00:00" + assert task2.TaskTime.ScheduleFinish == "1999-12-31T17:00:00" + assert task3.TaskTime.ScheduleStart == "1999-12-30T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" def _create_task(self, duration): task = ifcopenshell.api.run("sequence.add_task", self.file) + if duration == "P0D": + task.IsMilestone = True task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=task) ifcopenshell.api.run( "sequence.edit_task_time", diff --git a/src/ifcopenshell-python/test/api/sequence/test_edit_task_time.py b/src/ifcopenshell-python/test/api/sequence/test_edit_task_time.py index 4055b0194d..552bbce520 100644 --- a/src/ifcopenshell-python/test/api/sequence/test_edit_task_time.py +++ b/src/ifcopenshell-python/test/api/sequence/test_edit_task_time.py @@ -34,19 +34,19 @@ class TestEditTaskTime(test.bootstrap.IFC4): "UserDefinedDataOrigin": "UserDefinedDataOrigin", "DurationType": "ELAPSEDTIME", "ScheduleDuration": "P1D", - "ScheduleStart": "2000-01-01T00:00:00", - "ScheduleFinish": "2000-01-02T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", + "ScheduleFinish": "2000-01-01T17:00:00", "EarlyStart": "2000-01-01T00:00:00", - "EarlyFinish": "2000-01-02T00:00:00", + "EarlyFinish": "2000-01-01T00:00:00", "LateStart": "2000-01-01T00:00:00", - "LateFinish": "2000-01-02T00:00:00", + "LateFinish": "2000-01-01T00:00:00", "FreeFloat": "P0D", "TotalFloat": "P0D", "IsCritical": True, "StatusTime": "2000-01-01T00:00:00", "ActualDuration": "P1D", - "ActualStart": "2000-01-01T00:00:00", - "ActualFinish": "2000-01-02T00:00:00", + "ActualStart": "2000-01-01T09:00:00", + "ActualFinish": "2000-01-01T17:00:00", "RemainingTime": "P1D", "Completion": 0.5, }, @@ -56,19 +56,19 @@ class TestEditTaskTime(test.bootstrap.IFC4): assert task_time.UserDefinedDataOrigin == "UserDefinedDataOrigin" assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P1D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-02T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T17:00:00" assert task_time.EarlyStart == "2000-01-01T00:00:00" - assert task_time.EarlyFinish == "2000-01-02T00:00:00" + assert task_time.EarlyFinish == "2000-01-01T00:00:00" assert task_time.LateStart == "2000-01-01T00:00:00" - assert task_time.LateFinish == "2000-01-02T00:00:00" + assert task_time.LateFinish == "2000-01-01T00:00:00" assert task_time.FreeFloat == "P0D" assert task_time.TotalFloat == "P0D" assert task_time.IsCritical == True assert task_time.StatusTime == "2000-01-01T00:00:00" assert task_time.ActualDuration == "P1D" - assert task_time.ActualStart == "2000-01-01T00:00:00" - assert task_time.ActualFinish == "2000-01-02T00:00:00" + assert task_time.ActualStart == "2000-01-01T09:00:00" + assert task_time.ActualFinish == "2000-01-01T17:00:00" assert task_time.RemainingTime == "P1D" assert task_time.Completion == 0.5 @@ -80,11 +80,11 @@ class TestEditTaskTime(test.bootstrap.IFC4): task_time=task_time, attributes={ "ScheduleDuration": None, - "ScheduleStart": "2000-01-01T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", "ScheduleFinish": None, }, ) - assert task_time.ScheduleStart == "2000-01-01T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" assert task_time.ScheduleFinish is None assert task_time.ScheduleDuration is None @@ -104,7 +104,7 @@ class TestEditTaskTime(test.bootstrap.IFC4): "ScheduleFinish": None, }, ) - assert task_time.ScheduleStart == "2000-01-01T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" assert task_time.ScheduleFinish is None assert task_time.ScheduleDuration is None @@ -117,13 +117,13 @@ class TestEditTaskTime(test.bootstrap.IFC4): attributes={ "DurationType": "ELAPSEDTIME", "ScheduleDuration": "P1D", - "ScheduleStart": "2000-01-01T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", }, ) assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P1D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-02T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T17:00:00" def test_schedule_durations_are_auto_calculated_if_possible(self): task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=self.file.createIfcTask()) @@ -133,14 +133,14 @@ class TestEditTaskTime(test.bootstrap.IFC4): task_time=task_time, attributes={ "DurationType": "ELAPSEDTIME", - "ScheduleStart": "2000-01-01T00:00:00", - "ScheduleFinish": "2000-01-02T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", + "ScheduleFinish": "2000-01-01T17:00:00", }, ) assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P1D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-02T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T17:00:00" def test_a_duration_takes_priority_over_start_and_finish_dates(self): task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=self.file.createIfcTask()) @@ -151,14 +151,14 @@ class TestEditTaskTime(test.bootstrap.IFC4): attributes={ "DurationType": "ELAPSEDTIME", "ScheduleDuration": "P1D", - "ScheduleStart": "2000-01-01T00:00:00", - "ScheduleFinish": "2000-01-03T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", + "ScheduleFinish": "2000-01-03T17:00:00", }, ) assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P1D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-02T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T17:00:00" def test_durations_can_be_specified_in_datetime_objects(self): task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=self.file.createIfcTask()) @@ -169,13 +169,13 @@ class TestEditTaskTime(test.bootstrap.IFC4): attributes={ "DurationType": "ELAPSEDTIME", "ScheduleDuration": datetime.timedelta(days=1), - "ScheduleStart": "2000-01-01T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", }, ) assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P1D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-02T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T17:00:00" def test_zero_durations_are_allowed(self): task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=self.file.createIfcTask()) @@ -186,10 +186,10 @@ class TestEditTaskTime(test.bootstrap.IFC4): attributes={ "DurationType": "ELAPSEDTIME", "ScheduleDuration": datetime.timedelta(), - "ScheduleStart": "2000-01-01T00:00:00", + "ScheduleStart": "2000-01-01T09:00:00", }, ) assert task_time.DurationType == "ELAPSEDTIME" assert task_time.ScheduleDuration == "P0D" - assert task_time.ScheduleStart == "2000-01-01T00:00:00" - assert task_time.ScheduleFinish == "2000-01-01T00:00:00" + assert task_time.ScheduleStart == "2000-01-01T09:00:00" + assert task_time.ScheduleFinish == "2000-01-01T09:00:00" diff --git a/src/ifcopenshell-python/test/api/sequence/test_recalculate_schedule.py b/src/ifcopenshell-python/test/api/sequence/test_recalculate_schedule.py new file mode 100644 index 0000000000..399bd132cc --- /dev/null +++ b/src/ifcopenshell-python/test/api/sequence/test_recalculate_schedule.py @@ -0,0 +1,284 @@ +# IfcOpenShell - IFC toolkit and geometry engine +# Copyright (C) 2022 Dion Moult +# +# This file is part of IfcOpenShell. +# +# IfcOpenShell is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# IfcOpenShell is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with IfcOpenShell. If not, see . + +import datetime +import test.bootstrap +import ifcopenshell.api + + +# A good way for checking these is to recreate them in ProjectLibre +class TestRecalculateSchedule(test.bootstrap.IFC4): + def test_doing_nothing_if_the_task_has_no_time(self): + self._add_work_schedule() + task = ifcopenshell.api.run("sequence.add_task", self.file) + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime is None + + def test_recalculating_for_a_single_task(self): + self._add_work_schedule() + task = self._create_task("P1D") + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + + def test_recalculating_finish_to_start(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + self._create_sequence(task, task2, "FINISH_START") + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.EarlyStart == "2000-01-02T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.LateStart == "2000-01-02T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + + def test_recalculating_multiple_finish_to_start(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + task3 = self._create_task("P3D") + self._create_sequence(task, task2, "FINISH_START") + self._create_sequence(task, task3, "FINISH_START", lag="P1D") + ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.EarlyStart == "2000-01-02T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.LateStart == "2000-01-04T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-05T17:00:00" + assert task2.TaskTime.TotalFloat == "P2D" + assert task2.TaskTime.FreeFloat == "P2D" + assert task2.TaskTime.IsCritical is False + assert task3.TaskTime.ScheduleStart == "2000-01-03T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-05T17:00:00" + assert task3.TaskTime.EarlyStart == "2000-01-03T09:00:00" + assert task3.TaskTime.EarlyFinish == "2000-01-05T17:00:00" + assert task3.TaskTime.LateStart == "2000-01-03T09:00:00" + assert task3.TaskTime.LateFinish == "2000-01-05T17:00:00" + assert task3.TaskTime.TotalFloat == "P0D" + assert task3.TaskTime.FreeFloat == "P0D" + assert task3.TaskTime.IsCritical is True + + def test_recalculating_finish_to_start_with_a_milestone(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + task3 = self._create_task("P0D") + self._create_sequence(task, task2, "FINISH_START") + self._create_sequence(task, task3, "FINISH_START", lag="P1D") + ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.EarlyStart == "2000-01-02T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.LateStart == "2000-01-02T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + assert task3.TaskTime.ScheduleStart == "2000-01-03T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-03T09:00:00" + assert task3.TaskTime.EarlyStart == "2000-01-03T09:00:00" + assert task3.TaskTime.EarlyFinish == "2000-01-03T09:00:00" + assert task3.TaskTime.LateStart == "2000-01-03T17:00:00" + assert task3.TaskTime.LateFinish == "2000-01-03T17:00:00" + assert task3.TaskTime.TotalFloat == "P1D" + assert task3.TaskTime.FreeFloat == "P1D" + assert task3.TaskTime.IsCritical is False + + def test_recalculating_finish_to_start_with_a_milestone_as_the_last_task(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + task3 = self._create_task("P0D") + self._create_sequence(task, task2, "FINISH_START") + self._create_sequence(task2, task3, "FINISH_START") + ifcopenshell.api.run("sequence.cascade_schedule", self.file, task=task) + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "2000-01-02T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.EarlyStart == "2000-01-02T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.LateStart == "2000-01-02T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-03T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + assert task3.TaskTime.ScheduleStart == "2000-01-04T09:00:00" + assert task3.TaskTime.ScheduleFinish == "2000-01-04T09:00:00" + assert task3.TaskTime.EarlyStart == "2000-01-04T09:00:00" + assert task3.TaskTime.EarlyFinish == "2000-01-04T09:00:00" + assert task3.TaskTime.LateStart == "2000-01-04T09:00:00" + assert task3.TaskTime.LateFinish == "2000-01-04T09:00:00" + assert task3.TaskTime.TotalFloat == "P0D" + assert task3.TaskTime.FreeFloat == "P0D" + assert task3.TaskTime.IsCritical is True + + def test_recalculating_finish_to_finish(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + self._create_sequence(task, task2, "FINISH_FINISH") + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "1999-12-31T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.EarlyStart == "1999-12-31T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.LateStart == "1999-12-31T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + + def test_recalculating_start_to_start(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + self._create_sequence(task, task2, "START_START") + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task2.TaskTime.ScheduleFinish == "2000-01-02T17:00:00" + assert task2.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task2.TaskTime.EarlyFinish == "2000-01-02T17:00:00" + assert task2.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task2.TaskTime.LateFinish == "2000-01-02T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + + def test_recalculating_start_to_finish(self): + self._add_work_schedule() + task = self._create_task("P1D") + task2 = self._create_task("P2D") + self._create_sequence(task, task2, "START_FINISH") + ifcopenshell.api.run("sequence.recalculate_schedule", self.file, work_schedule=self.work_schedule) + assert task.TaskTime.ScheduleStart == "2000-01-01T09:00:00" + assert task.TaskTime.ScheduleFinish == "2000-01-01T17:00:00" + assert task.TaskTime.EarlyStart == "2000-01-01T09:00:00" + assert task.TaskTime.EarlyFinish == "2000-01-01T17:00:00" + assert task.TaskTime.LateStart == "2000-01-01T09:00:00" + assert task.TaskTime.LateFinish == "2000-01-01T17:00:00" + assert task.TaskTime.TotalFloat == "P0D" + assert task.TaskTime.FreeFloat == "P0D" + assert task.TaskTime.IsCritical is True + assert task2.TaskTime.ScheduleStart == "1999-12-30T09:00:00" + assert task2.TaskTime.ScheduleFinish == "1999-12-31T17:00:00" + assert task2.TaskTime.EarlyStart == "1999-12-30T09:00:00" + assert task2.TaskTime.EarlyFinish == "1999-12-31T17:00:00" + assert task2.TaskTime.LateStart == "1999-12-30T09:00:00" + assert task2.TaskTime.LateFinish == "1999-12-31T17:00:00" + assert task2.TaskTime.TotalFloat == "P0D" + assert task2.TaskTime.FreeFloat == "P0D" + assert task2.TaskTime.IsCritical is True + + def _add_work_schedule(self): + ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcProject") + self.work_schedule = ifcopenshell.api.run("sequence.add_work_schedule", self.file) + + def _create_task(self, duration): + task = ifcopenshell.api.run("sequence.add_task", self.file, work_schedule=self.work_schedule) + if duration == "P0D": + task.IsMilestone = True + task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=task) + ifcopenshell.api.run( + "sequence.edit_task_time", + self.file, + task_time=task_time, + attributes={"ScheduleStart": datetime.date(2000, 1, 1), "ScheduleDuration": duration}, + ) + return task + + def _create_sequence(self, predecessor, successor, relationship, lag=None): + rel = ifcopenshell.api.run( + "sequence.assign_sequence", self.file, relating_process=predecessor, related_process=successor + ) + ifcopenshell.api.run( + "sequence.edit_sequence", self.file, rel_sequence=rel, attributes={"SequenceType": relationship} + ) + if lag: + ifcopenshell.api.run( + "sequence.assign_lag_time", self.file, rel_sequence=rel, lag_value=lag, duration_type="WORKTIME" + )