RFlat2DMatrixOperators.hxx

Go to the documentation of this file.

// Author: Martin Føll, University of Oslo (UiO) & CERN 1/2026
 
/*************************************************************************
 * Copyright (C) 1995-2026, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#ifndef TMVA_RFLAT2DMATRIXOPERATORS
#define TMVA_RFLAT2DMATRIXOPERATORS
 
#include <random>
#include <algorithm>
 
#include "TMVA/BatchGenerator/RFlat2DMatrix.hxx"
 
namespace TMVA::Experimental::Internal {
// clang-format off
/**
\class ROOT::TMVA::Experimental::Internal::RFlat2DMatrixOperators
\ingroup tmva
\brief Collection of operations applied to one or multiple flat 2D matrices.
*/
 
class RFlat2DMatrixOperators {
private:
   // clang-format on   
   bool fShuffle;
   std::size_t fSetSeed;   
public:
   RFlat2DMatrixOperators(bool shuffle = true, const std::size_t setSeed = 0)
      : fShuffle(shuffle),
        fSetSeed(setSeed)
   {
   
   }
 
  void ShuffleTensor(RFlat2DMatrix &ShuffledTensor, RFlat2DMatrix &Tensor ) {
    std::random_device rd;
    std::mt19937 g;
 
    if (fSetSeed == 0) {
      g.seed(rd());
    } else {
      g.seed(fSetSeed);
    }
 
    std::size_t rows = Tensor.GetRows();
    std::size_t cols = Tensor.GetCols();
    ShuffledTensor.Resize(rows, cols);
    
    // make an identity permutation map
    std::vector<Long_t> indices(rows);
    std::iota(indices.begin(), indices.end(), 0);    
 
    // shuffle the identity permutation to create a new permutation
    if (fShuffle) {
      std::shuffle(indices.begin(), indices.end(), g);
    }
 
    // shuffle data in the tensor with the permutation map defined above
    for (std::size_t i = 0; i < rows; i++) {
      std::copy(Tensor.GetData() + indices[i] * cols,
                Tensor.GetData() + (indices[i] + 1) * cols,
                ShuffledTensor.GetData() + i * cols);
    }
  }
 
   void SliceTensor(RFlat2DMatrix& SlicedTensor, RFlat2DMatrix& Tensor,
                    const std::vector<std::vector<std::size_t>>& slice)
   {
      const auto& rowSlice = slice[0];
      const auto& colSlice = slice[1];
 
      std::size_t rowStart = rowSlice[0];
      std::size_t rowEnd   = rowSlice[1];
      std::size_t colStart = colSlice[0];
      std::size_t colEnd   = colSlice[1];
 
      std::size_t rows = rowEnd - rowStart;
      std::size_t cols = colEnd - colStart;
 
      SlicedTensor.Resize(rows, cols);
      std::copy(Tensor.GetData() + rowStart * cols,
                Tensor.GetData() + rowStart * cols + rows * cols,
                SlicedTensor.GetData());
   }
  
   void ConcatenateTensors(RFlat2DMatrix &ConcatTensor, std::vector<RFlat2DMatrix> &Tensors)
   {
      std::size_t cols = Tensors[0].GetCols();
      std::size_t rows = 0;
 
      for (const auto& t : Tensors) {
         rows += t.GetRows();
      }
     
      ConcatTensor.Resize(rows, cols);
      
      std::size_t index = 0;
      for (std::size_t i = 0; i < Tensors.size(); i++) {
         std::size_t tensorRows = Tensors[i].GetRows();
         std::copy(Tensors[i].GetData(),
                   Tensors[i].GetData() + tensorRows * cols,
                   ConcatTensor.GetData() + index * cols);         
         index += tensorRows;
      }
   }
   
   
};
 
} // namespace TMVA::Experimental::Internal
#endif // ROOT_TMVA_RFLAT2DMATRIXOPERATORS