Utils.h

/*
 *  MoMEMta: a modular implementation of the Matrix Element Method
 *  Copyright (C) 2016  Universite catholique de Louvain (UCL), Belgium
 *
 *  This program 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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <algorithm>
#include <string>
#include <vector>

#include <momemta/Types.h>

template <class T> std::vector<typename T::Scalar> toVector(const T& v) {
    return {v.E(), v.Px(), v.Py(), v.Pz()};
}

template <typename T>
std::vector<std::size_t> get_permutations(const std::vector<T>& from, const std::vector<T>& to) {

    std::vector<std::size_t> p(from.size());

    std::transform(from.begin(), from.end(), p.begin(), [&from, &to](const T& item) -> std::size_t {
        return std::distance(to.begin(), std::find(to.begin(), to.end(), item));
    });

    return p;
}

template <typename T>
void apply_permutations(std::vector<T>& vec, std::vector<std::size_t> const& p) {
    std::vector<T> sorted_vec(p.size());
    std::transform(p.begin(), p.end(), sorted_vec.begin(), [&vec](int i) { return vec[i]; });

    vec = sorted_vec;
}

LorentzVector getRandom4Vector(double maxE, double m=0);

std::string demangle(const char* name);

namespace cuba {

inline unsigned int createFlagsBitset(char verbosity, bool subregion, bool retainStateFile,
                                      unsigned int level, bool smoothing,
                                      bool takeOnlyGridFromFile) {

    unsigned int flags = 0;

    static unsigned int opt_subregion = 0x04;            // bit 2 (=4)
    static unsigned int opt_smoothing = 0x08;            // bit 3 (=8)
    static unsigned int opt_retainStateFile = 0x10;      // bit 4 (=16)
    static unsigned int opt_takeOnlyGridFromFile = 0x20; // bit 5 (=32)

    level <<= 8;                // bits 8-31
    flags |= level | verbosity; // verbosity: bits 0-1
    if (subregion)
        flags |= opt_subregion;
    if (!smoothing)
        flags |= opt_smoothing; // careful true-false inverted
    if (retainStateFile)
        flags |= opt_retainStateFile;
    if (takeOnlyGridFromFile)
        flags |= opt_takeOnlyGridFromFile;

    return flags;
}
}