common.h

#ifndef _TIMBER_COMMON
#define _TIMBER_COMMON

#include <fstream>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <stdexcept>
#include <boost/filesystem.hpp>

#include <cmath>
#include <cstdlib>
#include <ROOT/RVec.hxx>
#include <TMath.h>
#include <TFile.h>
#include <TH1.h>
#include <Math/GenVector/LorentzVector.h>
#include <Math/GenVector/PtEtaPhiM4D.h>
#include <Math/Vector4Dfwd.h>

using namespace ROOT::VecOps;
namespace hardware {  
    TFile *Open(std::string file, bool inTIMBER = true, const char *option = "READ");
    TH1 *LoadHist(std::string filename, std::string histname, bool inTIMBER = true);
    RVec<float> HadamardProduct(RVec<float> v1, RVec<float> v2);
    RVec<float> HadamardProduct(RVec<float> v1, RVec<RVec<float>> v2, int v2subindex);
    RVec<float> MultiHadamardProduct(RVec<float> v1, RVec<RVec<float>> Multiv2);
    RVec<float> MultiHadamardProduct(RVec<float> v1, RVec<RVec<RVec<float>>> Multiv2, int v2subindex);
    float DeltaPhi(float phi1,float phi2);
    float DeltaR(ROOT::Math::PtEtaPhiMVector v1, ROOT::Math::PtEtaPhiMVector v2);
    template<class T1, class T2>
    float DeltaR(T1 in1, T2 in2) {
        ROOT::Math::PtEtaPhiMVector v1(in1.pt, in1.eta, in1.phi, in1.mass);
        ROOT::Math::PtEtaPhiMVector v2(in2.pt, in2.eta, in2.phi, in2.mass);
        float deta = v1.Eta()-v2.Eta();
        float dphi = DeltaPhi(v1.Phi(),v2.Phi());
        return sqrt(deta*deta+dphi*dphi);
    }
    ROOT::Math::PtEtaPhiMVector TLvector(float pt,float eta,float phi,float m);
    RVec<ROOT::Math::PtEtaPhiMVector> TLvector(RVec<float> pt,RVec<float> eta,RVec<float> phi,RVec<float> m);
    template<class T>
    ROOT::Math::PtEtaPhiMVector TLvector(T obj) {
        ROOT::Math::PtEtaPhiMVector v (obj.pt, obj.eta, obj.phi, obj.mass);
        return v;
    }
    template<class T>
    RVec<ROOT::Math::PtEtaPhiMVector> TLvector(std::vector<T> objs) {
        RVec<ROOT::Math::PtEtaPhiMVector> vs;
        vs.reserve(objs.size());
        for (size_t i = 0; i < objs.size(); i++) {
            vs.emplace_back(objs[i].pt, objs[i].eta, objs[i].phi, objs[i].mass);
        }
        return vs;
    }

    float TransverseMass(float MET_pt, float obj_pt, float MET_phi, float obj_phi);
    double InvariantMass(RVec<ROOT::Math::PtEtaPhiMVector> vects);
    template <class T>
    RVec<RVec<T>> Transpose(RVec<RVec<T>> v) {
        if (v.size() == 0) {
            return RVec<RVec<T>> (0);
        } else {
            RVec<RVec<T>> out;
            for (int i = 0; i < v[0].size(); i++) {
                RVec<T> inner;
                for (int j = 0; j < v.size(); j++) {
                    inner.push_back(v[j][i]);
                }
                out.push_back(inner);
            }
            return out;
        }
    }
}

namespace Pythonic {
    template <typename IntType>
    std::vector<IntType> Range(IntType start, IntType stop, IntType step) {
        if (step == IntType(0)) {
            throw std::invalid_argument("step for range must be non-zero");
        }

        std::vector<IntType> result;
        IntType i = start;
        while ((step > 0) ? (i < stop) : (i > stop)) {
            result.push_back(i);
            i += step;
        }

        return result;
    }

    template <typename IntType>
    std::vector<IntType> Range(IntType start, IntType stop) {
        return Range(start, stop, IntType(1));
    }

    template <typename IntType>
    std::vector<IntType> Range(IntType stop) {
        return Range(IntType(0), stop, IntType(1));
    }

    std::vector<std::string> Split(const std::string& str, char delim = ' ');

    // Personal
    template<typename T>
    int InList(T obj, std::vector<T> list) {
        int out;
        auto pos = std::find(std::begin(list), std::end(list), obj);
        if (pos != std::end(list)){
            out = pos - std::begin(list);
        } else {out = -1;}
        return out;
    }

    bool InString(std::string sub, std::string main);

    template<typename T>
    void Extend(std::vector<T> base, std::vector<T> extension) {
        for (int i = 0; i < extension.size(); i++) {
            base.push_back(extension.at(i));
        }
    }

    bool IsDir(char* dirname);
    void Execute(std::string cmd);
}

std::string ReadTarFile(std::string tarname, std::string internalFile);

class TempDir {
    private:
        const boost::filesystem::path _path;
        std::vector<std::string> _filesSaved;

    public:
        TempDir();
        ~TempDir();
        std::string Write(std::string filename, std::string in);
        std::string Hash();

};
#endif