void makeDF(){
    auto add_vec_col1 = []( double dummy ){ 
        vector<double> c;
        c.reserve(10);
        for( int i = 0; i < 100; ++i){
            c.push_back( 1.*i);
        }
        return c;
    };
    auto add_vec_col2 = []( double dummy ){ 
        vector<double> c;
        c.reserve(10);
        for( int i = 0; i < 100; ++i){
            c.push_back( 2.*i);
        }
        return c;
    };    
    ROOT::RDataFrame df(1000);
    auto last_node = df.Define("dummy", "1.");
    last_node.Define("val1", add_vec_col1, {"dummy"})
             .Define("val2", add_vec_col2, {"dummy"})
             .Snapshot("test","test.root");
}

using namespace ROOT::VecOps;

template<typename T , int N  >
class SUMRVEC : public ROOT::Detail::RDF::RActionImpl<SUMRVEC<T,N>> {
    public  : 
    const int NBSLOTS = N;
    using Result_t = T;    
    std::shared_ptr<Result_t> fResultSum;
    std::vector< Result_t > fSumsPerSlot;
    SUMRVEC(){
    std::cout<<"Constructor"<<std::endl;

    const auto nSlots = ROOT::IsImplicitMTEnabled() ?  ROOT::GetImplicitMTPoolSize() : 1;
    for (auto slot : ROOT::TSeqU(0,nSlots)){
        T slotSum; 
        slotSum.resize(N);
        for( int j = 0; j < N; ++j){
            slotSum[j] = 0; 
        }
        fSumsPerSlot.push_back( slotSum);
    }
    T myVec(N);
    fResultSum = std::make_shared<T>( myVec);
  }
  SUMRVEC( SUMRVEC &&)= default;  
  SUMRVEC( const SUMRVEC &) = delete;  
  void Exec(unsigned int slot, const T &vs)
   {
        std::cout<<"EXEC"<<std::endl;
        for( auto  slot : ROOT::TSeqU(0, fSumsPerSlot.size())){                
            for( int i = 0 ; i < vs.size(); ++i){
             fSumsPerSlot[slot][i] += vs.at(i);
            }
        }        
   }
  void Initialize() {
      std::cout<<"Initialize"<<std::endl;
      (*fResultSum).resize(N);
      for( int i = 0; i < N; ++i){
          (*fResultSum)[i] = 0.;
      }
  }
  void Finalize(){
        for( auto  slot : ROOT::TSeqU(0, fSumsPerSlot.size())){                
            for(int i = 0; i< N; ++i){
                (*fResultSum)[i] += fSumsPerSlot[slot][i];
            }                  
        }       
   }

    std::shared_ptr<T> GetResultPtr() const { 
         std::cout<<"ResultPtr"<<std::endl;
        return  fResultSum;
    }
    void InitTask(TTreeReader *, unsigned int) {}

    std::string GetActionName(){
        return "SUMRVEC";
    }   
};


void Proto(){
    std::cout<<"Make df"<<std::endl;
    makeDF();

    ROOT::RDataFrame df("test","test.root");


    std::cout<<"Node maker"<<std::endl;

    auto node = df.Define("val3", "val1*val2");

    std::cout<<"SumW"<<std::endl;

    auto sumWCols = SUMRVEC<RVec<double>, 100>();            

    std::cout<<"BOOKIT"<<std::endl;
    auto CC =  node.Book<RVec<double>>(std::move(sumWCols), {"val1"} ).GetValue();
    // df.Count();
    std::cout<<"LOOPING"<<std::endl;

    for( int i = 0; i < 100; ++i){
       std::cout<<"sumW ["<< i << "] = "<< CC[i] << std::endl;
    }



}