Globals.hpp

Go to the documentation of this file.

#ifndef __GLOBALS_HPP_
#define __GLOBALS_HPP_

#include <algorithm>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include <cstdlib>
#include <stdint.h>

#include "pugixml.hpp"

#include "pixie16app_defs.h"

#include "Exceptions.hpp"
#include "Messenger.hpp"

namespace pixie {
    typedef uint32_t word_t; 
    typedef uint16_t halfword_t; 
    typedef uint32_t bufword_t; 

    const pixie::word_t U_DELIMITER = (pixie::word_t)-1;

    const unsigned int TOTALREAD = 1000000;

    const pixie::word_t clockVsn = 1000;
    const size_t numberOfChannels = 16;
};

namespace readbuff {
    const int STATS = -10;
    const int ERROR = -100;
}

namespace TimingDefs {
    typedef std::pair<unsigned int, std::string> TimingIdentifier;
}

namespace strings {
    inline double to_double (std::string s) {
        std::istringstream iss(s);
        double value;
        if (!(iss >> value)) {
            std::stringstream ss;
            ss << "strings::to_double: Could not convert string '"
               << s << "' to double" << std::endl;
            throw ConversionException(ss.str());
        }
        return value;
    }

    inline int to_int (std::string s) {
        std::istringstream iss(s);
        int value;
        if (!(iss >> value)) {
            std::stringstream ss;
            ss << "strings::to_int: Could not convert string '"
               << s << "' to int" << std::endl;
            throw ConversionException(ss.str());
        }
        return value;
    }

    inline bool to_bool (std::string s) {
        std::transform(s.begin(), s.end(), s.begin(), ::tolower);
        if (s == "true" || s == "1")
            return true;
        else if (s == "false" || s == "0")
            return false;
        else {
            std::stringstream ss;
            ss << "strings::to_bool: Could not convert string '"
               << s << "' to bool" << std::endl;
            throw ConversionException(ss.str());
        }
    }

    inline std::vector<std::string> tokenize(std::string str,
                                             std::string delimiter) {
        std::string temp;
        std::vector<std::string> tokenized;
        while (str.find(delimiter) != std::string::npos) {
            size_t pos = str.find(delimiter);
            temp = str.substr(0, pos);
            str.erase(0, pos + 1);
            tokenized.push_back(temp);
        }
        tokenized.push_back(str);
        return tokenized;
    }
};

class Globals {
public:
    static Globals* get();
    ~Globals();

    bool hasReject() const { return hasReject_; }

    double adcClockInSeconds() const {return adcClockInSeconds_;}
    double clockInSeconds() const {return(clockInSeconds_);}
    double eventInSeconds() const {return eventInSeconds_; }
    double energyContraction() const { return energyContraction_; }
    double filterClockInSeconds() const { return filterClockInSeconds_; }
    double bigLength() const {return(bigLength_);}
    double bigLengthTime() const {return(bigLength_/speedOfLightBig_);}
    double mediumLength() const {return(mediumLength_);}
    double mediumLengthTime() const {return(mediumLength_/speedOfLightMedium_);}
    double neutronMass() const {return(neutronMass_);}
    double smallLength() const {return(smallLength_);}
    double smallLengthTime() const {return(smallLength_/speedOfLightSmall_);}
    double speedOfLight() const {return(speedOfLight_);}
    double speedOfLightBig() const {return(speedOfLightBig_);}
    double speedOfLightMedium() const {return(speedOfLightMedium_);}
    double speedOfLightSmall() const {return(speedOfLightSmall_);}
    double discriminationStart() const {return(discriminationStart_);}
    double qdcCompression() const {return (qdcCompression_);}
    double sigmaBaselineThresh() const {return(sigmaBaselineThresh_);}
    double siPmtSigmaBaselineThresh() const {return(siPmtSigmaBaselineThresh_);}
    double traceDelay() const {return(traceDelay_);}
    double traceLength() const {return(traceLength_);}
    double trapezoidalWalk() const {return(trapezoidalWalk_);}
    int eventWidth() const { return eventWidth_; }
    std::pair<unsigned int, unsigned int> waveformRange() const {return(waveformRange_);}
    std::pair<unsigned int, unsigned int> siPmtWaveformRange() const {return(siPmtWaveformRange_);}
    std::pair<double,double> smallVandlePars() {return(smallVandlePars_);}
    std::pair<double,double> mediumVandlePars() {return(mediumVandlePars_);}
    std::pair<double,double> bigVandlePars() {return(bigVandlePars_);}
    std::pair<double,double> singleBetaPars() {return(singleBetaPars_);}
    std::pair<double,double> doubleBetaPars() {return(doubleBetaPars_);}
    std::pair<double,double> pulserPars() {return(pulserPars_);}
    std::pair<double,double> tvandlePars() {return(tvandlePars_);}
    std::pair<double,double> liquidScintPars() {return(liquidScintPars_);}
    std::string configPath(std::string fileName) {
        std::stringstream ss;
        ss << configPath_ << fileName;
        return ss.str();
    }
    std::string revision() const { return revision_; }
    unsigned int maxWords() const { return maxWords_; }
    unsigned short numTraces() const { return numTraces_; }
    std::vector< std::pair<int, int> > rejectRegions() const {return reject_; };
private:
    Globals();
    Globals(Globals const&);
    void operator=(Globals const&); 
    static Globals* instance; 

    void SanityCheck();
    void WarnOfUnknownParameter(Messenger &m, pugi::xml_node_iterator &it);

    bool hasReject_;
    double adcClockInSeconds_; 
    double clockInSeconds_;
    double energyContraction_;
    double eventInSeconds_;
    double filterClockInSeconds_;
    double bigLength_;
    double mediumLength_;
    double neutronMass_;
    double smallLength_;
    double speedOfLight_;
    double speedOfLightBig_;
    double speedOfLightMedium_;
    double speedOfLightSmall_;
    double discriminationStart_;
    double qdcCompression_;
    double sigmaBaselineThresh_;
    double siPmtSigmaBaselineThresh_;
    double traceDelay_;
    double traceLength_;
    double trapezoidalWalk_;
    int eventWidth_; 
    std::pair<unsigned int, unsigned int> waveformRange_; 
    std::pair<unsigned int, unsigned int> siPmtWaveformRange_; 
    std::pair<double,double> smallVandlePars_;
    std::pair<double,double> mediumVandlePars_;
    std::pair<double,double> bigVandlePars_;
    std::pair<double,double> singleBetaPars_;
    std::pair<double,double> doubleBetaPars_;
    std::pair<double,double> pulserPars_;
    std::pair<double,double> tvandlePars_;
    std::pair<double,double> liquidScintPars_;
    std::string configPath_; 
    std::string revision_;
    unsigned int maxWords_;
    unsigned short numTraces_;
    std::vector< std::pair<int, int> > reject_;
};
#endif