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(100000);
    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 SUMRVECHelper : public ROOT::Detail::RDF::RActionImpl<SUMRVECHelper<T,N>> {
    public  : 
    const int NBSLOTS = N;
    using Result_t = T;    
    std::shared_ptr<Result_t> fResultSum;
    std::vector< Result_t > fSumsPerSlot;
    SUMRVECHelper(){
        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);
    }
    SUMRVECHelper( SUMRVECHelper &&)= default;  
    SUMRVECHelper( const SUMRVECHelper &) = delete;  
    void Exec(unsigned int slot, const T &vs){
        for( auto  slot : ROOT::TSeqU(0, fSumsPerSlot.size())){                
            for( int i = 0 ; i < vs.size(); ++i){
                fSumsPerSlot[slot][i] += vs.at(i);
            }
        }        
    }
    void Initialize() {
        //Initialize for safety the final results to start from 0. the weight counting 
        (*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::EnableImplicitMT(4);
    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>>(SUMRVECHelper<RVec<double>, 100>(), {"val1"} ); //.GetValue();
    std::cout<<"LOOPING"<<std::endl;
    *df.Count();
    std::cout<<"LOOPING"<<std::endl;
    RVec<double> res = *CC;
    for( int i = 0; i < 100; ++i){
       std::cout<<"sumW ["<< i << "] = "<< res[i] << std::endl;
    }
}