Defining DDD entities and object values from a dataset of measurements - machine-learning

Question

I am working on an ML project with a dataset of operating points for a diesel engine. The dataset contains roughly 100 features, ranging from various temperature measurements of fuel/air/exhaust to engine speed and more.
I am looking to apply a DDD approach to my project so I am working on defining a domain model. I am reading up on the matter and talking to domain experts to get a better sense of the domain problem.
That being said, I am having trouble understanding how I can apply the concepts of entities and/or object values to my problem as I feel I might be overengineering here.
This is an example of the table with two operating points:
OperatingPoint
EngineSpeed
EngineTorque
FuelTemperature
FuelPressure
ExhaustTemperature
...
1
200
1000
240
12
500
2
300
3000
350
13
600
In spite of the fact that I have a one-to-one relationship between an OperatingPoint and any other measured parameter, in an attempt to better represent the domain and the objects and behaviors therein, I would like to try to divide this table up into dataclasses that I can then store and process individually. I would group measurements based on the domain object they belong to.
I am thinking that the OperatingPoint is an Entity with its specific ID with all other parameters/features of the table being value objects connected to this entity. For example: OperatingPoint (entity), Engine (value object), Fuel (value object), etc.:
from base_data import BaseData
class OperatingPoint(BaseData):
"""An entity with its ID."""
id: int
engine: Engine
class Engine(BaseData):
"""Value object containing other value objects."""
operating_point_id: int
speed: float
fuel: Fuel
exhaust_gas: ExhaustGas
class Fuel(BaseData):
"""Value object"""
operating_point_id: int
temperature: float
pressure: float
class ExhaustGas(BaseData):
"""Value object"""
operating_point_id: int
temperature: float
...
In this case engine (value object) contains two other value objects which are Fuel and ExhaustGas.
Another example: the intake gas (comburent) is a mix of air and EGR gas, so the dataclass IntakeGas would have two properties that represent value objects:
from base_data import BaseData
from air import Air
from egr_gas import EGRGas
class IntakeGas(BaseData):
"""Value object containing other value objects."""
operating_point_id: int
air: Air
egr_gas: EGRGas
Am I overthinking this problem and creating too much complexion by trying to divide the table up?

Answer 1

The pattern language of domain models may not be a particularly good fit for the problem that you are trying to solve.
If I'm interpreting your example correctly, what you have is a big old pile of data samples, or perhaps a continuous stream of data samples. High cardinality facts[tm], coming to you from system outside of the control of your program.
Your table is, in effect, a cache of messages that weren't lost in transit.
In particular, given a new message, deciding how to add it to that table doesn't seem to require knowing anything about previous entries.
You might need a "parser" (so that you can recognize messages that have been corrupted in transit, rather than polluting your data with garbage); you might need a "filter" (to elide the fields that you don't care about). But the case for "entities" is not obvious.
It might even be that you have several different (logical) processes, that filter data into different tables, so that your data model has better cohesion (or maybe only better performance characteristics). That could be fine.
But for the problem where you are just copying input data into your database, the ceremony of "entities" adds unnecessary friction. So you best be sure that they are delivering value that compensates for that friction, or leave them out.