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(10);
    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 SumVecCol : public ROOT::Detail::RDF::RActionImpl<SumVecCol<T,N>> {
    public  : 
    const int NBSLOTS = N;
    using Result_t = T;   
    bool m_debug  = true;
    TString m_name; 
    std::shared_ptr<Result_t> fResultSum;
    std::vector< Result_t > fSumsPerSlot;

    SumVecCol(TString _name){
        m_name = _name;
        if(m_debug){ 
            std::cout<< "Create with name "<< _name<<std::endl;
        }
        const auto nSlots = ROOT::IsImplicitMTEnabled() ?  ROOT::GetImplicitMTPoolSize() : 1;
        std::cout<<"# Create Custom Action SumVecCol(Init) : use nSLOTS "<< nSlots << " , " << m_name<< std::endl;
        for (auto slot : ROOT::TSeqU(nSlots)){
            T slotSum; 
            slotSum.resize(N);
            for( int j = 0; j < N; ++j){
                slotSum[j] = 0; 
            }
            fSumsPerSlot.push_back( slotSum);
            (void)slot;
        }
        std::cout<<"- SumVecSlots size() = "<< fSumsPerSlot.size() << "   with name " << m_name<< std::endl;
        for( int i = 0; i < nSlots ; ++i){
            std::cout<<" - SumVecSlots["<<i<<"] size = "<< fSumsPerSlot[i].size() << std::endl;
        }
        //Initialize for safety the final results to start from 0. the weight counting 
        T myVec(N); 
        for( int i = 0; i < N; ++i){
            myVec[i] = 0.;
        }
        fResultSum = std::make_shared<T>( myVec ); //should be enough to avoid going out of scope?
        std::cout<<"- SumResults size() = "<< (*fResultSum).size()<< std::endl;
        
    }
    SumVecCol( SumVecCol &&)= default;  
    SumVecCol( const SumVecCol &) = delete;  
    void Exec(unsigned int slot, const T &vs){     
        // if(m_debug){ 
        //     std::cout<< "Exec slot "<< slot<<std::endl;
        // }         
        // for( int i = 0 ; i < vs.size(); ++i){
        fSumsPerSlot[slot] += vs; //should be using RVec<double> sum operation?
        // }            
    }
    void Initialize() {
        //No init! Maybe share_ptr making has to go in constructor?
    }
    void Finalize(){
        std::cout<<"# Booked Custom Action SumVecCol(Finalize)" << std::endl;
        for( auto & m : fSumsPerSlot){
            std::cout<<"Result+=SlotResult"<<std::endl;
            *fResultSum += m;
        }      
    }
    std::shared_ptr<T> GetResultPtr() const { 
        //  std::cout<<"ResultPtr"<<std::endl;
        return  fResultSum;
    }
    void InitTask(TTreeReader *, unsigned int) {}

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

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


    ROOT::EnableImplicitMT(2);
    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;
    std::map< TString, RResultPtr< RVec<double>> 
    auto CC =  node.Book<RVec<double>>(SumVecCol<RVec<double>, 100>("test"), {"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;
    }
}