📊 statistics

Simulating Complex Crossectional and Longitudinal Data using the simDAG R Package

This paper introduces the **simDAG** R package, a standardized tool that simplifies the generation of complex cross-sectional and longitudinal data by utilizing structural equations in directed acyclic graphs to support diverse data types, non-linear relationships, and arbitrary dependencies for Monte-Carlo simulation studies.

Original authors: Robin Denz, Nina Timmesfeld

Published 2026-06-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Robin Denz, Nina Timmesfeld

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a chef trying to test a new recipe. Before you serve the dish to real customers, you need to know if your ingredients will work together. In the world of statistics, researchers do the same thing: they run "simulations" to test if their mathematical recipes (statistical methods) work correctly. To do this, they need to create fake data that looks and behaves exactly like the real world.

The problem? Creating this fake data is like trying to build a complex Lego castle where every brick depends on the one before it, and some bricks change shape over time. It's tedious, error-prone, and requires a lot of programming skill.

Enter simDAG, a new tool (an R package) that acts like a "smart blueprint builder" for this fake data. Here is how it works, explained simply:

1. The Blueprint: The DAG

Instead of writing thousands of lines of code to generate numbers, you draw a map called a Directed Acyclic Graph (DAG).

Think of it like a family tree: You have a "root" (like a parent) and "children" (variables that depend on the parent).
The Rule: The arrows only go one way (from parent to child), and there are no loops (you can't be your own ancestor).
What it does: This map tells the computer exactly how variables are connected. For example, "Smoking causes Lung Cancer," or "Age affects both Smoking and Lung Cancer."

2. The Recipe: Structural Equations

Once you have the map, you need to tell the computer how to build the data. In simDAG, you attach a "recipe" to each node (variable) on your map.

Root Nodes (The Start): These are variables with no parents (like a coin flip or a random number). You just say, "Make this a random number between 0 and 1."
Child Nodes (The Dependents): These variables depend on others. You can say, "Take the value of 'Smoking' and add 20% to it to get 'Lung Cancer risk'."
The Magic: You don't need to be a coding wizard. You can use simple formulas (like y = 2x + 5) or even complex functions. The package handles the heavy lifting of calculating the numbers based on your map.

3. The Time Machine: Longitudinal Data

Most fake data is just a snapshot (like a photo). But sometimes, researchers need a movie (longitudinal data) to see how things change over time.

The Old Way: You had to draw a new map for every single day, week, or year. If you wanted to simulate 100 days, you had to draw 100 separate maps. This was like drawing a comic strip by hand, one frame at a time.
The simDAG Way: It uses a Discrete-Time Simulation. Imagine a conveyor belt moving through time. Instead of drawing every frame, you give the machine one rule: "Every time the belt moves, check if an event happens."
- Example: If you are simulating a vaccine, the machine checks every day: "Did this person get vaccinated? If yes, does their risk of side effects go up for the next 20 days?"
- This allows researchers to simulate years of data (thousands of time points) for thousands of people without redrawing the map every time.

4. Why This Matters

The paper demonstrates that simDAG can handle:

Mixed Ingredients: It can generate continuous numbers (like height), categories (like "yes/no"), counts (like "number of hospital visits"), and time-to-event data (like "how long until a heart attack") all in the same simulation.
Complex Relationships: It handles non-linear relationships (where doubling the input doesn't just double the output) and interactions (where two variables work together to create a third effect).
Real-World Replication: The authors showed they could recreate the complex data generation processes from real, published scientific studies, proving the tool is powerful enough for serious research.

The Catch (Computational Cost)

The paper admits that simulating time step-by-step is like watching a movie frame-by-frame; it takes more computing power than just looking at a still photo. However, the authors built the tool to be very fast (using a special engine called data.table) so it can run on a standard office computer without needing a supercomputer.

In Summary

simDAG is a tool that lets researchers draw a simple map of how variables are connected and then automatically generates complex, realistic fake data based on that map. It turns the difficult, manual process of building simulation data into a streamlined, standardized workflow, making it easier for scientists to test their theories and ensure their statistical methods are working correctly.

Technical Summary: Simulating Complex Crossectional and Longitudinal Data using the `simDAG` R Package

Problem Statement
Monte-Carlo simulation studies are fundamental to statistical research for estimating sample sizes, comparing methods, and planning clinical trials. A critical bottleneck in these studies is the generation of artificial data from complex Data Generation Processes (DGPs). Researchers often require data containing multiple variables of varying types (continuous, binary, count, time-to-event) with intricate causal dependencies, non-linear relationships, and interactions. While existing R packages facilitate the generation of synthetic data, they often lack flexibility: structural equation packages (e.g., lavaan, simsem) typically restrict users to linear relationships and continuous data; specialized time-to-event packages (e.g., simsurv, survsim) often fail to support arbitrary mixtures of data types or time-varying covariates; and general simulation tools may lack the specific syntax required for causal DAG-based definitions. Furthermore, generating longitudinal data with many time points using traditional methods often requires cumbersome, repetitive code definitions for every time step, making large-scale simulations computationally and practically infeasible.

Methodology
The paper introduces simDAG, an R package designed to standardize the generation of crossectional and longitudinal data based on Directed Acyclic Graphs (DAGs). The methodology relies on three core components:

DAG-Based Definition: Users define the DGP as a causal DAG where nodes represent random variables and edges represent directed causal relationships. The package requires the user to specify structural equations for each node, describing its distribution conditional on its parent nodes.
Topological Sorting and Generation: The package employs a step-wise algorithm that topologically sorts the DAG. It generates data for root nodes (those without parents) by sampling from specified parametric distributions or user-defined functions. Subsequently, it generates data for child nodes based on the values of their parents and the defined structural equations.
Discrete-Time Simulation for Longitudinal Data: To address the challenge of longitudinal data with many time points, simDAG implements a discrete-time simulation approach. Instead of defining a separate node for every time point, users define a single time-varying node using the node_td() function. This node is simulated over a specified number of time steps ( $t$ $t$ ), allowing for the generation of semi-continuous time-scale data. This approach supports:
- Arbitrary Data Types: Support for binary, categorical, count, and continuous variables, as well as time-to-event data.
- Complex Dependencies: Non-linear relationships, interactions, and arbitrary user-defined functions for probability generation.
- Event Dynamics: Specialized node types (time_to_event, competing_events) that handle recurrent events, competing risks, and time-varying covariates by performing Bernoulli or multinomial trials at each time step.
- Data Transformation: The sim2data() function converts the internal simulation output into standard formats (wide, long, or start-stop) suitable for survival analysis (e.g., Cox models with time-varying covariates).

Key Contributions
The primary contribution of the paper is the simDAG package, which offers a unified framework for data generation that bridges the gap between simple structural equation modeling and complex longitudinal simulation. Key features include:

Standardized Syntax: A clear formula interface that allows users to define structural equations similar to standard regression models, supporting mixed model syntax and custom functions.
Longitudinal Flexibility: The ability to simulate longitudinal data with hundreds of time points efficiently by defining generic time-dependent structural equations rather than manually expanding the graph for each time step.
Comprehensive Node Types: Implementation of a wide array of node types (Table 1 in the paper), including specialized functions for survival analysis (Cox, AFT, parametric models) and time-varying binary/categorical processes.
Reproducibility and Transparency: Built-in functions (plot.DAG, summary.DAG) allow for the graphical and textual representation of the underlying DAG and structural equations, facilitating the documentation and reproducibility of simulation studies.

Results
The authors demonstrate the package's capabilities by replicating the DGPs of multiple real Monte-Carlo simulation studies:

Crossectional Data: The package successfully replicated a complex DGP from Denz et al. (2023a) involving six covariates (binary and continuous), a treatment variable, and a right-censored time-to-event outcome with non-linear terms and interactions.
Longitudinal Data (Few Time Points): The package replicated a study by Gruber et al. (2015) involving time-varying treatment and confounders, demonstrating the ability to handle lagged effects and multiple time points using standard node() calls.
Longitudinal Data (Many Time Points): The authors simulated a complex scenario involving Covid-19 vaccination and recurrent myocarditis events over 730 days (2 years). This demonstrated the discrete-time approach's ability to handle time-dependent probabilities, immunity periods, and recurrent events. The resulting data was successfully transformed into a start-stop format and analyzed using a Cox proportional hazards model, yielding a hazard ratio consistent with the specified relative risk.
Computational Performance: Benchmarks indicate that while discrete-time simulation is computationally intensive, the package's reliance on the data.table package and optimized memory management allows for the generation of large datasets (e.g., 10,000 individuals over 730 time points) in reasonable timeframes (approx. 1.11 seconds for a specific configuration on a standard CPU). Runtime scales non-linearly with the number of time points due to loop iterations but linearly with the number of individuals due to vectorized operations.

Significance and Claims
The paper claims that simDAG provides a "standardized approach" to generating complex data, significantly reducing the programming burden and expertise required to implement sophisticated DGPs. The authors emphasize that the package is particularly well-suited for simulation studies involving causal inference due to its DAG foundation but is not limited to this field.

The significance of the work lies in its ability to:

Automate Complex Workflows: It allows researchers to define arbitrary dependencies and data types without writing custom simulation algorithms from scratch.
Enable Discrete-Time Simulations: It makes the generation of longitudinal data with high-resolution time scales feasible for standard Monte-Carlo studies, a task often avoided due to computational complexity or coding difficulty.
Enhance Reproducibility: By formalizing the DGP as a DAG with explicit structural equations, the package aids in the transparent reporting of simulation studies.

The authors modestly acknowledge limitations, noting that discrete-time simulation is inherently more computationally expensive than discrete-event simulation methods. They also note that while the package supports generating data mimicking existing datasets via dag_from_data(), dedicated packages like simPop may be preferable for that specific use case. The paper concludes that simDAG fills a critical gap in the R ecosystem for flexible, causal-aware, and longitudinal data generation.