IntMpdRdmeSolverExtended.h

Go to the documentation of this file.

/*
 * University of Illinois Open Source License
 * Copyright 2024 Luthey-Schulten Group,
 * All rights reserved.
 *
 * Developed by: Luthey-Schulten Group
 *               University of Illinois at Urbana-Champaign
 *               http://www.scs.uiuc.edu/~schulten
 *
 * Extended IntMpdRdmeSolver with particle size support
 */
 
#ifndef LM_RDME_INTMPDRDMESOLVEREXTENDED_H
#define LM_RDME_INTMPDRDMESOLVEREXTENDED_H
 
#include <map>
#include <string>
#include "rdme/IntMpdRdmeSolver.h"
#include "cuda/particle_size_kernels.cuh"
#include "core/Types.h"
 
namespace lm {
namespace rdme {

class IntMpdRdmeSolverExtended : public IntMpdRdmeSolver
{
public:
    IntMpdRdmeSolverExtended();
    virtual ~IntMpdRdmeSolverExtended();
 
    // Override parent methods
    virtual void buildModel(const uint numberSpeciesA,
                           const uint numberReactionsA,
                           const uint* initialSpeciesCountsA,
                           const uint* reactionTypesA,
                           const double* KA,
                           const int* SA,
                           const uint* DA,
                           const uint kCols) override;
 
    virtual void buildDiffusionModel(const uint numberSiteTypesA,
                                    const double* DFA,
                                    const uint* RLA,
                                    lattice_size_t latticeXSize,
                                    lattice_size_t latticeYSize,
                                    lattice_size_t latticeZSize,
                                    site_size_t particlesPerSite,
                                    const unsigned int bytes_per_particle,
                                    si_dist_t latticeSpacing,
                                    const uint8_t* latticeData,
                                    const uint8_t* latticeSitesData,
                                    bool rowMajorData) override;
 
    virtual void runTimestep(CudaIntLattice* lattice, uint32_t timestep) override;
 
    // New particle size methods
    void setParticleSizes(const uint32_t* sizes, uint32_t numTypes);
    void enableParticleSizeChecking(bool enable = true);
    bool isParticleSizeCheckingEnabled() const { return particleSizeEnabled; }
 
    // Validation and statistics
    uint32_t validateConstraints(CudaIntLattice* lattice);
    void getOccupancyStatistics(CudaIntLattice* lattice, uint32_t* occupancyCounts,
                               uint32_t maxOccupancy);
 
    // Get particle size info
    uint32_t getParticleSize(particle_t particleType) const;
 
private:
    // Particle size data
    uint32_t* hostParticleSizes;      // Host copy of particle sizes
    uint32_t numParticleTypes;        // Number of particle types
    bool particleSizeEnabled;         // Enable size checking
    bool particleSizesInitialized;    // Flag for initialization
 
    // GPU memory for extended functionality
    uint8_t* deviceReactionMatrix;    // Device copy of reaction matrix (int8_t -> uint8_t)
    uint8_t* deviceReactionLocationMatrix; // Device copy of RL matrix
 
    // Internal methods
    void initializeParticleSizes();
    void copyReactionDataToDevice();
    void runStandardTimestep(CudaIntLattice* lattice, uint32_t timestep);
    void runSizeAwareTimestep(CudaIntLattice* lattice, uint32_t timestep);
 
    // Launch parameter calculation for size-aware kernels
    void calculateSizeAwareLaunchParameters(dim3* gridSize, dim3* blockSize,
                                           uint32_t latticeXSize,
                                           uint32_t latticeYSize,
                                           uint32_t latticeZSize);
};
 
} // namespace rdme
} // namespace lm
 
#endif // LM_RDME_INTMPDRDMESOLVEREXTENDED_H