gEventDataCollection.h

Go to the documentation of this file.

#pragma once
 
#include <gemc/gdata/gDataCollection.h>
#include "gEventHeader.h"
 
// C++
#include <map>
#include <string>
#include <vector>
 
constexpr const char* GEVENTDATA_LOGGER = "gevent_data";
 
struct GGeneratedParticleData
{
    std::string name;
 
    int pid = 0;
 
    int type = 1;
 
    int multiplicity = 1;
 
    double p = 0;
 
    double theta = 0;
 
    double phi = 0;
 
    double vx = 0;
 
    double vy = 0;
 
    double vz = 0;
};
 
using GGeneratedParticleBank = std::vector<GGeneratedParticleData>;
 
struct GAncestorData
{
    int    pid = 0;
    int    tid = 0;
    int    mtid = 0;
    double trackE = 0;
    double px = 0;
    double py = 0;
    double pz = 0;
    double vx = 0;
    double vy = 0;
    double vz = 0;
};
 
using GAncestorBank = std::vector<GAncestorData>;
 
namespace gevent_data {
 
inline auto defineOptions() -> GOptions {
    auto goptions = GOptions(GEVENTDATA_LOGGER);
    goptions      += geventheader::defineOptions();
    goptions      += gtrue_data::defineOptions();
    goptions      += gdigi_data::defineOptions();
    goptions      += gtouchable::defineOptions();
    return goptions;
}
 
} // namespace gevent_data
 
class GEventDataCollection : public GBase<GEventDataCollection>
{
public:
    GEventDataCollection(const std::shared_ptr<GOptions>& gopts, std::unique_ptr<GEventHeader> header)
        : GBase(gopts, GEVENTDATA_LOGGER), gevent_header(std::move(header)) {
    }
 
    void addDetectorTrueInfoData(const std::string& sdName, std::unique_ptr<GTrueInfoData> data);
 
    void addDetectorDigitizedData(const std::string& sdName, std::unique_ptr<GDigitizedData> data);
 
    [[nodiscard]] auto getHeader() const -> const std::unique_ptr<GEventHeader>& { return gevent_header; }
 
    [[nodiscard]] auto getDataCollectionMap() const
        -> const std::map<std::string, std::unique_ptr<GDataCollection>>& {
        return gdataCollectionMap;
    }
 
    void setGeneratedParticles(GGeneratedParticleBank particles) {
        generated_particles = std::move(particles);
    }
 
    void setGeneratedTrackedParticles(GGeneratedParticleBank particles) {
        generated_tracked_particles = std::move(particles);
    }
 
    [[nodiscard]] const GGeneratedParticleBank& getGeneratedParticles() const { return generated_particles; }
 
    [[nodiscard]] const GGeneratedParticleBank& getGeneratedTrackedParticles() const {
        return generated_tracked_particles;
    }
 
    void setAncestors(GAncestorBank ancestors) {
        ancestor_particles = std::move(ancestors);
        ancestor_bank_enabled = true;
    }
 
    [[nodiscard]] const GAncestorBank& getAncestors() const { return ancestor_particles; }
 
    [[nodiscard]] bool hasAncestorBank() const { return ancestor_bank_enabled; }
 
    [[nodiscard]] auto getEventNumber() const -> int { return gevent_header->getG4LocalEvn(); }
 
    static auto create(const std::shared_ptr<GOptions>& gopts) -> std::shared_ptr<GEventDataCollection> {
        auto header = GEventHeader::create(gopts);
        auto edc    = std::make_shared<GEventDataCollection>(gopts, std::move(header));
 
        auto digi_data = GDigitizedData::create(gopts);
        auto true_data = GTrueInfoData::create(gopts);
 
        edc->addDetectorDigitizedData("ctof", std::move(digi_data));
        edc->addDetectorTrueInfoData("ctof", std::move(true_data));
 
        return edc;
    }
 
private:
    std::unique_ptr<GEventHeader> gevent_header;
 
    std::map<std::string, std::unique_ptr<GDataCollection>> gdataCollectionMap;
 
    GGeneratedParticleBank generated_particles;
 
    GGeneratedParticleBank generated_tracked_particles;
 
    GAncestorBank ancestor_particles;
    bool          ancestor_bank_enabled = false;
 
    static std::atomic<int> globalEventDataCollectionCounter;
};