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