ParticleSizeManager.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
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the Software), to deal with
 * 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:
 */
 
#ifndef LM_PARTICLE_SIZE_MANAGER_H
#define LM_PARTICLE_SIZE_MANAGER_H
 
#include <vector>
#include <algorithm>
#include <stdexcept>
#include <string>
#include <map>
#include "core/Types.h"
#include "core/Exceptions.h"
 
// Ensure required types are defined
#ifndef particle_t
typedef uint32_t particle_t;
#endif
 
#ifndef site_size_t
typedef uint32_t site_size_t;
#endif
 
namespace lm {
namespace rdme {

class ParticleSizeManager {
public:
    explicit ParticleSizeManager(uint32_t maxParticleTypes = 256);

    ~ParticleSizeManager() = default;

    void setParticleSize(particle_t particleType, uint32_t size);

    uint32_t getParticleSize(particle_t particleType) const;

    uint32_t calculateSiteOccupancy(const particle_t* particles, site_size_t count) const;

    bool canAddParticle(const particle_t* particles, site_size_t count,
                       particle_t newParticle, uint32_t maxCapacity) const;

    bool canAddParticles(const particle_t* particles, site_size_t count,
                        const particle_t* newParticles, site_size_t newCount,
                        uint32_t maxCapacity) const;

    uint32_t getMaxParticleCount(particle_t particleType, uint32_t currentOccupancy,
                                uint32_t maxCapacity) const;

    void validateConfiguration() const;

    const std::vector<uint32_t>& getParticleSizes() const;

    void clear();

    size_t getConfiguredParticleCount() const;

    void setParticleSizesFromDict(const std::map<particle_t, uint32_t>& sizeDict);

    std::map<particle_t, uint32_t> getParticleSizesDict() const;
 
private:
    std::vector<uint32_t> particleSizes_;  
    uint32_t maxParticleTypes_;            

    void ensureCapacity(particle_t particleType);
};

class ParticleSizeException : public Exception {
public:
    explicit ParticleSizeException(const char* message)
        : Exception(message) {}
 
    explicit ParticleSizeException(const std::string& message)
        : Exception(message.c_str()) {}
};
 
} // namespace rdme
} // namespace lm
 
#endif // LM_PARTICLE_SIZE_MANAGER_H