class RootHelperBase(object):
    """
    Class that helps to pick any object from any root file
    by specifiying the path to the object like:
    path/to/root_file.root/path/to/root_object.
    Class can also check for type of object and return TypeError
    in case the object is not of a desired type.
    """

    def __init__(self):
        self.log = Logger().getLogger(self.__class__.__name__, 10)
        self.pp = pprint.PrettyPrinter(indent=4)
        self.DEBUG = True

    def check_in_opened_files_table(self, file_name, access):
        """
        Makes a check in the open_files_table dictionary and returns
        pointer to the file if file is opened correct access mode.

        Returns:
        --------
        tuple (is_opened, pointer_to_file).
        In case file doesn't exist (is_opened=False,pointer_to_file=None)

        """
        try:
            self.open_files_table[file_name][access]
        except KeyError:
            self.log.debug("File {0} is not opened in {1} mode.".format(file_name, access))
            return (False, None)
        else:
            the_file = self.open_files_table[file_name][access]
            if isinstance(the_file, TFile):
                if the_file.IsOpen() and not the_file.IsZombie():
                    self.log.debug(
                        "File {0} is already opened in {1} mode. Return pointer to file.".format(file_name, access)
                    )
                    return (True, the_file)
                else:
                    self.log.debug("File {0}   in {1} mode is either closed or zombie.".format(file_name, access))
                    self.open_files_table[file_name][access] = None
                    return (False, None)
            else:
                self.log.debug("File {0} is not opened in {1} mode.".format(file_name, access))
                return (False, None)

    def update_opened_files_table(self, file_object, access):
        """
        Update the status of files opened.
        file_name: acces : file_pointer structure.
        """
        try:
            self.open_files_table
        except AttributeError:
            # self.open_files_table = collections.OrderedDict()
            self.open_files_table = {}
            self.open_files_table[file_object.GetName()] = {access: file_object}
        else:

            try:
                self.open_files_table[file_object.GetName()]
            except KeyError:
                self.open_files_table[file_object.GetName()] = {access: file_object}
            else:
                self.open_files_table[file_object.GetName()].update({access: file_object})
            # self.open_files_table['dummy'].update({access : file_object})
            # self.open_files_table[file_object.GetName()][access] = file_object

        if self.DEBUG:
            self.pp.pprint(self.open_files_table)

        return 0

    def TFile_safe_open(self, file_name, access="READ"):
        """
        Safely open TFile object. Memory is saved by cheking if the file is already
        open by looking up in the list open_files_table.

        """
        # check if file is already openedby looking-up the opend files dict
        is_opened = False
        rootfile = None
        try:
            self.open_files_table
        except AttributeError:
            pass
        else:
            is_opened, rootfile = self.check_in_opened_files_table(file_name, access)
        if is_opened:
            self.log.debug("Returning pointer to ROOT file: {0}".format(file_name))
            return rootfile

        self.log.debug("Opening ROOT file: {0}".format(file_name))

        if access.upper() == "READ" and not os.path.exists(file_name):
            raise IOError, "File path does not exist: {0}".format(file_name)
        else:
            base_dir = os.path.dirname(file_name)
            misc.make_sure_path_exists(base_dir)

        rootfile = TFile.Open(file_name, access)
        self.update_opened_files_table(rootfile, access)

        if not rootfile:
            raise IOError, "The file {0} either doesn't exist or cannot be open".format(file_name)
        return rootfile

    def get_paths(self, path):
        """
        Returns tuple (path_to_root_file, path_to_root_object_in_root_file)
        """
        path_contains_file = ".root" in path
        path_segments = path.split(".root")
        if path.endswith(".root"):  # only root file path exists
            return (path, "")

        # print path_segments
        # assert 1<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
        assert (
            0 < len(path_segments) <= 2
        ), "Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file"
        path_to_file = ""
        if len(path_segments) == 2:  # path contains file name and object path in the root file
            path_to_file = path_segments[0] + ".root"
            self.log.debug("Src root file: {0}".format(path_to_file))
            # path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root

        if path_segments[-1].startswith("/"):
            path_to_root_object = path_segments[-1][1:]  # to remove the '/' after .root
        else:
            path_to_root_object = path_segments[-1]  # there is no '/' at the beggining
        self.log.debug("Src root_object name: {0}".format(path_to_root_object))

        return (path_to_file, path_to_root_object)

        # path_to_file = path_segments[0]+'.root'
        # self.log.debug('Src root file: {0}'.format(path_to_file ))
        # path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
        # self.log.debug('Src root_object name: {0}'.format(path_to_root_object))

        # return (path_to_file,path_to_root_object)

    def get_object(self, path, object_type=None, clone=False):
        """
        Get any root object copy from path and check it's type.
        The object is copied from the file if needed.
        """
        path_to_file, path_to_root_object = self.get_paths(path)
        root_object_file = self.TFile_safe_open(path_to_file, "READ")
        the_object = root_object_file.Get(path_to_root_object)
        is_TTree = isinstance(the_object, TTree)
        if clone:
            if not is_TTree:
                the_object = copy.deepcopy(root_object_file.Get(path_to_root_object))
                self.log.debug("Coping root_object {0} of type={1}.".format(path_to_root_object, type(the_object)))
                root_object_file.Close()
            else:
                # FIXME
                self.log.warn("Cloning the full tree {0}. !!! Still not fully tested !!!".format(path_to_root_object))
                the_object = root_object_file.Get(path_to_root_object).CloneTree()
                # will not close file since it will destroy the object. Better to write the tree down first, then close file.

        else:
            self.log.debug(
                "Pointer to root_object {0} of type={1} is returned.".format(path_to_root_object, type(the_object))
            )
        return the_object

    def get_TTree(self, path, cut=None, clone=False):
        """
        Get a tree from the path of format //machine/file_name.root/subdir/tree_name.
        If path is list it will asume TChain. Wildcards can be used but ".root" has
        to exost in the path name, otherwise 'segmentation violation'
        """

        the_tree = TChain()

        if isinstance(path, list):
            tree_name = self.get_paths(path[0])[1]
            the_tree.SetName(tree_name)
            for item in path:
                assert isinstance(item, str), "The tree path should be of string format and not: {0}".format(type(item))
                add_result = the_tree.Add(item)

        elif isinstance(path, str):
            tree_name = self.get_paths(path)[1]
            the_tree.SetName(tree_name)
            add_result = the_tree.Add(path)
        self.log.debug("TChain has been constructed from {0} files with correct tree names.".format(add_result))
        if cut:
            assert isinstance(cut, str), "The TTree cut has to be string value, not {0} !!!".format(type(cut))
            clone = True
            the_selection_tree = the_tree.CopyTree(cut)
            return the_selection_tree
        else:
            return the_tree

    def get_histogram(self, path, hist_type=TH1, clone=False):
        """
        Get TH1 object or any other that inherits from TH1
        """
        return self.get_object(path, hist_type, clone)

    def get_embedded_object(
        self, path_to_container, container_type=None, embedded_object=None, object_type=None, clone=False
    ):
        """
        Get an object embedded into another class, like e.g. a TH1 from TCanvas
        saved in file. In case only path_to_container is given, it will return the container
        like with get_object method.
        """
        pass

    def add_to_basket(self, root_object, new_name=None, new_title=None):
        """
        Add object to the basket with new_name and new_title.
        If new_name contains "/" then a directory will be created inside the file. (TODO)
        """

        if new_name:
            # name_in_basket = new_name
            new_name_no_subfolders = new_name.split("/")[-1]  # remove subfolder name from the new_name
            root_object.SetName(new_name_no_subfolders)
            name_in_basket = new_name
        else:
            name_in_basket = root_object.GetName()

        if new_title:
            root_object.SetTitle(new_title)
        try:
            self.root_fruit_basket
        except AttributeError:
            self.root_fruit_basket = collections.OrderedDict()
            self.log.debug("Creating new root-object basket.")
        else:
            if self.DEBUG and len(self.root_fruit_basket) < 10:
                self.log.debug("Adding root-object to existing basket. Basket state (printed if less then 10 items):")
                self.pp.pprint(self.root_fruit_basket)
        self.root_fruit_basket[name_in_basket] = root_object

    def _get_subfolders_and_name(self, path):
        """
        Gives back the 2 element tuple with subfolder path and a name of root_object
        """
        path_segments = path.split("/")
        assert len(path_segments) > 0, "The name should not be empty string."
        if len(path_segments) > 1:
            # check if first is '/'
            if path_segments[0] == "":
                path_segments.pop(0)
            subfolders = string.join(path_segments[:-1], "/")
            root_object_name = path_segments[-1]
            self.log.debug("Root-subfolder: {0}".format(subfolders))
            self.log.debug("Root-object name: {0}".format(root_object_name))
            return (subfolders, root_object_name)
        else:
            root_object_name = path_segments[-1]
            return (None, root_object_name)

    def _get_directory(self, root_file, path):
        """
        Create and cd to the directory if given like a/b/c
        """
        root_file.cd()
        # subfolders = self._get_subfolders_and_name(path)[0]
        if path:
            self.log.debug("Creating root-subfolder {0}".format(path))
            mkdir_res = root_file.mkdir(path)
            self.log.info("Root-subfolder {0} created with code = {1}".format(path, mkdir_res))
            root_file.cd(path)
        else:  # no subfolder will be created
            root_file.cd()
        self.log.debug("Current directory: {0}".format(gDirectory.GetPath()))

    def flush_basket(self):
        """
        Resets the basket content and delets the basket.
        """

        try:
            del self.root_fruit_basket
        except:
            raise RuntimeError, "Basket cannot be flushed and destroyed! It even doesn't exist ..."
        else:
            self.log.info("Basket flushed!")
            return 0

    def dump_basket_to_file(self, file_name, access="UPDATE"):
        """
        Save what is in basket to a file. Create directories in the path if needed.
        """
        out_file = self.TFile_safe_open(file_name, access)
        out_file.cd()
        if self.DEBUG:
            self.pp.pprint(self.root_fruit_basket)

        for item_name in self.root_fruit_basket.keys():
            subfolders, root_object_name = self._get_subfolders_and_name(item_name)
            self._get_directory(out_file, subfolders)  # it will create and cd to the directory if given like a/b/c
            self.log.debug(
                "Writing root-object: {0} Object name: {1} ; Object title: {2}".format(
                    self.root_fruit_basket[item_name],
                    self.root_fruit_basket[item_name].GetName(),
                    self.root_fruit_basket[item_name].GetTitle(),
                )
            )
            is_TTree = isinstance(self.root_fruit_basket[item_name], TTree)
            if is_TTree:
                self.log.debug("This is a TTree object : {0}".format(self.root_fruit_basket[item_name]))
                copy_tree_name = self.root_fruit_basket[item_name].GetName()
                copy_tree_title = self.root_fruit_basket[item_name].GetTitle()
                tree_for_saving = self.root_fruit_basket[item_name].CloneTree(0)
                copy_res = tree_for_saving.CopyEntries(self.root_fruit_basket[item_name])
                tree_for_saving.SetNameTitle(copy_tree_name, copy_tree_title)
                write_res = tree_for_saving.Write()
            else:
                write_res = self.root_fruit_basket[item_name].Write()

            if write_res == 0:
                self.log.error("The object {0} cannot be written into {1}".format(item_name, gDirectory.GetPath()))
            else:
                self.log.info("The object {0} has been written into {1}".format(item_name, gDirectory.GetPath()))

        out_file.Close()
        self.log.info(
            "Saved the basket with {1} items into the file: {0}".format(file_name, len(self.root_fruit_basket))
        )
        self.flush_basket()

        return 0
Exemple #2
0
class RootPlottersBase(RootHelperBase):
  """Class as a base class for many plotters containing the structure, common functions...
  """

  def __init__(self,name = "plotters_base_functionality" ):
        self.log = Logger().getLogger(self.__class__.__name__, 10)
        self.name = name
        #ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
        #ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
        #from ROOT import setTDRStyle
        #ROOT.setTDRStyle(True)

        #ROOT.gStyle.SetPalette(1)
        #ROOT.gStyle.SetOptStat(0)
        self.copy_to_web_dir = False
        self.webdir = ""
        self.save_extensions = ['png','pdf','eps']
        #self.pp = pprint.PrettyPrinter(indent=4)

  def setName(self, newname): self.name = newname

  def make_plot(self, data):
        print "This is a default method for plotters. It has to be implemented in derived classes"
        pass

  def setCopyToWebDir(self,doCopy=False,webdir=""):
        if doCopy:
            self.copy_to_web_dir = True
            if webdir:
                self.webdir = webdir
            else:
                raise ValueError, "You have to provide a webdir path if you want to copy the files."
        else:
            self.copy_to_web_dir = False
            self.webdir = ""
        return 0

  def get_webdir(self):
        return self.webdir

  def copy_index_html(self, full_path_dir):
        """
        Walk to all subdirs and put index.php if not present.
        """
        for root, dirs, files in os.walk(full_path_dir):
            #print root
            if not os.path.exists("{0}/index.php".format(root)) :
                #shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",root)
                self.put_index_php_structure(root)



  def doCopyToWebDir(self,file_name, newname=""):
        if newname=="":
            newname = file_name
        if self.webdir :
            full_path = self.webdir+"/"+newname
            full_path_dir =  os.path.dirname(full_path)
            #misctools.make_sure_path_exists(self.webdir)
            misctools.make_sure_path_exists(full_path_dir)
            #if not os.path.exists("{0}/index.php".format(self.webdir)) :
            self.copy_index_html(self.webdir)
            if not os.path.exists("{0}/index.php".format(full_path_dir)) :
                #shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",full_path_dir)
                self.put_index_php_structure(full_path_dir)
            self.log.debug("Copying {0} to webdir {1}".format(file_name,full_path))
            shutil.copy(file_name,full_path)
            self.log.info("Copied {0} to webdir {1}".format(file_name,full_path))
        else :
            raise ValueError, "You have to provide a webdir path if you want to copy the files."
        return 0


  def save(self, canv, plot_name, extensions=['png','root']):
        #extensions = ['.png','.pdf','.eps','.root']
        if len(extensions)==0:
            extensions=['']
        for ext in extensions:
            postfix = "."+ext
            if ext=='':
                postfix=''
            canv.SaveAs(plot_name+postfix)
            self.log.debug("Saving to: {0}.{1}".format(plot_name,ext))
            if self.copy_to_web_dir :
                self.doCopyToWebDir(plot_name+postfix)


  def XtoNDC(self, x):
        gPad.Update() #this is necessary!
        return (x - gPad.GetX1())/(gPad.GetX2()-gPad.GetX1())


  def YtoNDC(self, y):
        gPad.Update() #this is necessary!
        return (y - gPad.GetY1())/(gPad.GetY2()-gPad.GetY1())

  def get_histDim(self,input_hist):
        n_dim = None
        if (isinstance(input_hist, TH3)): n_dim = 3
        elif (isinstance(input_hist, TH2)): n_dim = 2
        elif (isinstance(input_hist, TH1)): n_dim = 1
        else:
            raise TypeError, '[RootPlottersBase::get_histDim] The input to this function should be a histogram. Check your inputs!'
        return n_dim

  def put_index_php_structure(self, www_dir):
      """
      Copies the structure of index.php file to the www_dir.
      """
      index_php = """
        <html>
            <head>
                        <title><?php echo getcwd(); ?></title>
                        <style type='text/css'>
                                body {
                                    font-family: "Candara", sans-serif;
                                    font-size: 9pt;
                                    line-height: 10.5pt;
                                }
                                div.pic h3 { 
                                    font-size: 11pt;
                                    margin: 0.5em 1em 0.2em 1em;
                                }
                                div.pic p {
                                    font-size: 11pt;
                                    margin: 0.2em 1em 0.1em 1em;
                                }
                                div.pic {
                                    display: block;
                                    float: left;
                                    background-color: white;
                                    border: 1px solid #ccc;
                                    padding: 2px;
                                    text-align: center;
                                    margin: 2px 10px 10px 2px;
                                    -moz-box-shadow: 7px 5px 5px rgb(80,80,80);    /* Firefox 3.5 */
                                    -webkit-box-shadow: 7px 5px 5px rgb(80,80,80); /* Chrome, Safari */
                                    box-shadow: 7px 5px 5px rgb(80,80,80);         /* New browsers */  
                                }
                                a { text-decoration: none; color: rgb(80,0,0); }
                                a:hover { text-decoration: underline; color: rgb(255,80,80); }
                                figure {
                                        display: table;
                                        width: 1px; /* This can be any width, so long as it's narrower than any image */
                                        }
                                img, figcaption {
                                        display: table-row;
                                        }
                        </style>

            </head>


            <body>
                    <h4>&copy G. Petrucciani (CERN), R. Plestina (IHEP-CAS)</h4>

                    <?PHP
                        if (file_exists("title.txt")){
                            $page_title = file_get_contents("title.txt");
                            print "<h1>$page_title</h1>";
                        }
                        print "<h3>".getcwd()."</h3>";
                        if (file_exists("basic.info")){
                            print "<h2><a name='basic_info'>Basic information</a></h2>";
                            $file_handle = fopen("basic.info", "rb");

                            while (!feof($file_handle) ) {
                                    $line_of_text = fgets($file_handle);
                                    $parts = explode('=', $line_of_text);
                                    print $parts[0] . $parts[1]. "<BR>";
                            }
                            fclose($file_handle);
                        }
                    ?>
                    

                    
                    <h2><a name="plots">Plots</a></h2>
                    <p>
                        <form>Filter: 
                            <input type="text" name="match" size="30" value="<?php if (isset($_GET['match'])) print htmlspecialchars($_GET['match']);  ?>" /><input type="Submit" value="Search" />
                        </form>
                    </p>

                    <div>
                            <?PHP
                            // ____________________________________________________________________________________________________________
                            $displayed = array();
                            if ($_GET['noplots']) {
                                print "Plots will not be displayed.\n";
                            } else {
                                $other_exts = array('.pdf', '.cxx', '.eps', '.root', '.txt','.C','.gif');
                                $filenames = glob("*.png"); sort($filenames);
                                foreach ($filenames as $filename) {
                                    if (isset($_GET['match']) && !fnmatch('*'.$_GET['match'].'*', $filename)) continue;
                                    array_push($displayed, $filename);
                                    print "<div class='pic'>\n";
                                    print "<h3><a href=\"$filename\">$filename</a></h3>";
        //                             print "<a href=\"$filename\"><img src=\"$filename\" style=\"border: none; width: 300px; \"></a>";
                                    $others = array();
                                    $caption_text = '';
                                    foreach ($other_exts as $ex) {
                                        $other_filename = str_replace('.png', $ex, $filename);
                                        if (file_exists($other_filename)) {
        //                                     array_push($others, "<a class=\"file\" href=\"$other_filename\">[" . $ex . "]</a>");
                                            if ($ex != '.txt') {
                                                array_push($others, "<a class=\"file\" href=\"$other_filename\">[" . $ex . "]</a>");
                                                array_push($displayed, $other_filename);
                                                
                                            }
                                            
                                            else {
                                                $caption_text = file_get_contents($other_filename);
                                            }
                                        }
                                    }
        //                             print "<a href=\"$filename\"><figure><img src=\"$filename\" style=\"border: none; width: 300px; \"><figcaption>$caption_text</figcaption></figure></a>";
                                    print "<figure><a href=\"$filename\"><img src=\"$filename\" style=\"border: none; width: 300px; \"></a><figcaption>$caption_text</figcaption></figure>";
                                    if ($others) print "<p>View as ".implode(', ',$others)."</p>";
                                
                                    
                                    print "</div>";
                                }
                            }
                            // ____________________________________________________________________________________________________________
                            ?>

                    </div>
                    <div style="display: block; clear:both;">
                            <h2><a name="files">Other</a></h2>
                            <ul>
                            <?PHP
                            // ____________________________________________________________________________________________________________
                            foreach (glob("*") as $filename) {
                                if ($_GET['noplots'] || !in_array($filename, $displayed)) {
                                    if (isset($_GET['match']) && !fnmatch('*'.$_GET['match'].'*', $filename)) continue;
                                    if ($filename=='index.php') continue;
                                    if (is_dir($filename)) {
                                        print "<b><li><a href=\"$filename\">$filename</a></li></b>";

                                    } else {
                                        print "<li><a href=\"$filename\">$filename</a></li>";
                                    }
                                }
                            }
                            // ____________________________________________________________________________________________________________
                            ?>
                            </ul>
                    </div>
        
            </body>
        </html>

            """
      with open(www_dir+'/index.php','w') as f:
          f.write(index_php)
          
            
class TemplatesPlotter(PlotPolisher):  
  def __init__(self,name = "templates" ):
      self.log = Logger().getLogger(self.__class__.__name__, 10)
      self.name = name
      #ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
      ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
      from ROOT import setTDRStyle
      ROOT.setTDRStyle(True)
      
      ROOT.gStyle.SetPalette(1)
      ROOT.gStyle.SetOptStat(0)
      self.copy_to_web_dir = False
      self.webdir = ""
      self.pp = pprint.PrettyPrinter(indent=4)
      self.k2k1_ratio=0
      self.k3k1_ratio=0
      self.total_pdf=0
      
  def set_k2k1_and_k3k1(self, k2k1, k3k1):
      self.k2k1_ratio = k2k1
      self.k3k1_ratio = k3k1
      
  def setName(self, newname): self.name = newname
  def get_scale_factors(self):
            
        factors = {'lambda12_cosP' : 0.0,
            'lambda13_cosP' : 0.0,
            'lambda23_cosN' : 0.0,
            'lambda23_cosP' : 0.0,
            'gamma33' : 0.034,
            'gamma13' : 0.0,
            'gamma12' : -0.269303399267,
            'gamma11' : 1.0,
            'lambda13_cosN' : 0.0,
            'lambda12_sinN' : 0.0,
            'lambda12_cosN' : 0.538606798534,
            'gamma22' : 0.09,
            'gamma23' : 0.0,
            }
            
        nominator={
            'ggH_shape'      :             '{0}'.format(factors['gamma11']),
            'gg0Ph_shape'    :     '{0}*{1}*{1}'.format(factors['gamma22'],self.k2k1_ratio),     # @0 = k2k1_ratio
            'gg0M_shape'     :     '{0}*{1}*{1}'.format(factors['gamma33'],self.k3k1_ratio),     # @1 = k3k1_ratio
            'ggInt_12P_shape':         '{0}*{1}'.format(factors['lambda12_cosP'],self.k2k1_ratio),  
            'ggInt_12N_shape':    '{0}*{1}*(-1)'.format(factors['lambda12_cosN'],self.k2k1_ratio),
            'ggInt_13P_shape':         '{0}*{1}'.format(factors['lambda13_cosP'],self.k3k1_ratio),  
            'ggInt_13N_shape':    '{0}*{1}*(-1)'.format(factors['lambda13_cosN'],self.k3k1_ratio),  
            'ggInt_23P_shape':     '{0}*{1}*{2}'.format(factors['lambda23_cosP'],self.k2k1_ratio,self.k3k1_ratio),  
            'ggInt_23N_shape':'{0}*{1}*{2}*(-1)'.format(factors['lambda23_cosN'],self.k2k1_ratio,self.k3k1_ratio)  
            }
        return nominator


  def set_total_pdf(self, plot, root_file):
        f = TFile(root_file,"READ")
        nominator= self.get_scale_factors()    
        for i_pdf in range(len(plot['histos'])):
            if i_pdf==0:
                total_pdf = f.Get(plot['histos'][i_pdf])
                total_pdf.Scale(eval(nominator[plot['histos'][i_pdf]]))
                self.log.debug('TOTAL_PDF -> Picking up the first term {0} and the scale {1}. The histo is TH2: {2}'.format(plot['histos'][i_pdf], eval(nominator[plot['histos'][i_pdf]]), isinstance(total_pdf,TH2)))

            if plot['histos'][i_pdf]=="TOTAL_PDF":
                break
            another_template = f.Get(plot['histos'][i_pdf])
            another_template.Scale(float(eval(nominator[plot['histos'][1]]))) 
            self.log.debug('TOTAL_PDF -> Adding up term {0} and the scale {1} to histo TH2:{2}'.format(plot['histos'][i_pdf], eval(nominator[plot['histos'][i_pdf]]),isinstance(total_pdf,TH2)))
            total_pdf.Add(another_template)
        self.total_pdf = total_pdf    
        self.log.debug('TOTAL_PDF -> Added all terms and now the histo is TH2:{0} ... returning the value.'.format(isinstance(self.total_pdf,TH2)))
        
  def makePlot(self, data):

      self.c1 =ROOT.TCanvas("cc1","Templates",1000,800)
      self.c1.cd()
      ROOT.gPad.SetRightMargin(0.2)
      
      try:
	  data['content']
      except KeyError:
	  raise KeyError, "Canvas \'content\' dictionary is not provided in config file."
	  
      try:
	  data['setup']
      except KeyError:
	  print "@@@@ Canvas \'setup\' dictionary is not provided. "
	  self.setup_exist=False
      else:
	  self.arrangeCanvas(self.c1, data['setup'])
	  self.setup_exist=True
	  
      
      try:
	  self.leg
      except AttributeError:
	  self.leg_exist=False
      else:
	  self.leg_exist=True
      print data['setup']['add_text']
      try:
	  data['setup']['add_text']
      except KeyError:
	  self.add_text_exist=False
      else:
	  self.add_text_exist=True
	  
      
      
      i=0
      #rat = RootAttributeTranslator()
      for plot in data['content']:
        try:
            plot['POI']
        except KeyError:
            self.plot_total_pdf=False
        else:
            self.plot_total_pdf=True  
            plot['histos'].append("TOTAL_PDF")
            
            
        
  
        for fs in data['setup']['final_states']:
            print 100*"-"
            theTemplFile = plot['file']+"_"+fs+".root"
            interference_tag = "13"
            
            if ('ggInt_13P_shape' in plot['histos']) and ('ggInt_13N_shape' in plot['histos']): 
                plot['histos'].append("ggInt_13_shape")
                interference_tag = "13"
            elif ('ggInt_12P_shape' in plot['histos']) and ('ggInt_12N_shape' in plot['histos']): 
                plot['histos'].append("ggInt_12_shape")
                interference_tag = "12"
            if self.plot_total_pdf:
                self.set_total_pdf(plot, theTemplFile)
                
                self.log.debug('TOTAL_PDF -> Returned histo is TH2:{0}'.format(isinstance(self.total_pdf,TH2)))
            for theTemplate in plot['histos']:
               
                doSum = False
                if theTemplate == "ggInt_{0}_shape".format(interference_tag) : 
                    doSum = True
                    
                self.log.debug("Running on file:{0}  template:{1}".format(theTemplFile, theTemplate))
                if DEBUG:
                    pp.pprint(plot)
                th2 = SimplePlotter()
                
                #plot['th2'] = th2.getTH2(theTemplFile, theTemplate)
                if theTemplate=="TOTAL_PDF":
                    plot['th2'] = self.total_pdf
                    self.log.debug('TOTAL_PDF -> The addition is over. Going to plot now.' )
                elif not doSum:
                    f = TFile(theTemplFile,"READ")
                    plot['th2'] = f.Get(theTemplate)
                else:
                    self.log.debug('Summing up the interference template, which has been divided into positive and negative part.')
                    f = TFile(theTemplFile,"READ")
                    th2_P = f.Get("ggInt_{0}P_shape".format(interference_tag))
                    th2_N = f.Get("ggInt_{0}N_shape".format(interference_tag))
                        
                    #get lamda factors
                    tree=f.Get('factors')
                    factors={}
                    for fn in ['lambda{0}_cosP'.format(interference_tag),'lambda{0}_cosN'.format(interference_tag)]:
                        factors[fn] = array('d',[0])
                        tree.SetBranchAddress(fn,factors[fn])
                    tree.GetEntry(0)
                    for fn in factors.keys(): factors[fn] = factors[fn][0]
                    print "Lambdas:",factors['lambda{0}_cosP'.format(interference_tag)], factors['lambda{0}_cosN'.format(interference_tag)]
                    th2_P.Scale(factors['lambda{0}_cosP'.format(interference_tag)])
                    th2_N.Scale(factors['lambda{0}_cosN'.format(interference_tag)])
                    th2_P.Add(th2_N, -1)
                    plot['th2'] = th2_P
                 
                 
                 
                    
                if self.setup_exist: self.arrangeAxis(plot['th2'],data['setup'])
                if self.leg_exist:
                    self.leg.AddEntry(plot['th2'],plot['legend']['text'],plot['legend']['opt']);
                try:
                    plot['draw_opt']
                except KeyError:
                    draw_opt = "COLZ"
                else:
                    draw_opt = str(plot['draw_opt'])
                if draw_opt.lower()=="surf":
                    self.c1.SetTheta(16.56)
                    self.c1.SetPhi(57.83133)

                plot['th2'].Draw(draw_opt)
                
                if self.leg_exist: self.leg.Draw()
                
                
                template_name={
                    'ggH_shape':"T_{11}",
                    'gg0M_shape':'T_{33}',
                    'ggInt_13P_shape':'T_{13}',
                    'ggInt_13N_shape':'T_{13}',
                    'ggInt_13_shape':'T_{13}',
                    'gg0Ph_shape':'T_{22}',
                    'ggInt_12P_shape':'T_{12}',
                    'ggInt_12N_shape':'T_{12}',
                    'ggInt_12_shape':'T_{12}',
                    'qqZZ_shape':'T_{qqZZ}',
                    'TOTAL_PDF' : 'Total PDF'
                    }
                    
                if self.add_text_exist: 
                        data['setup']['add_text'][0]['text'] = "{0}(X,Y), {1}, GEN level, 8TeV".format(template_name[theTemplate], fs)
                        if theTemplate=="TOTAL_PDF":
                            data['setup']['add_text'][0]['text']+=", Parameters: k2/k1={0}, k3/k1={1}".format(self.k2k1_ratio,self.k3k1_ratio)
                        self.add_text(data['setup']['add_text'])
                
                
                plot_name = "{0}_{1}_{2}".format(theTemplFile.replace("/","_"), theTemplate, draw_opt)
                #plot_name = self.name
                self.save_extensions = ['png','pdf','eps']
                try:
                    data['setup']['save_ext']
                except KeyError:
                    self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
                else:
                    self.save_extensions = list(data['setup']['save_ext'])
                self.save(self.c1, plot_name, self.save_extensions)
    
 
            
        
      
  def setCopyToWebDir(self,doCopy=False,webdir=""):
      if doCopy:
	  self.copy_to_web_dir = True
	  if webdir!="":
	      self.webdir = webdir
	  else:
	      raise ValueError, "You have to provide a webdir path if you want to copy the files."
      else:
	self.copy_to_web_dir = False
	self.webdir = ""
      return 0
	

  def doCopyToWebDir(self,plot_name, newname=""):
      if newname=="":
	    newname = plot_name
      if self.webdir!="" :
          misctools.make_sure_path_exists(self.webdir)
          if not os.path.exists("{0}/index.php".format(self.webdir)) : shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",self.webdir)
	  shutil.copy(plot_name,self.webdir+"/"+newname)
	  self.log.info("Copied {0} to webdir {1}".format(plot_name,self.webdir+"/"+newname))
      else :
	  raise ValueError, "You have to provide a webdir path if you want to copy the files."      
      return 0

      
  def save(self, canv, plot_name, extensions=[]):     
      #extensions = ['.png','.pdf','.eps','.root']
      if len(extensions)==0: extensions=['']
      for ext in extensions:
	postfix = "."+ext
	if ext=='': postfix=''
	canv.SaveAs(plot_name+postfix)
	self.log.debug("Saving to: {0}.*".format(plot_name))
	if self.copy_to_web_dir : 
	  self.doCopyToWebDir(plot_name+postfix)
   chain_process.set_do_copy_to_webdir(opt.do_copy_to_webdir)
       
   for poi in list(run_data['POI']):
       log.debug('Setting POI value for {0}'.format(poi))
       chain_process.set_poi_value(str(poi), str(run_data[poi]))
       
   
   lumi_list = run_data['lumi_list']
 
   this_dir=os.getcwd()
   cards_dir = "cards_{0}/HCG/126".format(opt.run_data_name)
   #out_file_name_base = "{0}.{1}.asimov.k3k1.{2}".format(opt.run_data_name, run_data['final_state'],run_data['k3k1_ratio'])
   out_file_name_base = "{0}.{1}.asimov.{2}".format(opt.run_data_name, run_data['final_state'],chain_process.get_poi_name_value_filename())
   if 'info' not in run_data.keys(): 
       run_data['info']='Not available...'
   log.info(run_data['info'])
   info_name = out_file_name_base+".info"
   tab_name = out_file_name_base+".tab"
   log.debug("tab_name={0}".format(tab_name))
   
   import yaml
   with open('data_config.yaml', 'w') as fdata:
       fdata.write(yaml.dump(run_data, default_flow_style=False))
       log.info('Writing used configuration to data_config.yaml')
   
   
   if opt.datacard:
       chain_process.process("createCards")
       try:
           os.remove(info_name)
       except OSError , exception:
Exemple #5
0
class RootHelperBase(object):
    """
    Class that helps to pick any object from any root file
    by specifiying the path to the object like:
    path/to/root_file.root/path/to/root_object.
    Class can also check for type of object and return TypeError
    in case the object is not of a desired type.
    """

    def __init__(self):
        self.log = Logger().getLogger(self.__class__.__name__, 10)
        self.pp = pprint.PrettyPrinter(indent=4)
        self.DEBUG = True

    def check_in_opened_files_table(self, file_name,access):
        """
        Makes a check in the open_files_table dictionary and returns
        pointer to the file if file is opened correct access mode.

        Returns:
        --------
        tuple (is_opened, pointer_to_file).
        In case file doesn't exist (is_opened=False,pointer_to_file=None)

        """
        try:
            self.open_files_table[file_name][access]
        except KeyError:
            self.log.debug('File {0} is not opened in {1} mode.'.format(file_name, access))
            return (False, None)
        else:
            the_file = self.open_files_table[file_name][access]
            if isinstance(the_file,TFile):
                if (the_file.IsOpen() and not the_file.IsZombie()):
                    self.log.debug('File {0} is already opened in {1} mode. Return pointer to file.'.format(file_name, access))
                    return (True, the_file)
                else:
                    self.log.debug('File {0}   in {1} mode is either closed or zombie.'.format(file_name, access))
                    self.open_files_table[file_name][access] = None
                    return (False, None)
            else:
                self.log.debug('File {0} is not opened in {1} mode.'.format(file_name, access))
                return (False, None)

    def update_opened_files_table(self, file_object, access):
        """
        Update the status of files opened.
        file_name: acces : file_pointer structure.
        """
        try:
            self.open_files_table
        except AttributeError:
            #self.open_files_table = collections.OrderedDict()
            self.open_files_table = {}
            self.open_files_table[file_object.GetName()] = {access : file_object}
        else:

            try:
                self.open_files_table[file_object.GetName()]
            except KeyError:
                self.open_files_table[file_object.GetName()] = {access : file_object}
            else:
                self.open_files_table[file_object.GetName()].update({access : file_object})
            #self.open_files_table['dummy'].update({access : file_object})
            #self.open_files_table[file_object.GetName()][access] = file_object

        if self.DEBUG:
            self.pp.pprint(self.open_files_table)

        return 0


    def TFile_safe_open(self, file_name, access = 'READ'):
        """
        Safely open TFile object. Memory is saved by cheking if the file is already
        open by looking up in the list open_files_table.

        """
        #check if file is already openedby looking-up the opend files dict
        is_opened=False
        rootfile= None
        try:
            self.open_files_table
        except AttributeError:
            pass
        else:
            is_opened, rootfile = self.check_in_opened_files_table(file_name,access)
        if is_opened:
            self.log.debug('Returning pointer to ROOT file: {0}'.format(file_name))
            return rootfile

        self.log.debug('Opening ROOT file: {0}'.format(file_name))

        if access.upper() == 'READ' and not os.path.exists(file_name):
            raise IOError, 'File path does not exist: {0}'.format(file_name)
        else:
            base_dir = os.path.dirname(file_name)
            misc.make_sure_path_exists(base_dir)

        rootfile = TFile.Open(file_name,access)
        self.update_opened_files_table(rootfile, access)

        if not rootfile:
            raise IOError, 'The file {0} either doesn\'t exist or cannot be open'.format(file_name)
        return rootfile


    def get_paths(self, path):
        """
        Returns tuple (path_to_root_file, path_to_root_object_in_root_file)
        """
        path_contains_file = ('.root' in path)
        path_segments = path.split('.root')
        if path.endswith('.root'):  #only root file path exists
            return (path,"")

        #print path_segments
        #assert 1<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
        assert 0<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
        path_to_file = ""
        if len(path_segments)==2: #path contains file name and object path in the root file
            path_to_file = path_segments[0]+'.root'
            self.log.debug('Src root file: {0}'.format(path_to_file ))
            #path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root

        if path_segments[-1].startswith('/'):
            path_to_root_object = path_segments[-1][1:] #to remove the '/' after .root
        else:
            path_to_root_object = path_segments[-1] #there is no '/' at the beggining
        self.log.debug('Src root_object name: {0}'.format(path_to_root_object))

        return (path_to_file,path_to_root_object)


        #path_to_file = path_segments[0]+'.root'
        #self.log.debug('Src root file: {0}'.format(path_to_file ))
        #path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
        #self.log.debug('Src root_object name: {0}'.format(path_to_root_object))

        #return (path_to_file,path_to_root_object)

    def get_object(self, path, object_type=None, clone=False):
        """
        Get any root object copy from path and check it's type.
        The object is copied from the file if needed.
        """
        path_to_file, path_to_root_object = self.get_paths(path)
        root_object_file = self.TFile_safe_open(path_to_file, 'READ')
        the_object = root_object_file.Get(path_to_root_object)
        is_TTree = isinstance(the_object,TTree)
        if clone:
            if not is_TTree:
                the_object = copy.deepcopy(root_object_file.Get(path_to_root_object))
                self.log.debug('Coping root_object {0} of type={1}.'.format(path_to_root_object, type(the_object)))
                root_object_file.Close()
            else:
                #FIXME
                self.log.warn('Cloning the full tree {0}. !!! Still not fully tested !!!'.format(path_to_root_object))
                the_object = root_object_file.Get(path_to_root_object).CloneTree()
                #will not close file since it will destroy the object. Better to write the tree down first, then close file.

        else:
            self.log.debug('Pointer to root_object {0} of type={1} is returned.'.format(path_to_root_object, type(the_object)))
        return the_object

    def get_TTree(self,path , cut = None, clone = False):
        """
        Get a tree from the path of format //machine/file_name.root/subdir/tree_name.
        If path is list it will asume TChain. Wildcards can be used but ".root" has
        to exost in the path name, otherwise 'segmentation violation'
        """

        the_tree = TChain()

        if isinstance(path, list):
            tree_name = self.get_paths(path[0])[1]
            the_tree.SetName(tree_name)
            for item in path:
                assert isinstance(item,str),'The tree path should be of string format and not: {0}'.format(type(item))
                add_result = the_tree.Add(item)

        elif isinstance(path, str):
            tree_name = self.get_paths(path)[1]
            the_tree.SetName(tree_name)
            add_result = the_tree.Add(path)
        self.log.debug('TChain has been constructed from {0} files with correct tree names.'.format(add_result))
        if cut:
            assert isinstance(cut, str), 'The TTree cut has to be string value, not {0} !!!'.format(type(cut))
            clone = True
            the_selection_tree = the_tree.CopyTree(cut)
            return the_selection_tree
        else:
            return the_tree


    def get_histogram(self,path, hist_type = TH1, clone = False):
        """
        Get TH1 object or any other that inherits from TH1
        """
        return self.get_object(path,hist_type, clone)

    def get_embedded_object(self, path_to_container, container_type = None, embedded_object = None, object_type = None, clone = False):
        """
        Get an object embedded into another class, like e.g. a TH1 from TCanvas
        saved in file. In case only path_to_container is given, it will return the container
        like with get_object method.
        """
        pass

    def add_to_basket(self,root_object, new_name = None, new_title = None):
        """
        Add object to the basket with new_name and new_title.
        If new_name contains "/" then a directory will be created inside the file. (TODO)
        """

        if new_name:
            #name_in_basket = new_name
            new_name_no_subfolders = new_name.split('/')[-1]  #remove subfolder name from the new_name
            root_object.SetName(new_name_no_subfolders)
            name_in_basket = new_name
        else:
            name_in_basket = root_object.GetName()


        if new_title:
            root_object.SetTitle(new_title)
        try:
            self.root_fruit_basket
        except AttributeError:
            self.root_fruit_basket = collections.OrderedDict()
            self.log.debug('Creating new root-object basket.')
        else:
            if self.DEBUG and len(self.root_fruit_basket)<10:
                self.log.debug('Adding root-object to existing basket. Basket state (printed if less then 10 items):')
                self.pp.pprint(self.root_fruit_basket)
        self.root_fruit_basket[name_in_basket] = root_object


    def _get_subfolders_and_name(self,path):
        """
        Gives back the 2 element tuple with subfolder path and a name of root_object
        """
        path_segments = path.split('/')
        assert len(path_segments)>0, 'The name should not be empty string.'
        if len(path_segments) > 1:
            #check if first is '/'
            if path_segments[0]=='': path_segments.pop(0)
            subfolders = string.join(path_segments[:-1],'/')
            root_object_name = path_segments[-1]
            self.log.debug('Root-subfolder: {0}'.format(subfolders))
            self.log.debug('Root-object name: {0}'.format(root_object_name))
            return (subfolders, root_object_name)
        else:
            root_object_name = path_segments[-1]
            return (None, root_object_name)

    def _get_directory(self,root_file, path):
        """
        Create and cd to the directory if given like a/b/c
        """
        root_file.cd()
        #subfolders = self._get_subfolders_and_name(path)[0]
        if path:
            self.log.debug('Creating root-subfolder {0}'.format(path))
            mkdir_res = root_file.mkdir(path)
            self.log.info('Root-subfolder {0} created with code = {1}'.format(path, mkdir_res))
            root_file.cd(path)
        else:  #no subfolder will be created
            root_file.cd()
        self.log.debug('Current directory: {0}'.format(gDirectory.GetPath()))


    def flush_basket(self):
        """
        Resets the basket content and delets the basket.
        """

        try:
            del self.root_fruit_basket
        except:
            raise RuntimeError, 'Basket cannot be flushed and destroyed! It even doesn\'t exist ...'
        else:
            self.log.info('Basket flushed!')
            return 0

    def dump_basket_to_file(self, file_name, access = 'UPDATE'):
        """
        Save what is in basket to a file. Create directories in the path if needed.
        """
        out_file = self.TFile_safe_open(file_name, access)
        out_file.cd()
        if self.DEBUG:
            self.pp.pprint(self.root_fruit_basket)

        for item_name in self.root_fruit_basket.keys():
            subfolders, root_object_name = self._get_subfolders_and_name(item_name)
            self._get_directory(out_file, subfolders)  #it will create and cd to the directory if given like a/b/c
            self.log.debug('Writing root-object: {0} Object name: {1} ; Object title: {2}'.format(self.root_fruit_basket[item_name],self.root_fruit_basket[item_name].GetName(),self.root_fruit_basket[item_name].GetTitle()))
            is_TTree = isinstance(self.root_fruit_basket[item_name],TTree)
            if is_TTree:
                self.log.debug('This is a TTree object : {0}'.format(self.root_fruit_basket[item_name]))
                copy_tree_name = self.root_fruit_basket[item_name].GetName()
                copy_tree_title = self.root_fruit_basket[item_name].GetTitle()
                tree_for_saving = self.root_fruit_basket[item_name].CloneTree(0)
                copy_res = tree_for_saving.CopyEntries(self.root_fruit_basket[item_name])
                tree_for_saving.SetNameTitle(copy_tree_name,copy_tree_title)
                write_res = tree_for_saving.Write()
            else:
                write_res = self.root_fruit_basket[item_name].Write()

            if write_res == 0 :
                self.log.error('The object {0} cannot be written into {1}'.format(item_name, gDirectory.GetPath()))
            else:
                self.log.info('The object {0} has been written into {1}'.format(item_name, gDirectory.GetPath()))

        out_file.Close()
        self.log.info('Saved the basket with {1} items into the file: {0}'.format(file_name, len(self.root_fruit_basket)))
        self.flush_basket()

        return 0
class TotalPdfPlotter(PlotPolisher, RootPlottersBase):
  """Plots PDF from input templates without using nusance. 
     This is because, sometimes it happens that the templates
     are negative for some values of parameter. In that case
     the RooFit gives errors. 
  """
  def __init__(self,name = "templates" ):
        self.log = Logger().getLogger(self.__class__.__name__, 10)
        self.name = name
        #ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
        ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
        from ROOT import setTDRStyle
        ROOT.setTDRStyle(True)
        
        ROOT.gStyle.SetPalette(1)
        ROOT.gStyle.SetOptStat(0)
        self.copy_to_web_dir = False
        self.webdir = ""
        self.pp = pprint.PrettyPrinter(indent=4)
        self.k2k1_ratio=0
        self.k3k1_ratio=0
        self.total_pdf=0
        
  def set_k2k1_and_k3k1(self, k2k1, k3k1):
        self.k2k1_ratio = k2k1
        self.k3k1_ratio = k3k1
      
  def get_scale_factors(self):
            
        factors = {'lambda12_cosP' : 0.0,
            'lambda13_cosP' : 0.0,
            'lambda23_cosN' : 0.0,
            'lambda23_cosP' : 0.0,
            'gamma33' : 0.034,
            'gamma13' : 0.0,
            'gamma12' : -0.290992,
            'gamma11' : 1.0,
            'lambda13_cosN' : 0.0,
            'lambda12_sinN' : 0.0,
            'lambda12_cosN' : 0.581984,
            'gamma22' : 0.09,
            'gamma23' : 0.0,
            }
            
        nominator={
            'ggH_shape'      :             '{0}'.format(factors['gamma11']),
            'gg0Ph_shape'    :     '{0}*{1}*{1}'.format(factors['gamma22'],self.k2k1_ratio),     # @0 = k2k1_ratio
            'gg0M_shape'     :     '{0}*{1}*{1}'.format(factors['gamma33'],self.k3k1_ratio),     # @1 = k3k1_ratio
            'ggInt_12P_shape':         '{0}*{1}'.format(factors['lambda12_cosP'],self.k2k1_ratio),  
            'ggInt_12N_shape':    '{0}*{1}*(-1)'.format(factors['lambda12_cosN'],self.k2k1_ratio),
            'ggInt_13P_shape':         '{0}*{1}'.format(factors['lambda13_cosP'],self.k3k1_ratio),  
            'ggInt_13N_shape':    '{0}*{1}*(-1)'.format(factors['lambda13_cosN'],self.k3k1_ratio),  
            'ggInt_23P_shape':     '{0}*{1}*{2}'.format(factors['lambda23_cosP'],self.k2k1_ratio,self.k3k1_ratio),  
            'ggInt_23N_shape':'{0}*{1}*{2}*(-1)'.format(factors['lambda23_cosN'],self.k2k1_ratio,self.k3k1_ratio)  
            }
            
        denominator  =   "1"
        #denominator_geoloc = "({0}+{1}*@0*@0+{2}*@1*@1+2*(({3}*@0)+({4}*@1)+({5}*@0*@1)))" ### added factor 2 for mixed terms
        ##denominator = denominator_geoloc.format(factors['gamma11'],factors['gamma22'],factors['gamma33'],
                                                ##factors['gamma12'],factors['gamma13'],factors['gamma23'])
        #denominator = "{0}+{1}+{2}".format(_getDenominatorSegment(1,denominator_geoloc),_getDenominatorSegment(2,denominator_geoloc),_getDenominatorSegment(3,denominator_geoloc))      
        #denominator = "0.354301097432*(1.0+0.0*@0*@0+0.034*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))
                      #+0.184149324322*(1.0+0.0*@0*@0+0.034*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))
                      #+0.461549578246*(1.0+0.0*@0*@0+0.040*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))"
        norm={}
        for nom in nominator.keys():    
            norm[nom] = eval("({0})/({1})".format(nominator[nom], denominator))
            self.log.debug('Norm for {0}  = {1}'.format(nom, norm[nom]))    
            
        return norm

  def make_animated_gif(self, list_for_animated_gif, name_animated_gif, delay=100, loop=True):
        #import lib.util.MiscTools as misctools
        try:
            delay = int(delay)
        except ValueError:
            raise ValueError, "Delay must be an integer."
        
        loop_string = ""
        if loop:
            loop_string = " -loop 0"
            
        self.log.info('Creating animated gif: {0}'.format(name_animated_gif))    
        misctools.processCmd("convert -delay {2} {0}{3} {1} ".format(" ".join("%s"%(one_gif) for one_gif in list_for_animated_gif), name_animated_gif, delay, loop_string))    
        self.doCopyToWebDir(name_animated_gif)
        
  def makePlot(self, data):

        #self.c_big = ROOT.TCanvas("c_big","Template Components",1200,1200)
        #self.c_big.Divide(len())
        self.c1 =ROOT.TCanvas("cc1","Templates",1000,800)
        #pdf_components = {}
        self.c1.cd()
        ROOT.gPad.SetRightMargin(0.2)
        
        try:
            data['content']
        except KeyError:
            raise KeyError, "Canvas \'content\' dictionary is not provided in config file."
            
        try:
            data['setup']
        except:
            print "@@@@ Canvas \'setup\' dictionary is not provided. "
            self.setup_exist=False
        else:
            self.arrangeCanvas(self.c1, data['setup'])
            self.setup_exist=True
            
        
        try:
            self.leg
        except AttributeError:
            self.leg_exist=False
        else:
            self.leg_exist=True
        print data['setup']['add_text']
        try:
            data['setup']['add_text']
        except KeyError:
            self.add_text_exist=False
        else:
            self.add_text_exist=True
        
        i=0
        for plot in data['content']:
            
                list_for_animated_gif=[]
                list_for_animated_gif_components=[]
                
                
                try:
                    plot['POI']
                except KeyError:
                    raise KeyError, "You chould provide POI dictionary with values in your confguration."
                else:
                    self.plot_total_pdf=True  
                    if isinstance(plot['POI'], dict):
                        if "k2k1_ratio" in plot['POI'].keys():
                            k2k1_list = list(plot['POI']['k2k1_ratio'])
                            self.log.debug('k2k1_list = {0}'.format(", ".join([str(k) for k in k2k1_list])))
                        if "k3k1_ratio" in plot['POI'].keys():
                            k3k1_list = list(plot['POI']['k3k1_ratio'])
                            self.log.debug('k3k1_list = {0}'.format(", ".join([str(k) for k in k3k1_list])))
                
                for k2k1 in k2k1_list:
                    for k3k1 in k3k1_list:
                        self.set_k2k1_and_k3k1(k2k1, k3k1)
                        self.log.debug('Seting parameters to k2k1 = {0} and k3k1 = {1}'.format(self.k2k1_ratio,self.k3k1_ratio) )
                        
                        n_components = len(plot['histos'])+1 #we include the total pdf into computation
                        self.c_big = ROOT.TCanvas("c_big","Template Components",int(500*n_components),400)
                        #self.c_big = ROOT.TCanvas("c_big","Template Components",1600,800)
                        self.c_big.Divide(n_components,1)
                        
                        
                        self.log.debug("Canvas is divided to N = {0}".format(n_components))
                        pdf_components = cols.OrderedDict()
                        pdf_components_minmax = cols.OrderedDict()
                        #pdf_components_order = []
                        
                        for fs in data['setup']['final_states']:
                            print 200*"_"
                            theTemplFile = plot['file']+"_"+fs+".root"
                            
                            if DEBUG:
                                pp.pprint(plot)
                        
                            f = TFile(theTemplFile,"READ")
                            self.log.debug("Running on file: {0}".format(theTemplFile))
                            norm= self.get_scale_factors()
                            
                            for i_pdf in range(len(plot['histos'])):
                                if i_pdf==0:
                                    total_pdf = f.Get(plot['histos'][i_pdf])
                                    total_pdf.Scale(norm[plot['histos'][i_pdf]])
                                    pdf_components[plot['histos'][i_pdf]] = copy.deepcopy(total_pdf)
                                    self.log.debug('TOTAL_PDF -> Picking up the first term {0} and the scale {1}. The histo is TH2: {2}'.format(plot['histos'][i_pdf], norm[plot['histos'][i_pdf]], isinstance(total_pdf,TH2)))
                                    #pdf_components_order.append(plot['histos'][i_pdf])

                                another_template = f.Get(plot['histos'][i_pdf])
                                another_template.Scale(float(norm[plot['histos'][i_pdf]])) 
                                pdf_components[plot['histos'][i_pdf]] = copy.deepcopy(another_template)
                                #pdf_components_order.append(plot['histos'][i_pdf])
                                
                                self.log.debug('TOTAL_PDF -> Adding up term {0} and the scale {1} to histo TH2:{2}'.format(plot['histos'][i_pdf], norm[plot['histos'][i_pdf]],isinstance(total_pdf,TH2)))
                                total_pdf.Add(another_template)
                                
                            self.total_pdf = total_pdf    
                            self.log.debug('TOTAL_PDF -> Added all terms and now the histo is TH2:{0}'.format(isinstance(self.total_pdf,TH2)))
                            bins_x, bins_y = self.total_pdf.GetXaxis().GetNbins(), self.total_pdf.GetYaxis().GetNbins()
                            self.log.debug('Size of template (x,y) = ({0},{1})'.format(bins_x, bins_y))
                            
                            pdf_components["TotalPDF"] = copy.deepcopy(self.total_pdf)

                            
                            for x_bin in range(1,bins_x+1):
                                for y_bin in range(1,bins_y+1):
                                    bin_content = self.total_pdf.GetBinContent(x_bin, y_bin)
                                    #self.log.debug("Bin (i,j) = {0},{1} value = {2}".format(x_bin,y_bin, bin_content))
                                    if bin_content <= 0:
                                        raise ValueError, "!!! PDF CANNOT BE 0 or NEGATIVE !!!"
                                    assert bin_content > 0, "!!! PDF CANNOT BE 0 or NEGATIVE !!! Check your tamplates. Bin (i,j) = {0},{1} value = {2}".format(x_bin,y_bin, bin_content)   
                            
                            ### settup for the plot: text, legend and save    
                            self.c1.cd()
                            if self.setup_exist: 
                                self.arrangeAxis(self.total_pdf,data['setup'])
                            if self.leg_exist:
                                self.leg.AddEntry(self.total_pdf,plot['legend']['text'],plot['legend']['opt']);
                            try:
                                plot['draw_opt']
                            except KeyError:
                                draw_opt = "COLZ"
                            else:
                                draw_opt = str(plot['draw_opt'])
                            if draw_opt.lower()=="surf":
                                self.c1.SetTheta(16.56)
                                self.c1.SetPhi(57.83133)
                            self.total_pdf.SetMaximum(0.033)
                            self.total_pdf.SetMinimum(-0.005)
                            self.total_pdf.Draw(draw_opt)
                            
                            if self.leg_exist: self.leg.Draw()
                            
                                            
                            if self.add_text_exist: 
                                    data['setup']['add_text'][0]['text'] = "Total PDF(X,Y), {0}, GEN level, 8TeV".format(fs)
                                    data['setup']['add_text'][0]['text']+=", k2/k1 ={0: >6.2f}, k3/k1 ={1: >6.2f}".format(self.k2k1_ratio,self.k3k1_ratio)
                                    self.add_text(data['setup']['add_text'])
                            
                            ### saving the plot and copyng to webdir(if configured)
                            plot_name = "TotalPdf_{0}_{1}_k2k1_{2}_k3k1_{3}".format(theTemplFile.replace("/","_"), draw_opt,self.k2k1_ratio,self.k3k1_ratio)
                            #plot_name = self.name
                            self.save_extensions = ['png','pdf','eps', 'gif']
                            try:
                                data['setup']['save_ext']
                            except KeyError:
                                self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
                            else:
                                self.save_extensions = list(data['setup']['save_ext'])
                            self.save(self.c1, plot_name, self.save_extensions)
                            list_for_animated_gif.append(plot_name+".gif")
                            
                            #### Plot in the same canvas
                            i_div = 1
                            print "COMPONENTS :", pdf_components.keys()
                            
                            for comp in pdf_components.keys():
                                    self.c_big.cd(i_div)
                                    ROOT.gPad.SetRightMargin(0.2)
                                    ROOT.gPad.SetLeftMargin(0.1)
                                    
                                    i_div+=1
                                    ### settup for the plot: text, legend and save    
                                    if self.setup_exist: 
                                        self.arrangeAxis(pdf_components[comp],data['setup'])
                                    if self.leg_exist:
                                        self.leg.AddEntry(pdf_components[comp],plot['legend']['text'],plot['legend']['opt']);
                                    try:
                                        plot['draw_opt']
                                    except KeyError:
                                        draw_opt = "COLZ"
                                    else:
                                        draw_opt = str(plot['draw_opt'])
                                    if draw_opt.lower()=="surf":
                                        self.c_big.SetTheta(16.56)
                                        self.c_big.SetPhi(57.83133)
                                    pdf_components[comp].SetMaximum(0.033)
                                    pdf_components[comp].SetMinimum(-0.033)
                                    
                                    pdf_components[comp].GetYaxis().SetTitleOffset(0.7)
                                    if (i_div-1)>1:
                                        pdf_components[comp].GetYaxis().SetLabelOffset(999)
                                        pdf_components[comp].GetYaxis().SetLabelSize(0)
                                        pdf_components[comp].GetYaxis().SetTitle("")
                                    
                                    pdf_components[comp].Draw(draw_opt)
                                    
                                    if self.leg_exist: self.leg.Draw()
                                    
                                    if self.add_text_exist: 
                                            data['setup']['add_text'][0]['text'] = "{1}(X,Y), {0}, GEN level, 8TeV".format(fs,comp )
                                            data['setup']['add_text'][0]['text']+=", k2/k1 ={0: >6.2f}, k3/k1 ={1: >6.2f}".format(self.k2k1_ratio,self.k3k1_ratio)
                                            self.add_text(data['setup']['add_text'])
                                    
                            ### saving the plot and copyng to webdir(if configured)
                            plot_name = "TotalPdfComponents_{0}_{1}_k2k1_{2}_k3k1_{3}".format(theTemplFile.replace("/","_"), draw_opt,self.k2k1_ratio,self.k3k1_ratio)
                            #plot_name = self.name
                            self.save_extensions = ['png','pdf','eps', 'gif']
                            try:
                                data['setup']['save_ext']
                            except KeyError:
                                self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
                            else:
                                self.save_extensions = list(data['setup']['save_ext'])
                            self.save(self.c_big, plot_name, self.save_extensions)
                            list_for_animated_gif_components.append(plot_name+".gif")
                            
                            
                            
                name_animated_gif = "TotalPdf_{0}_{1}_ANIMATED_k2k1_{2}_k3k1_{3}.gif".format(theTemplFile.replace("/","_"),draw_opt,"_".join("{0}".format(one_k2k1) for one_k2k1 in k2k1_list), "_".join("{0}".format(one_k3k1) for one_k3k1 in k3k1_list))                            
                self.make_animated_gif(list_for_animated_gif, name_animated_gif)      
                name_animated_gif = "TotalPdfComponents_{0}_{1}_ANIMATED_k2k1_{2}_k3k1_{3}.gif".format(theTemplFile.replace("/","_"),draw_opt,"_".join("{0}".format(one_k2k1) for one_k2k1 in k2k1_list), "_".join("{0}".format(one_k3k1) for one_k3k1 in k3k1_list))                            
                self.make_animated_gif(list_for_animated_gif_components, name_animated_gif)