PartBins.h

Go to the documentation of this file.

#ifndef OPAL_Bins_HH
#define OPAL_Bins_HH

#ifndef PartBinTest
#include "Algorithms/PBunchDefs.h"
#else
#include "ranlib.h"
#define Inform ostream
#endif

#include <gsl/gsl_rng.h>
#include <gsl/gsl_histogram.h>
#include <gsl/gsl_cdf.h>
#include <gsl/gsl_randist.h>


class PartBins {

public:


    PartBins(int bins, int sbins);

    virtual ~PartBins();


    inline int getDelBinCont(int bin) {
        int a = nDelBin_m[bin];
        reduce(a, a, OpAddAssign());
        return a;
    }


    void fill(std::vector<double> &p) {
        tmppart_m.push_back(p);
        isEmitted_m.push_back(false);
    }

    size_t getNp() {
        //    size_t a = tmppart_m.size();
        // reduce(a, a, OpAddAssign());
        // return a;
        return tmppart_m.size();
    }

    void setPartNum(int bin, long long num) {nBin_m[bin] = num;}

    void setBinEmitted(int bin) {binsEmitted_m[bin] = true;}

    bool getBinEmitted(int bin) {return binsEmitted_m[bin];}

    bool doEmission() {return getNp() > 0;}

    bool isEmitted(int n, int /*bin*/) {
        return isEmitted_m[n]; //(isEmitted_m[n][0]==1) && (isEmitted_m[n][1] == bin);
    }

    void setEmitted(int n, int /*bin*/) {
        isEmitted_m[n] = true;
    }

    void updatePartPos(int n, int /*bin*/, double z) {
        tmppart_m[n][2] = z;
    }

    void updateExtramePos(int bin, double dz) {
        xbinmax_m[bin] += dz;
        xbinmin_m[bin] += dz;
    }

    bool getPart(size_t n, int bin, std::vector<double> &p);

    void sortArray();

    void calcHBins();
    size_t getSum();
    void calcGlobalExtrema();
    void calcExtrema();
    void getExtrema(double &min, double &max) {
        min = xmin_m;
        max = xmax_m;
    }

    void updateStatus(int bunchCount, size_t nPartInBin);
    void resetPartInBin(size_t newPartNum[]);
    void resetPartInBin_cyc(size_t newPartNum[], int binID);
    void updatePartInBin(size_t countLost[]);
    void updatePartInBin_cyc(size_t countLost[]);

    void updateDeletedPartsInBin(size_t countLost[]) ;

    void setGamma(double gamma) { gamma_m = gamma;}
    double getGamma() {return gamma_m;}

protected:

    double gamma_m;
    int getBin(double x);

    int bins_m;
    int sBins_m;

    double xmin_m;
    double xmax_m;

    std::unique_ptr<double[]> xbinmin_m;
    std::unique_ptr<double[]> xbinmax_m;

    double hBin_m;

    std::vector< std::vector<double> > tmppart_m;
    std::vector< bool > isEmitted_m;
    //  std::vector< bool > binsEmitted_m;
    std::unique_ptr<bool[]> binsEmitted_m;

public:

    Inform &print(Inform &os);

    int getSBins() { return sBins_m; };

    virtual int getNBins() {return gsl_histogram_bins(h_m.get()) / sBins_m; }

    virtual int getNSBins() {return gsl_histogram_bins(h_m.get()); }

    int getBinToEmit() {
        int save;
        if(nemittedBins_m < getNBins()) {
            save =  nemittedBins_m;
            nemittedBins_m++;
            return save;
        } else
            return -1;
    }

    int getSBinToEmit() {
        int save;
        if(nemittedSBins_m < getNSBins()) {
            save = nemittedSBins_m;
            nemittedSBins_m++;
            return save;
        } else
            return -1;
    }

    int getLastemittedBin() {return nemittedBins_m; }

    void setActualemittedBin(int bin) {nemittedBins_m = bin; }

    void resetBins() {
        h_m.reset(nullptr);
    }

    virtual bool weHaveBins() {
        return h_m != nullptr;
    }

    void sortArrayT();

    inline void setHistogram(gsl_histogram *h) { h_m.reset(h);}

    virtual inline size_t getGlobalBinCount(int bin) {
        size_t a = gsl_histogram_get(h_m.get(), bin);
        reduce(a, a, OpAddAssign());
        return a;
    }

    virtual inline size_t getLocalBinCount(int bin) {
        size_t ret = 0;
        for(int i = sBins_m * bin; i < sBins_m * (bin + 1); i++) {
            ret += gsl_histogram_get(h_m.get(), i);
        }
        return ret;
    }

    inline size_t getLocalSBinCount(int bin) { return gsl_histogram_get(h_m.get(), bin);}


    size_t getTotalNum();

    size_t getTotalNumPerBin(int b);


protected:

    int nemittedBins_m;

    int nemittedSBins_m;

    std::unique_ptr<size_t[]> nBin_m;

    std::unique_ptr<size_t[]> nDelBin_m;

    std::unique_ptr<gsl_histogram> h_m;

};

inline Inform &operator<<(Inform &os, PartBins &p) {
    return p.print(os);
}


class AscendingLocationSort: public std::binary_function< std::vector<double>, std::vector<double>, bool> {
public:
    AscendingLocationSort(int direction = 0): direction_m(direction)
    {;}

    bool operator()(const std::vector<double>& first_part, const std::vector<double>& second_part) {
        return first_part[direction_m] < second_part[direction_m];
    }
private:
    int direction_m;
};

class DescendingLocationSort: public std::binary_function< std::vector<double>, std::vector<double>, bool> {
public:
    DescendingLocationSort(int direction = 0): direction_m(direction)
    {;}

    bool operator()(const std::vector<double>& first_part, const std::vector<double>& second_part) {
        return first_part[direction_m] > second_part[direction_m];
    }
private:
    int direction_m;
};

#endif // OPAL_Bins_HH