PHG4PSScanGenerator.h

Go to the documentation of this file.

#ifndef PHG4PSScanGenerator_H__
#define PHG4PSScanGenerator_H__
 
#include "PHG4ParticleGeneratorBase.h"
 
#include <map>
#include <vector>
 
class PHG4InEvent;
class PHCompositeNode;
 
class PHG4PSScanGenerator: public PHG4ParticleGeneratorBase {
 
public:
 
        enum FUNCTION {
                Uniform, Gaus
        };
 
        PHG4PSScanGenerator(const std::string &name = "EVTGENERATOR");
        virtual ~PHG4PSScanGenerator() {
        }
 
        int InitRun(PHCompositeNode *topNode);
        int process_event(PHCompositeNode *topNode);
 
        void add_particles(const std::string &name, const unsigned int count);
 
        void add_particles(const int pid, const unsigned int count);
 
        void set_t0(const double t0);
 
        void set_eta_range(const double eta_min, const double eta_max);
 
        void set_phi_range(const double phi_min, const double phi_max);
 
        void set_pt_range(const double pt_min, const double pt_max,
                        const double pt_gaus_width = 0);
 
        void set_p_range(const double p_min, const double p_max,
                        const double p_gaus_width = 0);
 
        void set_vertex_distribution_function(FUNCTION x, FUNCTION y, FUNCTION z);
 
        void set_vertex_distribution_mean(const double x, const double y,
                        const double z);
 
        void set_vertex_distribution_width(const double x, const double y,
                        const double z);
 
        void set_existing_vertex_offset_vector(const double x, const double y,
                        const double z);
 
        void set_vertex_size_function(FUNCTION r);
 
        void set_vertex_size_parameters(const double mean, const double width);
 
        void set_pxpypz_range(const double x_min, const double x_max,
                        const double y_min, const double y_max, const double z_min,
                        const double z_max);
 
        double get_px_step() const {
                return _px_step;
        }
 
        void set_px_step(double pxStep) {
                _px_step = pxStep;
        }
 
        double get_py_step() const {
                return _py_step;
        }
 
        void set_py_step(double pyStep) {
                _py_step = pyStep;
        }
 
        double get_pz_step() const {
                return _pz_step;
        }
 
        void set_pz_step(double pzStep) {
                _pz_step = pzStep;
        }
 
private:
 
        int _event;
        double _px_step;
        double _py_step;
        double _pz_step;
 
        double smearvtx(const double position, const double width,
                        FUNCTION dist) const;
        // these need to be stored separately until run time when the names
        // can be translated using the GEANT4 lookup
        std::vector<std::pair<int, unsigned int> > _particle_codes; // <pdgcode, count>
        std::vector<std::pair<std::string, unsigned int> > _particle_names; // <names, count>
        FUNCTION _vertex_func_x;
        FUNCTION _vertex_func_y;
        FUNCTION _vertex_func_z;
        double _t0;
        double _vertex_x;
        double _vertex_y;
        double _vertex_z;
        double _vertex_width_x;
        double _vertex_width_y;
        double _vertex_width_z;
        double _vertex_offset_x;
        double _vertex_offset_y;
        double _vertex_offset_z;
        FUNCTION _vertex_size_func_r;
        double _vertex_size_mean;
        double _vertex_size_width;
        double _eta_min;
        double _eta_max;
        double _phi_min;
        double _phi_max;
        double _pt_min;
        double _pt_max;
        double _pt_gaus_width;
        double _p_min;
        double _p_max;
        double _p_gaus_width;
 
        double _px_min, _px_max;
        double _py_min, _py_max;
        double _pz_min, _pz_max;
 
        PHG4InEvent* _ineve;
};
 
#endif