PartBins.h

Go to the documentation of this file.

//
// Class PartBins
//   Defines a structure to hold energy bins and their associated data
//
// Copyright (c) 2007-2020, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//

#ifndef OPAL_Bins_HH
#define OPAL_Bins_HH

#include <gsl/gsl_histogram.h>

#include <functional>
#include <memory>
#include <vector>

class Inform;

class PartBins {

public:


    PartBins(int bins, int sbins);

    virtual ~PartBins();


    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;}

    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);
    }

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

    void sortArray();

 private:
    void calcHBins();
    void calcExtrema();
    void setBinEmitted(int bin) {binsEmitted_m[bin] = true;}

 public:
    void resetPartInBin_cyc(size_t newPartNum[], int binID);
    void updatePartInBin_cyc(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::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; }

    int getLastemittedBin() {return nemittedBins_m; }

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

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

    size_t getTotalNum();

    size_t getTotalNumPerBin(int b);


protected:

    int nemittedBins_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:
    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:
    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