rapidsim 0.1.0__tar.gz

rapidsim-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tnehezd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rapidsim-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include include *.h
+recursive-include src *.c *.h
+include README.md
+include LICENSE

rapidsim-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: rapidsim
+Version: 0.1.0
+Summary: A Python wrapper for RAPID code
+Author: Dóra Tarczay-Nehéz
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Dynamic: license-file
+
+# RAPID: Representative Approach for Particle-Integrated Disks
+
+This repository contains the source code for `RAPID` (Representative Approach for Particle-Integrated Disks), a 1D numerical model developed as part of my PhD research. The model is designed to simulate the dynamics and evolution of dust particles in protoplanetary disks, including dust traps at the edges of an embedded deadzone.
+
+The core of the code was originally written in C during my PhD between 2012 and 2015. It has since been restructured into a more modular form to improve its functionality and maintainability.
+
+#### ⚠️ 2.2.2 Version: Stable Structure – Ongoing Feature Development
+
+The core structure of the codebase has now been finalized, and no further refactoring is planned. The architecture, naming conventions, and overall organization are stable and consistent with the [Coding Standard](docs/CodingStandard.md).
+
+However, the project remains under active development in terms of features and capabilities. Please always make sure to `git pull` and stay up to date with the latest release before running simulations.
+
+Upcoming and ongoing extensions include:
+
+- Additional numerical integrators
+- Dust settling implementation  
+  (transition from 1D to 1+1D structure)
+- General validation and benchmark test problems  
+  (e.g. shock tube and other standard test cases)
+  
+Stay tuned for regular feature updates.
+
+## Model Description
+
+RAPID is a trajectory-based Lagrangian model that tracks the motion of representative dust particles in the radial direction within an evolving 1D Eulerian gaseous disk. A key feature of this model is that the pressure maximum, which acts as a dust trap, is not a static element but a dynamically evolving phenomenon arising naturally in the vicinity of the embedded dead zone's inner and outer edges.
+
+This approach offers computational efficiency due to its 1D nature while providing an effective approximation of particle trajectories. Using RAPID, we can conduct parameter studies to investigate dust mass growth, particle trajectories, and the evolution of feeding zones around pressure bumps, aiming to understand the conditions that facilitate planetesimal formation in protoplanetary disks.
+
+This work is based on the methods described in Regály et al. (2017) and Tarczay-Nehéz (2026).
+
+## Building and Running the Simulation
+
+### Prerequisites
+To build the executable, you need a C compiler (e.g., GCC or Clang) and GNU Make.
+
+### Build Instructions
+
+To compile the source code, open your terminal and run the following commands:
+
+```Bash
+make clean
+make all
+```
+
+### Running a Simulation
+
+There are two primary ways to run a simulation:
+
+Using a configuration file:
+The `run_simulation.py` Python3 wrapper script can be used to run a series of simulations based on parameters defined in a `config.yaml` file. Simply execute the script in your terminal:
+
+```Bash
+python run_simulation.py
+```
+
+Using command-line arguments:
+Alternatively, you can run the executable directly from the command line by specifying the parameters. A detailed list of all available command-line flags and their corresponding parameters will be provided here shortly.
+
+----
+### References
+
+If you use this code in your research, please cite the following papers, which provides the theoretical background for the core numerical methods:
+
+```bibtex
+@ARTICLE{2017ApJ...851...89R,
+      author = {{Reg{\'a}ly}, Zs. and {Juh{\'a}sz}, A. and {Neh{\'e}z}, D.},
+      title = "{Interpreting Brightness Asymmetries in Transition Disks: Vortex at Dead Zone or Planet-carved Gap Edges?}",
+    journal = {\apj},
+   keywords = {accretion, accretion disks, hydrodynamics, methods: numerical, protoplanetary disks, Astrophysics - Earth and Planetary Astrophysics, Astrophysics - Solar and Stellar Astrophysics},
+      year = 2017,
+      month = dec,
+     volume = {851},
+     number = {2},
+       eid = {89},
+      pages = {89},
+        doi = {10.3847/1538-4357/aa9a3f},
+archivePrefix = {arXiv},
+     eprint = {1711.03548},
+primaryClass = {astro-ph.EP},
+     adsurl = {[https://ui.adsabs.harvard.edu/abs/2017ApJ...851...89R](https://ui.adsabs.harvard.edu/abs/2017ApJ...851...89R)},
+    adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}
+
+
+@article{TarczayNehez2026,
+    author = {Tarczay-Neh{\'e}z, D{\'o}ra},
+    date = {2026/02/03},
+    date-added = {2026-02-03 12:16:24 +0100},
+    date-modified = {2026-02-03 12:16:24 +0100},
+    doi = {10.1007/s10569-026-10278-2},
+    id = {Tarczay-Neh{\'e}z2026},
+    isbn = {1572-9478},
+    journal = {Celestial Mechanics and Dynamical Astronomy},
+    number = {1},
+    pages = {6},
+    title = {Trajectory-based dust evolution in disks: first results from the RAPID simulation code},
+    url = {https://doi.org/10.1007/s10569-026-10278-2},
+    volume = {138},
+    year = {2026},
+    bdsk-url-1 = {https://doi.org/10.1007/s10569-026-10278-2}}
+}
+

rapidsim-0.1.0/README.md

@@ -0,0 +1,102 @@
+# RAPID: Representative Approach for Particle-Integrated Disks
+
+This repository contains the source code for `RAPID` (Representative Approach for Particle-Integrated Disks), a 1D numerical model developed as part of my PhD research. The model is designed to simulate the dynamics and evolution of dust particles in protoplanetary disks, including dust traps at the edges of an embedded deadzone.
+
+The core of the code was originally written in C during my PhD between 2012 and 2015. It has since been restructured into a more modular form to improve its functionality and maintainability.
+
+#### ⚠️ 2.2.2 Version: Stable Structure – Ongoing Feature Development
+
+The core structure of the codebase has now been finalized, and no further refactoring is planned. The architecture, naming conventions, and overall organization are stable and consistent with the [Coding Standard](docs/CodingStandard.md).
+
+However, the project remains under active development in terms of features and capabilities. Please always make sure to `git pull` and stay up to date with the latest release before running simulations.
+
+Upcoming and ongoing extensions include:
+
+- Additional numerical integrators
+- Dust settling implementation  
+  (transition from 1D to 1+1D structure)
+- General validation and benchmark test problems  
+  (e.g. shock tube and other standard test cases)
+  
+Stay tuned for regular feature updates.
+
+## Model Description
+
+RAPID is a trajectory-based Lagrangian model that tracks the motion of representative dust particles in the radial direction within an evolving 1D Eulerian gaseous disk. A key feature of this model is that the pressure maximum, which acts as a dust trap, is not a static element but a dynamically evolving phenomenon arising naturally in the vicinity of the embedded dead zone's inner and outer edges.
+
+This approach offers computational efficiency due to its 1D nature while providing an effective approximation of particle trajectories. Using RAPID, we can conduct parameter studies to investigate dust mass growth, particle trajectories, and the evolution of feeding zones around pressure bumps, aiming to understand the conditions that facilitate planetesimal formation in protoplanetary disks.
+
+This work is based on the methods described in Regály et al. (2017) and Tarczay-Nehéz (2026).
+
+## Building and Running the Simulation
+
+### Prerequisites
+To build the executable, you need a C compiler (e.g., GCC or Clang) and GNU Make.
+
+### Build Instructions
+
+To compile the source code, open your terminal and run the following commands:
+
+```Bash
+make clean
+make all
+```
+
+### Running a Simulation
+
+There are two primary ways to run a simulation:
+
+Using a configuration file:
+The `run_simulation.py` Python3 wrapper script can be used to run a series of simulations based on parameters defined in a `config.yaml` file. Simply execute the script in your terminal:
+
+```Bash
+python run_simulation.py
+```
+
+Using command-line arguments:
+Alternatively, you can run the executable directly from the command line by specifying the parameters. A detailed list of all available command-line flags and their corresponding parameters will be provided here shortly.
+
+----
+### References
+
+If you use this code in your research, please cite the following papers, which provides the theoretical background for the core numerical methods:
+
+```bibtex
+@ARTICLE{2017ApJ...851...89R,
+      author = {{Reg{\'a}ly}, Zs. and {Juh{\'a}sz}, A. and {Neh{\'e}z}, D.},
+      title = "{Interpreting Brightness Asymmetries in Transition Disks: Vortex at Dead Zone or Planet-carved Gap Edges?}",
+    journal = {\apj},
+   keywords = {accretion, accretion disks, hydrodynamics, methods: numerical, protoplanetary disks, Astrophysics - Earth and Planetary Astrophysics, Astrophysics - Solar and Stellar Astrophysics},
+      year = 2017,
+      month = dec,
+     volume = {851},
+     number = {2},
+       eid = {89},
+      pages = {89},
+        doi = {10.3847/1538-4357/aa9a3f},
+archivePrefix = {arXiv},
+     eprint = {1711.03548},
+primaryClass = {astro-ph.EP},
+     adsurl = {[https://ui.adsabs.harvard.edu/abs/2017ApJ...851...89R](https://ui.adsabs.harvard.edu/abs/2017ApJ...851...89R)},
+    adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}
+
+
+@article{TarczayNehez2026,
+    author = {Tarczay-Neh{\'e}z, D{\'o}ra},
+    date = {2026/02/03},
+    date-added = {2026-02-03 12:16:24 +0100},
+    date-modified = {2026-02-03 12:16:24 +0100},
+    doi = {10.1007/s10569-026-10278-2},
+    id = {Tarczay-Neh{\'e}z2026},
+    isbn = {1572-9478},
+    journal = {Celestial Mechanics and Dynamical Astronomy},
+    number = {1},
+    pages = {6},
+    title = {Trajectory-based dust evolution in disks: first results from the RAPID simulation code},
+    url = {https://doi.org/10.1007/s10569-026-10278-2},
+    volume = {138},
+    year = {2026},
+    bdsk-url-1 = {https://doi.org/10.1007/s10569-026-10278-2}}
+}
+

rapidsim-0.1.0/include/core/config.h

@@ -0,0 +1,92 @@
+/**
+ * @file config.h
+ * @brief Global configuration, physical constants, and file handles.
+ * * This file contains global variable declarations, preprocessor macros for 
+ * physical constants, unit conversion factors, and external file pointers 
+ * used for simulation logging and data management.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <stdio.h> 
+#include <math.h>  
+
+/** @brief Total number of representative dust particles in the simulation. */
+extern int particle_number;
+
+/** @name Simulation Output File Pointers
+ * External file handles used for real-time tracking and data export.
+ */
+/**@{*/
+extern FILE *drift_timescale_file;      /**< Pointer to the file tracking dust radial drift timescales. */
+extern FILE *current_info_file;         /**< Pointer to the file for general simulation status and logging. */	
+extern FILE *load_dust_particles_file;  /**< Pointer to the input file used for loading initial particle states. */
+/**@}*/
+
+#include "simulation_types.h"
+
+/** @name Physical Constants and Unit Conversions
+ * Macros defining fundamental constants and factors to maintain the simulation's unit system.
+ */
+/**@{*/
+/** @brief Factor to convert surface density to internal simulation units. */
+#define SURFACE_DENSITY_CONVERSION_FACTOR       1.12521e-7   
+
+/** @brief Gravitational constant in dimensionless form (standardized to 1.0). */
+#define G_DIMENSIONLESS                         1.0          
+
+/** @brief Conversion factor from \f$cm/s\f$ to \f$AU/year\f$, normalized by \f$2\pi\f$. */
+#define CM_PER_SEC_TO_AU_PER_YEAR_2PI           3.35725e-07  
+
+/** @brief Mass of the Sun in grams (CGS units). */
+#define SOLAR_MASS_IN_GRAMS                     1.989e33     
+
+/** @brief One Astronomical Unit in centimeters (CGS units). */
+#define AU_IN_CM                                1.496e13     
+
+/** @brief Factor to convert days to years. */
+#define DAYS_PER_YEAR_CONVERSION_FACTOR         2.737850787e-3
+
+/** @brief Factor to convert years to days. */
+#define YEARS_PER_DAY_CONVERSION_FACTOR         365.242199
+
+/** @brief Safety maximum value for timestep calculations. */
+#define TIMESTEP_MAX_SAFETY_LIMIT               -10000.0
+
+/** @brief Numerical safety factor used for rounding or thresholding operations. */
+#define ROUNDING_FACTOR                         1.0          
+
+/** @brief Current version string of the RAPID simulation core. */
+#define SIM_VERSION                             "2.2.2"
+/**@}*/
+
+/** @name File and Directory Name Constants
+ * Global string constants defining the naming convention for input/output files.
+ */
+/**@{*/
+extern const char * const kInitialGasProfileFileName;   			/**< Filename for the initial gas profile. */
+extern const char * const kInitialDustProfileFileName;  			/**< Filename for the initial dust profile. */
+extern const char * const kGasDensityProfileFilePrefix; 			/**< Prefix for time-dependent gas density snapshots. */
+extern const char * const kDustAccumulationFileName;    			/**< Filename for tracking accumulated dust mass. */
+extern const char * const kDustParticleEvolutionFile;   			/**< Filename for Lagrangian particle trajectory data. */
+extern const char * const kDriftTimescaleFileName;      			/**< Filename for storing drift timescale analysis. */
+extern const char * const kDustDensityProfileFilePrefix; 			/**< Prefix for Eulerian dust density snapshots. */
+extern const char * const kMicronDustDensityProfileFilePrefix; 		/**< Prefix for small (micron) dust snapshots. */
+extern const char * const kDustMicronParticleEvolutionFile; 		/**< Evolution file for small dust populations. */
+extern const char * const kDiskConfigFile;              			/**< Filename for the primary disk configuration input. */
+extern const char * const kLogFilesDirectory;           			/**< Directory path where log files are stored. */
+extern const char * const kConfigFilesDirectory;        			/**< Directory path where configuration files reside. */
+extern const char * const kFileNamesSuffix;             			/**< Common suffix for output files for ASCII files (e.g., .dat or .txt). */
+extern const char * const kCurrentInfoFile;             			/**< Filename for general runtime info. */
+extern const char * const kDustParticleSizeFileName;    			/**< Filename for particle size distribution data. */
+extern const char * const kMicronDustParticleSizeFileName;    		/**< Filename for micron-sized particle size distribution data. */
+extern const char * const kCurrentRuntimeInfoFile;      			/**< Filename for high-frequency runtime diagnostics. */
+extern const char * const kSnapshotOutputFileNamePrefix;			/**< Filename for HDF5 snapshot output. */
+extern const char * const kTimeSeriesForMassAccumulatinFileName; 	/**< Filename for HDF mass accumulation file. */
+extern const char * const kFileNamesHDF5Suffix;						/**< Common suffix for output files for HDF5 files (e.g., .dat or .txt). */
+
+extern const int kTerminalWidth;                                    /**< Width of the terminal for formatted output. */
+/**@}*/
+
+#endif // CONFIG_H

rapidsim-0.1.0/include/core/init_tool_module.h

@@ -0,0 +1,71 @@
+/**
+ * @file init_tool_module.h
+ * @brief Initialization tools and default option management.
+ *
+ * This module defines the setup structures and functions used to bridge
+ * configuration files with the internal disk simulation parameters.
+ */
+
+#ifndef INIT_TOOL_MODULE_H
+#define INIT_TOOL_MODULE_H
+
+#include <stdbool.h>
+#include "simulation_types.h"
+
+/**
+ * @struct InitializeDefaultOptions
+ * @brief Configuration structure for setting up the initial disk model.
+ * * This structure holds all the raw input parameters required to define
+ * the disk's physical and numerical setup before the simulation starts.
+ */
+typedef struct {
+    bool    use_cutoff;                     /**< Initial condition profile type: false = Normal Power-Law, true = Exponential Cutoff. */
+    int     n_grid_points;                  /**< Number of radial grid cells. */
+    int     n_dust_particles;               /**< Total number of Lagrangian dust particles. */
+    double  r_inner;                        /**< Inner disk boundary in AU. */
+    double  r_outer;                        /**< Outer disk boundary in AU. */
+    double  sigma0_gas_au;                  /**< Gas surface density normalization at 1 AU. */
+    double  sigma_exponent;                 /**< Power-law exponent for the surface density profile. */
+    double  r_cutoff;                       /**< Characteristic exponential scaling/tapering radius in AU (used if ic_type == 2). */
+    double  n_for_cutoff;                   /**< Shape/sharpness parameter for the exponential cutoff (typically 2.0 - gamma). */
+    double  alpha_viscosity;                /**< Background Shakura-Sunyaev alpha viscosity. */
+    double  star_mass;                      /**< Central star mass in solar units. */
+    double  aspect_ratio;                   /**< Disk aspect ratio, \f$h=H/r\f$, at 1 AU. */
+    double  flaring_index;                  /**< Power-law index for disk flaring. */
+    double  density_floor;                  /**< Minimum allowed gas surface density (Σ_min) to prevent numerical underflow or negative densities. */
+    double  dust_density_floor;             /**< Minimum allowed dust surface density (Σ_min) to prevent numerical underflow or negative densities. */
+    double  deadzone_r_inner;               /**< Inner radius of the Dead Zone in AU. */
+    double  deadzone_r_outer;               /**< Outer radius of the Dead Zone in AU. */
+    double  deadzone_dr_inner;              /**< Smoothing width for the inner Dead Zone edge in AU. */
+    double  deadzone_dr_outer;              /**< Smoothing width for the outer Dead Zone edge in AU. */
+    double  deadzone_alpha_mod;             /**< Reduced alpha viscosity within the Dead Zone. */
+    double  dust_to_gas_ratio;              /**< Global dust-to-gas mass ratio, \f$\epsilon\f$. */
+    double  total_disk_mass;                /**< Total mass of the two components of the disk. */
+    double  one_size_particle_cm;           /**< Size of the large dust population in \f$cm\f$. */
+    double  two_pop_ratio;                  /**< Mass ratio between the two dust populations. */
+    double  micro_size_cm;                  /**< Size of the small (micron) dust population in \f$cm\f$. */
+    double  drift_factor;                   /**< Scaling factor for radial drift velocity. */
+    double  fragmentation_factor;           /**< Efficiency factor for dust fragmentation. */
+    char output_base_path[MAX_PATH_LEN];    /**< Base directory path for simulation output. */
+    double dust_density_g_cm3;              /**< Intrinsic material density of dust grains (e.g., \f 1.6g/cm^3\f$). */
+} InitializeDefaultOptions;
+
+/**
+ * @brief populates the InitializeDefaultOptions structure with hardcoded defaults.
+ * * Useful for ensuring all parameters have safe initial values before 
+ * reading from a configuration file.
+ * * @param[out] Pointer to the options structure to be initialized.
+ */
+void initializeDefaultOptions(InitializeDefaultOptions *opt);
+
+/**
+ * @brief Executes the full initialization sequence.
+ * * Converts the raw options into a physical disk state, populating the 
+ * internal arrays for density, pressure, and velocity.
+ * * @param[in]  opts                Pointer to the configured initialization options.
+ * @param[out] output_disk_params  Pointer to the disk parameters structure to be populated.
+ * @return                     Returns 0 on success, non-zero on failure.
+ */
+int runInitialization(InitializeDefaultOptions *opts, DiskParameters *output_disk_params, SimulationOptions *sim_opts);
+
+#endif // INIT_TOOL_MODULE_H

rapidsim-0.1.0/include/core/integrator.h

@@ -0,0 +1,42 @@
+/**
+ * @file integrator.h
+ * @brief Numerical integration routines for particle trajectories and growth.
+ *
+ * This header defines the integrators used to evolve the radial position and 
+ * physical size of Lagrangian dust particles over time.
+ */
+
+#ifndef INTEGRATOR_H
+#define INTEGRATOR_H
+
+#include "disk_model.h"      
+#include "simulation_types.h"
+
+/**
+ * @brief Performs a fourth-order Runge-Kutta (RK4) integration step for a single dust particle.
+ *
+ * This function evolves both the radial position of the particle and its physical radius (size)
+ * over a given timestep. It accounts for the aerodynamic drag (radial drift) and, 
+ * if enabled, the dust growth/fragmentation processes by interpolating local 
+ * gas properties from the Eulerian grid.
+ *
+ * @param[in]  actual_time            Current simulation time.
+ * @param[in]  particle_radius        Current physical radius (grain size) of the dust particle.
+ * @param[in]  dust_surfacedensity    Pointer to the array containing the dust surface density distribution.
+ * @param[in]  particle_distance_grid Pointer to the grid used for particle-related spatial calculations.
+ * @param[in]  actual_timestep        The time step size (dt) for the integration.
+ * @param[in]  particle_distance      Current radial distance of the particle from the central star.
+ * @param[out] particle_distance_new  Pointer to store the updated radial distance after the RK4 step.
+ * @param[out] particle_radius_new    Pointer to store the updated grain size after the growth step.
+ * @param[in]  disk_params            Pointer to the structure containing physical disk parameters and gas arrays.
+ * @param[in]  simulation_options     Pointer to the simulation configuration (e.g., enabling growth models).
+ *
+ * @note The function uses four intermediate slope calculations (k1, k2, k3, k4) to ensure 
+ * fourth-order accuracy in the radial trajectory.
+ */
+void integrateParticleRungeKutta4(double actual_time, double particle_radius, const double *dust_surfacedensity, const double *particle_distance_grid, 
+								  double actual_timestep, double particle_distance, double *particle_distance_new, double *particle_radius_new, 
+								  const DiskParameters *disk_params, const SimulationOptions *simulation_options);
+
+#endif // INTEGRATOR_H
+

rapidsim-0.1.0/include/core/particle_data.h

@@ -0,0 +1,63 @@
+/**
+ * @file particle_data.h
+ * @brief Data structures and utilities for managing dust particle arrays.
+ *
+ * Defines the ParticleData container used to store particle positions,
+ * masses, and surface densities, along with allocation and cleanup
+ * routines used by the simulation.
+ */
+
+#ifndef PARTICLE_DATA_H
+#define PARTICLE_DATA_H
+
+#include <stddef.h>
+
+/**
+ * @brief Container for all particle‑related arrays used in the simulation.
+ *
+ * This structure stores dynamically allocated arrays that describe the
+ * spatial distribution, mass distribution, and surface densities of both
+ * regular dust particles and micron‑sized dust particles.  
+ *
+ * The arrays are allocated based on the number of particles and whether
+ * the two‑population dust model is enabled.
+ */
+typedef struct {
+    double (*particle_distance_array)[2];          /**< Radial positions of dust particles (2 columns: r and dr). */
+    double (*micron_particle_distance_array)[2];   /**< Radial positions of micron‑sized dust particles. */
+    double *dust_particle_mass_grid;               /**< Mass grid for dust particles. */
+    double *massmicradial_grid;                    /**< Mass grid for micron‑sized dust particles. */
+    double (*dust_particle_mass_array)[5];         /**< Dust particle mass evolution array (5 columns per particle). */
+    double (*micron_dust_particle_mass_array)[5];  /**< Micron dust mass evolution array. */
+    double *dust_surfacedensity;                   /**< Dust surface density profile. */
+    double *micron_dust_surfacedensity;            /**< Micron dust surface density profile. */
+    double *particle_distance_grid;                /**< Radial grid for dust particles. */
+    double *micron_particle_distance_grid;         /**< Radial grid for micron dust particles. */
+    size_t allocated_particle_number;              /**< Number of particles allocated in memory. */
+} ParticleData;
+
+/**
+ * @brief Allocates memory for particle‑related arrays.
+ *
+ * This function initializes all arrays inside a ParticleData structure
+ * based on the number of particles and whether the two‑population dust
+ * model is enabled.
+ *
+ * @param particle_data Pointer to the ParticleData structure to initialize.
+ * @param particle_count Number of dust particles to allocate.
+ * @param is_twopop_enabled Non‑zero if the micron‑dust population should also be allocated.
+ * @return 0 on success, non‑zero on allocation failure.
+ */
+int allocateParticleData(ParticleData *particle_data, size_t particle_count, int is_twopop_enabled);
+
+/**
+ * @brief Frees all memory allocated inside a ParticleData structure.
+ *
+ * This function releases all dynamically allocated arrays and resets
+ * the structure fields to NULL or zero.
+ *
+ * @param particle_data Pointer to the ParticleData structure to free.
+ */
+void freeParticleData(ParticleData *particle_data);
+
+#endif // PARTICLE_DATA_H

rapidsim-0.1.0/include/core/photoevaporation_wrapper.h

@@ -0,0 +1,15 @@
+#ifndef PHOTOEVAPORATION_WRAPPER_H
+#define PHOTOEVAPORATION_WRAPPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// void* -ként adjuk át, így a C és a C++ is csont nélkül elfogadja anélkül, hogy ismernék a típust
+void computePhotoevaporationSink(void *disk_opaque);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PHOTOEVAPORATION_WRAPPER_H

rapidsim-0.1.0/include/core/simulation_core.h

@@ -0,0 +1,76 @@
+/**
+ * @file simulation_core.h
+ * @brief Core routines for advancing the disk–dust system in time.
+ *
+ * Contains the main physical update functions used during the simulation:
+ * dust drift calculation, timestep determination, and the full time
+ * integration loop that evolves gas and dust according to the selected
+ * snapshot mode.
+ */
+
+#ifndef SIMULATION_CORE_H
+#define SIMULATION_CORE_H
+
+#include "particle_data.h"
+#include "disk_model.h"        
+#include "simulation_types.h"  
+
+
+/**
+ * @brief Computes the radial drift velocity of dust particles in 1D.
+ *
+ * This function calculates the drift velocity of a dust particle based on
+ * its size, the local pressure gradient, gas surface density, gas velocity,
+ * and radial position. The result is written into @p drift_velocity.
+ *
+ * @param particle_radius Radius of the dust particle.
+ * @param pressure_gradient Local radial pressure gradient.
+ * @param gas_surface_density Gas surface density at the particle location.
+ * @param gas_velocity Radial gas velocity.
+ * @param radial_distance Radial distance of the particle from the star.
+ * @param drift_velocity Output pointer for the computed drift velocity.
+ * @param disk_params Pointer to the disk parameter structure.
+ */
+void calculate1DDustDrift(double particle_radius, double pressure_gradient, double gas_surface_density, double gas_velocity, double radial_distance, double *drift_velocity, const DiskParameters *disk_params);
+
+/**
+ * @brief Gets the maximum drift velocity of dust particles.
+ *
+ * This function iterates through all dust particles and computes their drift velocities,
+ * returning the maximum absolute value found.
+ *
+ * @param particle_data Pointer to the particle data structure.
+ * @param particle_number Number of dust particles.
+ * @param disk_params Pointer to the disk parameter structure.
+ * @param mode SnapshotMode indicating the type of snapshot being processed.
+ * @return The maximum drift velocity.
+ */
+double getMaximumDriftVelocity(const ParticleData *particle_data, int particle_number, const DiskParameters *disk_params, SnapshotMode mode);
+
+/**
+ * @brief Computes the simulation time step based on disk parameters.
+ *
+ * The time step is typically determined by stability constraints such as
+ * Courant conditions or drift/growth timescales.
+ *
+ * @param disk_params Pointer to the DiskParameters structure.
+ * @param max_drift_v The maximum drift velocity of the dust particles.
+ * @return The computed time step.
+ */
+double calculateTimeStep(const DiskParameters *disk_params, double max_drift_v);
+
+/**
+ * @brief Performs the full time integration loop for the simulation.
+ *
+ * This function advances the system in time according to the selected
+ * snapshot mode, updating disk quantities, dust evolution, and writing
+ * output files when necessary.
+ *
+ * @param mode Snapshot writing mode (e.g., none, periodic, final only).
+ * @param disk_params Pointer to the DiskParameters structure to update.
+ * @param sim_opts Pointer to the SimulationOptions structure.
+ * @param output_files Pointer to the OutputFiles structure for writing results.
+ */
+void timeIntegrationForTheSystem(SnapshotMode mode, DiskParameters *disk_params, SimulationOptions *sim_opts, OutputFiles *output_files);
+
+#endif // SIMULATION_CORE_H