poll2_core.h

Go to the documentation of this file.

#ifndef POLL2_CORE_H
#define POLL2_CORE_H

#include <vector>

#include "PixieInterface.h"
#include "hribf_buffers.h"
#define maxEventSize 4095 // (0x1FFE0000 >> 17)

#define POLL2_CORE_VERSION "1.4.14"
#define POLL2_CORE_DATE "Aug. 17th, 2016"

// Maximum length of UDP data packet (in bytes)
#define MAX_ORPH_DATA 1464

typedef PixieInterface::word_t word_t;
typedef word_t eventdata_t[maxEventSize];

class MCA;

class MCA_args{
  private:
    bool running;
    bool useRoot;
    int totalTime;
    std::string basename;
    
    MCA *mca;

  public:   
    MCA_args();
    
    MCA_args(bool useRoot_, int totalTime_, std::string basename_);
    
    ~MCA_args();
    
    bool IsRunning(){ return running; }
    
    bool UseRoot(){ return useRoot; }
    
    int GetTotalTime(){ return totalTime; }
    
    std::string GetBasename(){ return basename; }
    
    MCA *GetMCA(){ return mca; }
    
    void SetUseRoot(bool state_=true){ useRoot = state_; }
    
    void SetTotalTime(int totalTime_){ totalTime = totalTime_; }
    
    void SetBasename(std::string basename_){ basename = basename_; }

    bool Initialize(PixieInterface *pif_);
    
    bool Step();
    
    bool CheckTime();
    
    void Zero();
    
    void Close(PixieInterface *pif_);
};

struct UDP_Packet {
    int Sequence; 
    int DataSize; 
    unsigned char Data[MAX_ORPH_DATA]; 
};

struct data_pack{
    int Sequence; 
    int DataSize; 
    int TotalEvents; 
    unsigned short Events; 
    unsigned short Cont; 
    unsigned char Data[4*(4050 + 4)]; 
    int BufLen; 
};

// Forward class declarations
class StatsHandler;
class Client;
class Server;
class Terminal;

class Poll{
  private:
    Terminal *poll_term_;
    std::vector<word_t> *partialEvents;
    
    double startTime; 
    double lastSpillTime; 

    struct tm *time_info;

    Client *client; 
    Server *server; 

    PixieInterface *pif; 
  
    // System flags and variables
    std::string sys_message_head; 
    bool kill_all; 
    bool do_start_acq; 
    bool do_stop_acq; 
    bool record_data; 
    bool do_reboot; 
    bool force_spill; 
    bool acq_running; 
    bool run_ctrl_exit; 
    bool had_error;
    bool file_open;
    time_t raw_time;

    // System MCA flags
    bool do_MCA_run; 
    MCA_args mca_args; 

    // Run control variables
    bool boot_fast; //
    bool insert_wall_clock; //
    bool is_quiet; //
    bool send_alarm; //
    bool show_module_rates; //
    bool zero_clocks; //
    bool debug_mode; //
    bool shm_mode; 
    bool pac_mode; 
    bool init; //
    double runTime; 

    // Options relating to output data file
    std::string output_directory; 
    std::string filename_prefix; 
    std::string output_title; 
    unsigned int next_run_num; 
    unsigned int output_format; 

    // The main output data file and related variables
    int current_file_num;
    PollOutputFile output_file;

    unsigned int udp_sequence; 
    unsigned int total_spill_chunks; 

    size_t n_cards;
    size_t threshWords;

    typedef std::pair<unsigned int, unsigned int> chanid_t;
    std::map<chanid_t, PixieInterface::Histogram> histoMap;

    StatsHandler *statsHandler;
    static const int statsInterval_ = 3; 

    const static std::vector<std::string> runControlCommands_;
    const static std::vector<std::string> paramControlCommands_;
    const static std::vector<std::string> pollStatusCommands_; 
    std::vector<std::string> commands_;
    
    data_pack AcqBuf; 
    
    void help();

    void pchan_help();

    void pmod_help();

    bool start_run(const bool &record_=true, const double &time_=-1.0);
    
    bool stop_run();
    
    void show_status();
    
    void show_thresh();

    void get_traces(int mod_, int chan_, int thresh_=0);

    std::vector<std::string> TabComplete(const std::string &value_, const std::vector<std::string> &valid_);

    bool ReadFIFO();
    
    void ReadScalers();

    void UpdateStatus();

    bool synch_mods();

    std::string get_filename();
    
    bool CloseOutputFile(const bool continueRun = false);
    
    bool OpenOutputFile(bool continueRun = false);
    
    int write_data(word_t *data, unsigned int nWords);

    void broadcast_data(word_t *data, unsigned int nWords);

    void broadcast_pac_data();

    bool SplitParameterArgs(const std::string &arg, int &start, int &stop);

  public:
    Poll();
    
    ~Poll();
    
    bool Initialize();
    
    // Set methods.
    void SetBootFast(bool input_=true){ boot_fast = input_; }
    
    void SetWallClock(bool input_=true){ insert_wall_clock = input_; }
    
    void SetQuietMode(bool input_=true){ is_quiet = input_; }
    
    void SetSendAlarm(bool input_=true){ send_alarm = input_; }
    
    void SetShowRates(bool input_=true){ show_module_rates = input_; }
    
    void SetZeroClocks(bool input_=true){ zero_clocks = input_; }
    
    void SetDebugMode(bool input_=true){ debug_mode = input_; }
    
    void SetShmMode(bool input_=true){ shm_mode = input_; }
    
    void SetPacmanMode(bool input_=true){ pac_mode = input_; }
    
    void SetNcards(const size_t &n_cards_){ n_cards = n_cards_; }
    
    void SetThreshWords(const size_t &thresh_){ threshWords = thresh_; }

    void SetTerminal(Terminal *term){ poll_term_ = term; };

    // Get methods.
    bool GetBootFast(){ return boot_fast; }
    
    bool GetWallClock(){ return insert_wall_clock; }
    
    bool GetQuietMode(){ return is_quiet; }
    
    bool GetSendAlarm(){ return send_alarm; }
    
    bool GetShowRates(){ return show_module_rates; }
    
    bool GetZeroClocks(){ return zero_clocks; }
    
    bool GetDebugMode(){ return debug_mode; }
    
    bool GetShmMode(){ return shm_mode; }
    
    bool GetPacmanMode(){ return pac_mode; }
    
    size_t GetNcards(){ return n_cards; }
    
    size_t GetThreshWords(){ return threshWords; }

    void PrintModuleInfo();
    
    void CommandControl();
        
    void RunControl();
    
    bool Close();
};
    
bool IsNumeric(const std::string &input_, const std::string &prefix_="", const std::string &msg_="");
    
std::string humanReadable(double size);

std::string pad_string(const std::string &input_, unsigned int length_);

std::string yesno(bool value_);

#endif