Scoping problem

I can’t translate this from c++ to python

#include "TROOT.h"
#include "TApplication.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TFile.h"
#include "TTree.h"
#include "TDirectory.h"
#include "THStack.h"
#include <string>
#include <iostream>
#include <sstream>

template <class T>
std::string toString (const T& t)
{
    std::stringstream ss;
    ss << t;
    return ss.str();
}


void draw(TCanvas *canvas, TTree *data1,TTree *data2,char **variable)
{
    canvas->Divide(1,3);
    for (int i=0;i<2;++i)
    {
	canvas->cd(i+1);
	std::string name1 = std::string("histo1_") + toString(i);
	std::string name2 = std::string("histo2_") + toString(i);
	std::string stringa1 = std::string(variable[i]) + ">>" + name1;
	std::string stringa2 = std::string(variable[i]) + ">>" + name2;
	data1->Draw(stringa1.c_str());
	data2->Draw(stringa2.c_str());

	std::cout << stringa1 << std::endl;
	std::cout << stringa2 << std::endl;

	std::cout << name1 << std::endl;
	std::cout << name2 << std::endl;
	
	TH1F *histo1 = (TH1F*)gDirectory->Get(name1.c_str());
	TH1F *histo2 = (TH1F*)gDirectory->Get(name2.c_str());

//	histo2->Draw();
//	histo1->Draw("same");

	THStack *stack = new THStack("stack","stack");
	stack->Add(histo1);
	stack->Add(histo2);
	stack->Draw("nostack");
	
    }
    

}

int main(int argc, char **argv)
{
    TApplication theApp("App",&argc, argv);
    char* name_file_signal = "../decaytree140708_2.root";
    char* name_file_all = "../decaytree_strip150708_TOTAL.root";
    TFile *file_signal = new TFile(name_file_signal);
    TFile *file_all = new TFile(name_file_all);
    TDirectory *dir_signal = (TDirectory*)file_signal->Get("DsDs");
    TDirectory *dir_all = (TDirectory*)file_all->Get("DsDs");

    TTree *data_signal = (TTree*)dir_signal->Get("Selection");
    TTree *data_all = (TTree*)dir_all->Get("Selection");

    TCanvas *c1 = new TCanvas("c1","canvas");

    char* variable[] = {"DsP_MM","DsM_MM"};
    draw(c1,data_signal,data_all,variable);
    theApp.Run();
    return 0;
}

my translation is:

from ROOT import *

def draw(canvas,data1,data2,variable):
    canvas.Divide(1,3)
    for i in range(0,2):
        canvas.cd(i+1)
        name1 = "histo1_%d" %i
        name2 = "histo2_%d" %i
        stringa1 = variable[i] + ">>" + name1
        stringa2 = variable[i] + ">>" + name2
        data1.Draw(stringa1)
        data2.Draw(stringa2)
        
        print stringa1
        print stringa2
        
        print name1
        print name2

        histo1 = gDirectory.Get(name1)
        histo2 = gDirectory.Get(name2)

#        histo2.DrawCopy()
#        histo1.DrawCopy("same")
        stack = THStack("stack","stack")
        stack.Add(histo1)
        stack.Add(histo2)
        stack.Draw("nostack")

def main():
    name_file_signal = "../decaytree140708_2.root"
    name_file_all = "../decaytree_strip150708_TOTAL.root"

    file_signal = TFile(name_file_signal);
    file_all = TFile(name_file_all);
    dir_signal = file_signal.Get("DsDs");
    dir_all = file_all.Get("DsDs");

    data_signal = dir_signal.Get("Selection");
    data_all = dir_all.Get("Selection");

    c1 = TCanvas("c1","canvas");

    variable = ["DsP_MM","DsM_MM"];
    draw(c1,data_signal,data_all,variable);
    c1.Update()
    rep = ''
    while not rep in [ 'q', 'Q' ]:
        rep = raw_input( 'enter "q" to quit: ' )
        if 1 < len(rep):
            rep = rep[0]

if __name__ == '__main__':
    main()

I think is a scoping problem of the THStack.

Yes, at the end of the function draw() in C++, the stack will exist somewhere on the heap, whereas in python it will be destroyed b/c its refcount goes to zero. Best is to add the stack to the canvas as a data member, or to return it from the function into a variable at the level of main.

Cheers,
Wim