Merge lp:~ma5dev/madanalysis5/pyhf_update into lp:madanalysis5

[Benjamin Fuks]

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2021-06-30 09:39:51 +0000
@@ -0,0 +1,24 @@
+*.pyc
+*.log
+.ma5history
+tools/PADForSFS
+.DS_Store
+*.sh
+*.csh
+Makefile_*
+*.tgz
+tools/pyhf
+tools/zlib
+tools/architecture.ma5
+pyhf_test
+history.ma5
+tools/SampleAnalyzer/ExternalSymLink
+tools/SampleAnalyzer/Bin/PortabilityCheckup
+tools/SampleAnalyzer/Bin/TestCommons
+tools/SampleAnalyzer/Bin/TestFastjet
+tools/SampleAnalyzer/Bin/TestSampleAnalyzer
+tools/SampleAnalyzer/Bin/TestZlib
+tools/SampleAnalyzer/Commons/Makefile
+tools/SampleAnalyzer/Commons/Base/PortabilityTags.h
+tools/SampleAnalyzer/Configuration/Makefile
+tools/SampleAnalyzer/Process/Makefile

=== modified file 'bin/ma5'
--- bin/ma5	2020-11-02 21:02:08 +0000
+++ bin/ma5	2021-06-30 09:39:51 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 ################################################################################
 #  
@@ -33,15 +33,14 @@
 
 # Checking if the correct release of Python is installed
 import sys
-if not sys.version_info[0] == 2 or sys.version_info[1] < 6:
+if sys.version_info[1] < 7:
     sys.exit('Python release '+ sys.version + ' is detected.\n' + \
-    'MadAnalysis 5 works only with python 2.6 ' + \
-    'or later (but not python 3.X).\n' + \
+    'MadAnalysis 5 works only with python 2.7 ' + \
+    'or  python 3.7 and later.\n' + \
     'Please upgrade your version of python.')
 
 # Getting the parent directory (ma5 root dir) of the script real path (bin)
 import os
-import commands
 import optparse
 ma5dir = os.path.split(os.path.dirname(os.path.realpath( __file__ )))[0]
 if not os.path.isdir(ma5dir):
@@ -62,8 +61,13 @@
 
 # Release version
 # Do not touch it !!!!!  
+<<<<<<< TREE
 version = "1.8.59"
 date = "2020/11/02"
+=======
+version = "1.9.24"
+date = "2021/06/15"
+>>>>>>> MERGE-SOURCE
 
 # Loading the MadAnalysis session
 import madanalysis.core.launcher

=== modified file 'madanalysis/IOinterface/delphescard_checker.py'
--- madanalysis/IOinterface/delphescard_checker.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/delphescard_checker.py	2021-06-30 09:39:51 +0000
@@ -22,8 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 import os
+from six.moves import input
 
 class DelphesModule():
     
@@ -69,7 +71,7 @@
         allowed_answers=['n','no','y','yes']
         answer=""
         while answer not in  allowed_answers:
-            answer=raw_input("Answer: ")
+            answer=input("Answer: ")
             answer=answer.lower()
         if answer=="no" or answer=="n":
             return True
@@ -91,7 +93,7 @@
             allowed_answers=['n','no','y','yes']
             answer=""
             while answer not in  allowed_answers:
-                answer=raw_input("Answer: ")
+                answer=input("Answer: ")
                 answer=answer.lower()
             if answer=="no" or answer=="n":
                 return False # no, give up

=== modified file 'madanalysis/IOinterface/folder_writer.py'
--- madanalysis/IOinterface/folder_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/folder_writer.py	2021-06-30 09:39:51 +0000
@@ -22,9 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import os
 import shutil
 import logging
+from six.moves import input
 
 class FolderWriter:
 
@@ -43,7 +45,7 @@
             allowed_answers=['n','no','y','yes']
             answer=""
             while answer not in  allowed_answers:
-               answer=raw_input("Answer: ")
+               answer=input("Answer: ")
                answer=answer.lower()
             if answer=="no" or answer=="n":
                 return False, True
@@ -78,7 +80,7 @@
                 allowed_answers=['n','no','y','yes']
                 answer=""
                 while answer not in  allowed_answers:
-                    answer=raw_input("Answer: ")
+                    answer=input("Answer: ")
                     answer=answer.lower()
                 if answer=="no" or answer=="n":
                     return False

=== modified file 'madanalysis/IOinterface/histo_matplotlib_producer.py'
--- madanalysis/IOinterface/histo_matplotlib_producer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/histo_matplotlib_producer.py	2021-06-30 09:39:51 +0000
@@ -22,13 +22,13 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from string_tools                             import StringTools
 from shell_command                            import ShellCommand
 import logging
 import shutil
 import os
 import sys
-import commands
 
 class HistoMatplotlibProducer():
 
@@ -54,12 +54,12 @@
             output.write('import '+item.split('/')[-1][:-3]+'\n')
         output.write('\n')
         output.write('# Producing each histograms\n')
-        output.write('print "BEGIN-STAMP"\n')
+        output.write('print("BEGIN-STAMP")\n')
         for item in self.filenames:
             myname=item.split('/')[-1][:-3]
-            output.write('print "- Producing histo '+myname+'..."\n')
+            output.write('print("- Producing histo '+myname+'...")\n')
             output.write(myname+'.'+myname+'()\n')
-        output.write('print "END-STAMP"\n')
+        output.write('print("END-STAMP")\n')
         output.close()
         return True
 

=== modified file 'madanalysis/IOinterface/histo_root_producer.py'
--- madanalysis/IOinterface/histo_root_producer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/histo_root_producer.py	2021-06-30 09:39:51 +0000
@@ -22,12 +22,12 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from string_tools                             import StringTools
 from shell_command                            import ShellCommand
 import logging
 import shutil
 import os
-import commands
 
 class HistoRootProducer():
 
@@ -73,7 +73,7 @@
         import stat
 
         # Commands
-        output = file(self.histo_path+'/Makefile','w')
+        output = open(self.histo_path+'/Makefile','w')
         output.write('CXX     = `$(MA5_BASE)/tools/SampleAnalyzer/ExternalSymLink/Bin/root-config --cxx`\n')
         output.write('CFLAGS  = `$(MA5_BASE)/tools/SampleAnalyzer/ExternalSymLink/Bin/root-config --cflags`\n')
         output.write('LIBS    = `$(MA5_BASE)/tools/SampleAnalyzer/ExternalSymLink/Bin/root-config --libs`\n')
@@ -129,7 +129,7 @@
             return ok
 
         # Reading log file
-        input = file(self.histo_path+'/launch_root.log')
+        input = open(self.histo_path+'/launch_root.log')
         ok1 = False
         ok2 = False
         for line in input:

=== modified file 'madanalysis/IOinterface/html_report_writer.py'
--- madanalysis/IOinterface/html_report_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/html_report_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.IOinterface.text_file_writer as TextFileWriter
 from madanalysis.IOinterface.html_style_writer  import HTMLCSSWriter
 from madanalysis.enumeration.color_type         import ColorType
@@ -34,6 +35,7 @@
 import logging
 import time
 import pwd
+from six.moves import range
 
 class HTMLReportWriter(TextFileWriter.TextFileWriter):
     """Generate HTML report"""
@@ -184,7 +186,9 @@
             self.page.append("    </caption>\n")
         self.page.append('    <tr>\n')
 
-    def NewCell(self,color=ColorType.WHITE,span=1):
+    def NewCell(self,color=None,span=1):
+        if color is None:
+            color=ColorType.WHITE
         size=0
         for ii in range(0,span):
             size += self.col_size[self.current_col+ii]

=== modified file 'madanalysis/IOinterface/html_style_writer.py'
--- madanalysis/IOinterface/html_style_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/html_style_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.IOinterface.text_file_writer as TextFileWriter
 class HTMLCSSWriter(TextFileWriter.TextFileWriter):
     """Generate HTML CSS page sheet"""

=== modified file 'madanalysis/IOinterface/job_reader.py'
--- madanalysis/IOinterface/job_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/job_reader.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.dataset.sample_info          import SampleInfo
 from madanalysis.layout.cut_info              import CutInfo
@@ -33,7 +34,6 @@
 import logging
 import shutil
 import os
-import commands
 import copy
 
 

=== modified file 'madanalysis/IOinterface/job_writer.py'
--- madanalysis/IOinterface/job_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/job_writer.py	2021-06-30 09:39:51 +0000
@@ -22,17 +22,16 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.IOinterface.folder_writer    import FolderWriter
-from madanalysis.enumeration.ma5_running_type import MA5RunningType
-from string_tools                             import StringTools
 from shell_command                            import ShellCommand
 import logging
 import shutil
 import os
-import commands
+import six
 
-class JobWriter():
+class JobWriter(object):
 
     def __init__(self,main,jobdir,resubmit=False):
         self.main       = main
@@ -43,7 +42,7 @@
         self.merging    = self.main.merging
 
     @staticmethod
-    def CheckJobStructureMute(self,path,recastflag):
+    def CheckJobStructureMute(session_info,path,recastflag):
         if not os.path.isdir(path):
             return False
         if not recastflag:
@@ -67,10 +66,10 @@
             return False
         if not os.path.isdir(path+"/Output/HTML"):
             return False
-        if self.main.session_info.has_pdflatex:
+        if session_info.has_pdflatex:
             if not os.path.isdir(path+"/Output/PDF"):
                 return False
-        if self.main.session_info.has_latex:
+        if session_info.has_latex:
             if not os.path.isdir(path+"/Output/DVI"):
                 return False
         elif not os.path.isdir(path+"/Input"):
@@ -305,6 +304,7 @@
                 input = open(self.main.archi_info.ma5dir+"/tools/SampleAnalyzer/Interfaces/delphesMA5tune/"+cardname,'r')
         except:
             logging.getLogger('MA5').error("impossible to find "+self.main.archi_info.ma5dir+"/tools/SampleAnalyzer/Interfaces/delphes/"+cardname)
+            return False
         if "../../../.." in cardname:
             cardname=cardname.split('/')[-1]
 
@@ -339,6 +339,8 @@
         except:
             pass
 
+        return True
+
 
     def CopyLHEAnalysis(self):
         recast = (self.main.recasting.status=="on")
@@ -355,13 +357,14 @@
                 logging.getLogger('MA5').error('Impossible to copy the file "newAnalyzer"')
                 return False
             try:    
-                os.chmod(self.path+"/Build/SampleAnalyzer/newAnalyzer.py",0755)
+                os.chmod(self.path+"/Build/SampleAnalyzer/newAnalyzer.py",0o755)
             except:
                 logging.getLogger('MA5').error('Impossible to make executable the file "newAnalyzer"')
                 return False
 
         if self.main.fastsim.package in ["delphes","delphesMA5tune"]:
-            self.CreateDelphesCard()
+            if not self.CreateDelphesCard():
+                return False
 
         if self.main.recasting.status=="on":
             if not self.main.recasting.CreateCard(self.path):
@@ -374,7 +377,7 @@
         file.write('//  \n')
         file.write('//  This file has been generated by MadAnalysis 5.\n')
         file.write('//  The MadAnalysis development team: <[e-mail]>\n')
-        file.write('//                Eric Conte and Benjamin Fuks\n')
+        file.write('//         Jack Araz, Eric Conte and Benjamin Fuks\n')
         file.write('//  Official website: <https://launchpad.net/madanalysis5>\n')
         file.write('//  \n')
         file.write('////////////////////////////////////////////////////////////////////////////////\n\n')
@@ -460,17 +463,17 @@
             file.write('  //Getting pointer to the clusterer\n')
             file.write('  std::map<std::string, std::string> parametersC1;\n')
             parameters = self.main.fastsim.SampleAnalyzerConfigString()
-            for k,v in sorted(parameters.iteritems(),\
-                              key=lambda (k,v): (k,v)):
+            for k,v in sorted(six.iteritems(parameters),\
+                              key=lambda k_v: (k_v[0],k_v[1])):
                 file.write('  parametersC1["'+k+'"]="'+v+'";\n')
             file.write('  JetClusterer* cluster1 = \n')
             file.write('      manager.InitializeJetClusterer("'+self.main.fastsim.clustering.algorithm+'",parametersC1);\n')
             file.write('  if (cluster1==0) return 1;\n\n')
-            if self.main.superfastsim.smearer.rules!={}  or self.main.superfastsim.reco.rules!={}:
+            if self.main.superfastsim.isNewSmearerOn():
                 file.write('  // Declaration of the smearer\n')
                 file.write('  SmearerBase* mySmearer = new NewSmearer();\n')
                 file.write('  cluster1->LoadSmearer(mySmearer);\n\n')
-            if self.main.superfastsim.tagger.rules!={}:
+            if self.main.superfastsim.isTaggerOn():
                 file.write('  // Declaration of a generic tagger\n')
                 file.write('  NewTagger* tagger = new NewTagger();\n\n')
 
@@ -483,8 +486,8 @@
             else:
                 cfg=self.main.fastsim.delphes
             parameters = self.main.fastsim.SampleAnalyzerConfigString()
-            for k,v in sorted(parameters.iteritems(),\
-                              key=lambda (k,v): (k,v)):
+            for k,v in sorted(six.iteritems(parameters),\
+                              key=lambda k_v1: (k_v1[0],k_v1[1])):
                 file.write('  parametersD1["'+k+'"]="'+v+'";\n')
             file.write('  DetectorBase* fastsim1 = \n')
 
@@ -541,7 +544,7 @@
             file.write('      if (!analyzer2->Execute(mySample,myEvent)) continue;\n')
         if self.main.fastsim.package=="fastjet":
             file.write('      cluster1->Execute(mySample,myEvent);\n')
-            if self.main.superfastsim.tagger.rules!={}:
+            if self.main.superfastsim.isTaggerOn():
                 file.write('      tagger->Execute(mySample,myEvent);\n')
         elif self.main.fastsim.package=="delphes":
             file.write('      fastsim1->Execute(mySample,myEvent);\n')
@@ -582,23 +585,27 @@
         file.close()
 
         ## Do we need a smearer?
-        if main.superfastsim.smearer.rules!={} or main.superfastsim.reco.rules!={}:
+        if main.superfastsim.isNewSmearerOn():
             file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/new_smearer_reco.h","w")
             import madanalysis.job.job_smearer_reco_header as JobSmearerRecoHeader
             job = JobSmearerRecoHeader.JobSmearerRecoHeader(main.superfastsim)
             job.WriteNewSmearerRecoHeader(file)
             file.close()
-            if main.superfastsim.smearer.rules!={}:
+            if main.superfastsim.isSmearerOn():
                 file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/sigmas.h","w")
                 job.WriteNewSmearerEfficiencies(file)
                 file.close()
-            if main.superfastsim.reco.rules!={}:
+            if main.superfastsim.isRecoOn():
                 file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/reco.h","w")
                 job.WriteNewRecoEfficiencies(file)
                 file.close()
+            if main.superfastsim.isScalingOn():
+                file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/scaling.h","w")
+                job.WriteNewScales(file)
+                file.close()
 
         ## Do we need a tagger?
-        if main.superfastsim.tagger.rules!={}:
+        if main.superfastsim.isTaggerOn():
             file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/new_tagger.h","w")
             import madanalysis.job.job_tagger_header as JobTaggerHeader
             job = JobTaggerHeader.JobTaggerHeader(main.superfastsim)
@@ -618,7 +625,7 @@
         file.close()
 
         ## Do we need a smearer?
-        if main.superfastsim.smearer.rules!={}  or self.main.superfastsim.reco.rules!={}:
+        if main.superfastsim.isRecoSmearerOn():
             file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/new_smearer_reco.cpp","w")
             import madanalysis.job.job_smearer_reco_main as JobSmearerRecoMain
             job = JobSmearerRecoMain.JobSmearerRecoMain(main.superfastsim)
@@ -626,7 +633,7 @@
             file.close()
 
         ## Do we need a tagger?
-        if main.superfastsim.tagger.rules!={}:
+        if main.superfastsim.isTaggerOn():
             file = open(self.path+"/Build/SampleAnalyzer/User/Analyzer/new_tagger.cpp","w")
             import madanalysis.job.job_tagger_main as JobTaggerMain
             job = JobTaggerMain.JobTaggerMain(main.superfastsim)

=== modified file 'madanalysis/IOinterface/latex_report_writer.py'
--- madanalysis/IOinterface/latex_report_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/latex_report_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.IOinterface.text_file_writer as TextFileWriter
 from madanalysis.enumeration.color_type import ColorType
 from madanalysis.enumeration.font_type import FontType
@@ -177,7 +178,9 @@
             self.file.write("m{"+str(size)+"mm}|")
         self.file.write("}\n      \\hline\n")
 
-    def NewCell(self,color=ColorType.WHITE,span=1):
+    def NewCell(self,color=None,span=1):
+        if color is None:
+            color=ColorType.WHITE
         self.current_col=self.current_col+span
 
         if  self.current_col>self.number_col:

=== modified file 'madanalysis/IOinterface/layout_writer.py'
--- madanalysis/IOinterface/layout_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/layout_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.IOinterface.folder_writer    import FolderWriter
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
@@ -29,7 +30,6 @@
 import logging
 import shutil
 import os
-import commands
 
 class LayoutWriter():
 

=== modified file 'madanalysis/IOinterface/library_writer.py'
--- madanalysis/IOinterface/library_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/library_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.instance_name   import InstanceName
 from madanalysis.IOinterface.folder_writer import FolderWriter
 from madanalysis.IOinterface.job_writer    import JobWriter
@@ -30,8 +31,8 @@
 import logging
 import shutil
 import os
-import commands
 import subprocess
+from six.moves import input
 
 
 class LibraryWriter():
@@ -52,7 +53,7 @@
         if not self.main.forced:
             test=False
             while(not test):
-                answer=raw_input("     Answer: ")
+                answer=input("     Answer: ")
                 if answer=="":
                     test=True
                     ncores=nmaxcores
@@ -81,7 +82,7 @@
         if not self.main.forced:
             test=False
             while(not test):
-                answer=raw_input("   Answer: ")
+                answer=input("   Answer: ")
                 if answer=="":
                     test=True
                     ncores=nmaxcores

=== modified file 'madanalysis/IOinterface/madgraph_interface.py'
--- madanalysis/IOinterface/madgraph_interface.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/madgraph_interface.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,13 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.configuration.recast_configuration     import RecastConfiguration
 import itertools
 import logging
 import os
+import six
+from six.moves import range
 
 class MadGraphInterface():
 
@@ -94,6 +97,9 @@
                 self.logger.debug('pdgs = '+str(myline[3:]))
                 mypdgs= [self.get_pdg_code(prt) for prt in myline[3:]]
                 self.multiparticles[myline[1]]=sorted(sum([e if isinstance(e,list) else [e] for e in mypdgs],[]))
+        for key, value in self.multiparticles.items():
+            if len([x for x in value if x != '']) == 0:
+                del self.multiparticles[key]
         self.logger.debug('  >> ' + str(self.multiparticles))
         self.logger.debug('  >> invisible: ' + str(self.invisible_particles))
         if card_type=='parton':
@@ -436,7 +442,7 @@
             else:
                 return myprt['antiname']
         else:
-            for key, value in self.multiparticles.iteritems():
+            for key, value in six.iteritems(self.multiparticles):
                 self.logger.debug('new multiparticle ' + key + ' = ' + str(value))
                 if sorted(value)==sorted(pdg):
                     return key
@@ -450,22 +456,21 @@
             if isinstance( int(prt), int ):
                return int(prt)
         except:
-            for key, value in self.model.get('particle_dict').iteritems():
+            for key, value in six.iteritems(self.model.get('particle_dict')):
                 if value['antiname']==prt and not value['is_part']:
                     return key
                 elif value['name']==prt and value['is_part']:
                     return key
-            if prt in self.multiparticles.keys():
+            if prt in list(self.multiparticles.keys()):
                 return self.multiparticles[prt]
             else:
-                self.logger.error("  ** Problem with the multiparticle definitions")
-                raise self.MultiParts("  ** Problem with the multiparticle definitions")
+                return ''
 
     # adding the particle definitions
     def get_invisible(self, card_type='parton'):
         do_parton = card_type=='parton'
         # Do we have MET?
-        for key, value in self.model.get('particle_dict').iteritems():
+        for key, value in six.iteritems(self.model.get('particle_dict')):
             if value['width'] == 'ZERO' and value['color']==1 and value['charge']==0 and not value['name']=='a':
                 self.invisible_particles.append(value['name'])
                 self.invisible_particles.append(value['antiname'])
@@ -478,7 +483,7 @@
                 self.card.append('define invisible = ' + ' '.join(list(set(self.invisible_pdgs))))
 
     def write_multiparticles(self):
-        for key, value in self.multiparticles.iteritems():
+        for key, value in six.iteritems(self.multiparticles):
             if len([ x for x in value if x in [self.get_pdg_code(y) for y in self.invisible_particles] ])==len(value):
                 self.invisible_particles.append(key)
                 self.card.append('define ' + key + ' = ' + ' '.join([str(x) for x in value]))

=== modified file 'madanalysis/IOinterface/multiparticle_reader.py'
--- madanalysis/IOinterface/multiparticle_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/multiparticle_reader.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
 from madanalysis.core.main                    import Main
 import logging

=== modified file 'madanalysis/IOinterface/particle_reader.py'
--- madanalysis/IOinterface/particle_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/particle_reader.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.core.main as Main
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
 import logging

=== modified file 'madanalysis/IOinterface/png_reader.py'
--- madanalysis/IOinterface/png_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/png_reader.py	2021-06-30 09:39:51 +0000
@@ -22,12 +22,15 @@
 ################################################################################
 
 
+from __future__ import absolute_import
+from __future__ import print_function
+import copy
 import logging
 import shutil
 import os
-import commands
-import copy
-
+import sys
+from six.moves import range
+import six
 
 class PngHeader():
 
@@ -71,13 +74,13 @@
        
 
     def Print(self):
-        print 'PNG file with width='+str(self.width)+\
+        print('PNG file with width='+str(self.width)+\
               ' height='+str(self.height)+\
               ' bit_depth='+str(self.bit_depth)+\
               ' color_type='+str(self.color_type)+\
               ' compression_type='+str(self.compression_type)+\
               ' filter_type='+str(self.filter_type)+\
-              ' interlace_type='+str(self.interlace_type)
+              ' interlace_type='+str(self.interlace_type))
 
         
 
@@ -124,7 +127,8 @@
         # Check the PNG stamp
         ok=True
         for ind in range(0,len(head)):
-            if ord(head[ind])!=PngReader.png_header[ind]:
+            if (sys.version_info[0]==2 and ord(head[ind])!=PngReader.png_header[ind]) or \
+              (sys.version_info[0]==3 and head[ind]!=PngReader.png_header[ind]):
                 ok=False
                 break
         if not ok:
@@ -141,12 +145,13 @@
         try:
             head_length = self.input.read(4)
             head_type   = self.input.read(4)
-        except:
+        except Exception as error:
+            print(error)
             logging.getLogger('MA5').error('The file "'+self.filename+'" does not contain a PNG header.')
             return False
 
         # Check the header begin
-        if head_type.upper()!='IHDR':
+        if six.PY2 and head_type.upper()!='IHDR':
             logging.getLogger('MA5').error('The file "'+self.filename+'" does not contain a PNG header.')
             return False
 
@@ -162,18 +167,24 @@
         except:
             logging.getLogger('MA5').error('Wrong PNG header for the file "'+self.filename+'".')
             return False
-
+        
+        def decode(d):
+            if six.PY2:
+                return ord(d)
+            else:
+                return d
+        
         # Decode the header
-        self.header.bit_depth        = ord(bit_depth)
-        self.header.color_type       = ord(color_type)
-        self.header.compression_type = ord(compression_type)
-        self.header.filter_type      = ord(filter_type)
-        self.header.interlace_type   = ord(interlace_type)
+        self.header.bit_depth        = decode(bit_depth)
+        self.header.color_type       = decode(color_type)
+        self.header.compression_type = decode(compression_type)
+        self.header.filter_type      = decode(filter_type)
+        self.header.interlace_type   = decode(interlace_type)
         self.header.width            = 0
         self.header.height           = 0
         for ind in range(0,4):
-            self.header.width  += ord(width[ind]) *((2**8)**(3-ind))
-            self.header.height += ord(height[ind])*((2**8)**(3-ind))
+            self.header.width  += decode(width[ind]) *((2**8)**(3-ind))
+            self.header.height += decode(height[ind])*((2**8)**(3-ind))
 
         # Ok
         return True

=== modified file 'madanalysis/IOinterface/text_file_reader.py'
--- madanalysis/IOinterface/text_file_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/text_file_reader.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class TextFileReader():
 

=== modified file 'madanalysis/IOinterface/text_file_writer.py'
--- madanalysis/IOinterface/text_file_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/text_file_writer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class TextFileWriter():
 

=== modified file 'madanalysis/IOinterface/text_report.py'
--- madanalysis/IOinterface/text_report.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/text_report.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,12 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.color_type import ColorType
 from madanalysis.enumeration.font_type import FontType
 from madanalysis.enumeration.script_type import ScriptType
 import logging
+import six
 
 class TextReport():
 
@@ -42,7 +44,7 @@
         
         def ReplaceAll(self,text,dic):
             word = text
-            for i,j in dic.iteritems():
+            for i,j in six.iteritems(dic):
                 word = word.replace(i,j)
             return word
 

=== modified file 'madanalysis/IOinterface/ufo_reader.py'
--- madanalysis/IOinterface/ufo_reader.py	2020-07-03 08:05:49 +0000
+++ madanalysis/IOinterface/ufo_reader.py	2021-06-30 09:39:51 +0000
@@ -22,9 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.core.main as Main
 import logging
 import os
+from six.moves import range
 
 
 class UFOParticle:

=== modified file 'madanalysis/UpdateNotes.txt'
--- madanalysis/UpdateNotes.txt	2020-07-03 08:06:51 +0000
+++ madanalysis/UpdateNotes.txt	2021-06-30 09:39:51 +0000
@@ -1,5 +1,57 @@
 Update notes for MadAnalysis 5 (in reverse time order)
 
+154           (2021/06/15) fuks:    Re-organising the way the PAD works (continued) 
+
+153           (2021/06/15) fuks:    Re-organising the way the PAD works 
+
+152           (2021/06/15) fuks:    Connecting all PADs to the dataverse and fixing a few minor bugs 
+                                   with the LHC recasting structure 
+
+151           (2021/05/11) fuks:    Bug fix (696972) in the MG5 interface 
+
+150           (2021/05/03) fuks:    Matplotlib compatibility with py2 and py3 
+
+149           (2021/03/24) fuks:    Adding a warning message when Python2 is used 
+
+148           (2021/03/19) fuks:    Upgrading to delphes 3.4.3 
+
+147           (2021/02/19) fuks:    Small bug fixes with the SFS/PADForSFS 
+
+146           (2021/02/16) fuks:    Small bug with the python3 compatibility 
+
+145           (2021/02/16) fuks:    Finalisation of the PYHF interface and fixing a few bugs fir the 
+                                   PADForSFS 
+
+144           (2021/01/20) fuks:    Small bug fix for the track module (SFS) 
+
+143           (2021/01/12) fuks:    Bug fix with the mg5 interface 
+
+142           (2021/01/11) fuks:    Bug-fixing delphes so that it works with the latest ROOT 
+
+141           (2021/01/06) fuks:    Changing the default jet radius from 1 to 0.4 in the fastjet 
+                                   interface 
+
+140           (2020/12/16) fuks:    Bug fixes in particle propagation 
+
+139           (2020/12/10) fuks:    Fixing bugs with the python3 compatibility; adding tracks and 
+                                   particle propagation in the SFS module 
+
+138           (2020/11/30) fuks:    Bug fix with the PAD/PADForSFS 
+
+137           (2020/11/06) fuks:    Bug fix with the LHE reader (see bug #1851196 on Launchpad) 
+
+136           (2020/11/02) fuks:    Small bug in the recasting facilities 
+
+134           (2020/10/14) fuks:    Bug fix with the HEPMC reader 
+
+133           (2020/07/27) fuks:    Small bug with the LLP developments is now fixed 
+
+132           (2020/07/15) fuks:    Upgrading the SFS-LLP functionalities 
+
+131           (2020/07/13) fuks:    Small fix (LLP support) 
+
+130           (2020/07/13) fuks:    Adding LLP support 
+
 128  1.8   (2020/07/03) ma5team:    - New simplified fast simulation (SFS) module for event reconstruction
                                       (arxiv:2006.09387)
                                     - Update of the recasting functionalities to handle SFS detector simulations

=== modified file 'madanalysis/build/makefile_writer.py'
--- madanalysis/build/makefile_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/build/makefile_writer.py	2021-06-30 09:39:51 +0000
@@ -22,9 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 from shell_command import ShellCommand
 from string_tools  import StringTools
+from six.moves import range
 
 
 class MakefileWriter():

=== modified file 'madanalysis/build/setup_writer.py'
--- madanalysis/build/setup_writer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/build/setup_writer.py	2021-06-30 09:39:51 +0000
@@ -22,8 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 from string_tools import StringTools
+from six.moves import range
 
 
 class SetupWriter():

=== modified file 'madanalysis/configuration/beauty_identification.py'
--- madanalysis/configuration/beauty_identification.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/beauty_identification.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class BeautyIdentification():
 
@@ -95,7 +96,7 @@
 
     
     def user_GetParameters(self):
-        return BeautyIdentification.userVariables.keys()
+        return list(BeautyIdentification.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_antikt.py'
--- madanalysis/configuration/clustering_antikt.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_antikt.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringAntiKt():
 
-    default_radius    = 1.
+    default_radius    = 0.4
     default_ptmin     = 5.
 
     userVariables = { "radius" : [str(default_radius)],\
@@ -66,7 +67,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringAntiKt.userVariables.keys()
+        return list(ClusteringAntiKt.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_cambridge.py'
--- madanalysis/configuration/clustering_cambridge.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_cambridge.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringCambridge():
 
-    default_radius    = 1.
+    default_radius    = 0.4
     default_ptmin     = 5.
 
     userVariables = { "radius" : [str(default_radius)],\
@@ -65,7 +66,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringCambridge.userVariables.keys()
+        return list(ClusteringCambridge.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_cdfjetclu.py'
--- madanalysis/configuration/clustering_cdfjetclu.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_cdfjetclu.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringCDFJetClu():
     
@@ -86,7 +87,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringCDFJetClu.userVariables.keys()
+        return list(ClusteringCDFJetClu.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_cdfmidpoint.py'
--- madanalysis/configuration/clustering_cdfmidpoint.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_cdfmidpoint.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringCDFMidPoint():
 
@@ -86,7 +87,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringCDFMidPoint.userVariables.keys()
+        return list(ClusteringCDFMidPoint.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_configuration.py'
--- madanalysis/configuration/clustering_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.configuration.clustering_kt          import ClusteringKt
 from madanalysis.configuration.clustering_antikt      import ClusteringAntiKt
 from madanalysis.configuration.clustering_genkt       import ClusteringGenKt
@@ -42,8 +43,13 @@
                                      "siscone",\
                                      "cdfjetclu", "cdfmidpoint",\
                                      "none"],
-                      "exclusive_id" : ["true","false"],
-                      "jetrecomode" : ["jets","constituents"]
+                      "exclusive_id"        : ["true","false"],
+                      "jetrecomode"         : ["jets","constituents"],
+                      "magneticfield"       : ["3.8"],
+                      "tracker_radius"      : ["1.29"],
+                      "half_length"         : ["3.0"],
+                      "particle_propagator" : ["on","off"]
+
                     }
 
     def __init__(self):
@@ -204,7 +210,7 @@
         
     def user_GetParameters(self):
         if self.algorithm!="none":
-            table = ClusteringConfiguration.userVariables.keys()
+            table = list(ClusteringConfiguration.userVariables.keys())
             table.extend(self.clustering.user_GetParameters())
             table.extend(self.beauty.user_GetParameters())
             table.extend(self.tau.user_GetParameters())

=== modified file 'madanalysis/configuration/clustering_genkt.py'
--- madanalysis/configuration/clustering_genkt.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_genkt.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringGenKt():
 
-    default_radius    = 1.
+    default_radius    = 0.4
     default_exclusive = False
     default_ptmin     = 5.
     default_P         = -1.
@@ -93,7 +94,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringGenKt.userVariables.keys()
+        return list(ClusteringGenKt.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_gridjet.py'
--- madanalysis/configuration/clustering_gridjet.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_gridjet.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringGridJet():
 
@@ -72,7 +73,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringGridJet.userVariables.keys()
+        return list(ClusteringGridJet.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_kt.py'
--- madanalysis/configuration/clustering_kt.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_kt.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringKt():
 
-    default_radius    = 1.
+    default_radius    = 0.4
     default_exclusive = False
     default_ptmin     = 5.
 
@@ -78,7 +79,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringKt.userVariables.keys()
+        return list(ClusteringKt.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/clustering_siscone.py'
--- madanalysis/configuration/clustering_siscone.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/clustering_siscone.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class ClusteringSisCone():
     
-    default_radius       = 1.
+    default_radius       = 0.4
     default_overlap      = 0.5
     default_npassmax     = 0
     default_input_ptmin  = 0.
@@ -86,7 +87,7 @@
 
     
     def user_GetParameters(self):
-        return ClusteringSisCone.userVariables.keys()
+        return list(ClusteringSisCone.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/delphesMA5tune_configuration.py'
--- madanalysis/configuration/delphesMA5tune_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/delphesMA5tune_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type         import MA5RunningType
 import os
 import logging
@@ -160,7 +161,7 @@
 
         
     def user_GetParameters(self):
-        return DelphesMA5tuneConfiguration.userVariables.keys()
+        return list(DelphesMA5tuneConfiguration.userVariables.keys())
 
 
     def user_GetValues(self,variable):

=== modified file 'madanalysis/configuration/delphes_configuration.py'
--- madanalysis/configuration/delphes_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/delphes_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type         import MA5RunningType
 import os
 import logging
@@ -262,7 +263,7 @@
 
         
     def user_GetParameters(self):
-        return DelphesConfiguration.userVariables.keys()
+        return list(DelphesConfiguration.userVariables.keys())
 
 
     def user_GetValues(self,variable):

=== modified file 'madanalysis/configuration/fastsim_configuration.py'
--- madanalysis/configuration/fastsim_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/fastsim_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type           import MA5RunningType
 from madanalysis.configuration.clustering_configuration import ClusteringConfiguration
 from madanalysis.configuration.delphes_configuration    import DelphesConfiguration
@@ -180,13 +181,13 @@
         
     def user_GetParameters(self):
         if self.package=="fastjet":
-            table = FastsimConfiguration.userVariables.keys()
+            table = list(FastsimConfiguration.userVariables.keys())
             table.extend(self.clustering.user_GetParameters())
         elif self.package=="delphes":
-            table = FastsimConfiguration.userVariables.keys()
+            table = list(FastsimConfiguration.userVariables.keys())
             table.extend(self.delphes.user_GetParameters())
         elif self.package=="delphesMA5tune":
-            table = FastsimConfiguration.userVariables.keys()
+            table = list(FastsimConfiguration.userVariables.keys())
             table.extend(self.delphesMA5tune.user_GetParameters())
         else:
             table = ["package"]

=== modified file 'madanalysis/configuration/fom_configuration.py'
--- madanalysis/configuration/fom_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/fom_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class FomConfiguration:
 
@@ -86,14 +87,14 @@
     
         
     def user_GetParameters(self):
-        table = FomConfiguration.userVariables.keys()
+        table = list(FomConfiguration.userVariables.keys())
         if self.IsX():
             table.extend("x")
         return table
 
 
     def user_GetValues(self,variable):
-        if variable in FomConfiguration.userVariables.keys():
+        if variable in list(FomConfiguration.userVariables.keys()):
             table = FomConfiguration.userVariables[variable]
         if self.IsX() and variable=='x':
             table = ['0.']

=== modified file 'madanalysis/configuration/isolation_cone.py'
--- madanalysis/configuration/isolation_cone.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/isolation_cone.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class IsolationCone():
 
@@ -53,7 +54,7 @@
 
     
     def user_GetParameters(self):
-        return IsolationCone.userVariables.keys()
+        return list(IsolationCone.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/isolation_configuration.py'
--- madanalysis/configuration/isolation_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/isolation_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.configuration.isolation_cone  import IsolationCone
 from madanalysis.configuration.isolation_sumpt import IsolationSumPt
 import logging
@@ -46,7 +47,7 @@
             self.isolation.user_DisplayParameter(parameter)
 
     def user_GetParameters(self):
-        table = IsolationConfiguration.userVariables.keys()
+        table = list(IsolationConfiguration.userVariables.keys())
         table.extend(self.isolation.user_GetParameters())
         return table
 

=== modified file 'madanalysis/configuration/isolation_sumpt.py'
--- madanalysis/configuration/isolation_sumpt.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/isolation_sumpt.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class IsolationSumPt():
 
@@ -58,7 +59,7 @@
 
     
     def user_GetParameters(self):
-        return IsolationSumPt.userVariables.keys()
+        return list(IsolationSumPt.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/configuration/merging_configuration.py'
--- madanalysis/configuration/merging_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/merging_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.configuration.clustering_kt          import ClusteringKt
 from madanalysis.configuration.clustering_antikt      import ClusteringAntiKt
 from madanalysis.configuration.clustering_genkt       import ClusteringGenKt
@@ -121,7 +122,7 @@
 
         
     def user_GetParameters(self):
-        return MergingConfiguration.userVariables.keys()
+        return list(MergingConfiguration.userVariables.keys())
 
 
     def user_GetValues(self,variable):

=== modified file 'madanalysis/configuration/recast_configuration.py'
--- madanalysis/configuration/recast_configuration.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/recast_configuration.py	2021-06-30 09:39:51 +0000
@@ -22,13 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type   import MA5RunningType
-from madanalysis.IOinterface.folder_writer      import FolderWriter
-from shell_command import ShellCommand
-import glob
-import logging
-import shutil
-import os
+import glob, logging, shutil, os
+from six.moves import range
 
 class RecastConfiguration:
 
@@ -41,7 +38,8 @@
          "store_root"          : ["True", "False"] , \
          "store_events"        : ["True", "False"] , \
          "THerror_combination" : ["quadratic","linear"], \
-         "error_extrapolation" : ["linear", "sqrt"]
+         "error_extrapolation" : ["linear", "sqrt"],
+         "global_likelihoods"  : ["on","off"]
     }
 
     def __init__(self):
@@ -53,6 +51,7 @@
         self.padsfs                     = False
         self.store_root                 = False
         self.store_events               = False
+        self.global_likelihoods_switch  = True
         self.systematics                = []
         self.extrapolated_luminosities  = []
         self.THerror_combination        = "linear"
@@ -95,6 +94,7 @@
             self.user_DisplayParameter("systematics")
             self.user_DisplayParameter("THerror_combination")
             self.user_DisplayParameter("error_extrapolation")
+            self.user_DisplayParameter("global_likelihoods")
 
     def user_DisplayParameter(self,parameter):
         if parameter=="status":
@@ -162,6 +162,10 @@
                 else:
                     self.logger.info("   * Relative error on the extrapolated background Nb taken as sqrt({:.2f}^2 + ({:.2f}/Nb)^2)".format(self.error_extrapolation[0],self.error_extrapolation[1]))
             return
+        elif parameter=="global_likelihoods":
+            self.logger.info("   * Global-Likelihoods will"+(not self.global_likelihoods_switch)*' not'+\
+                             ' be calculated'+(self.global_likelihoods_switch)*', if available'+'.')
+            return
         return
 
     def user_SetParameter(self,parameters,values,level,archi_info,session_info,datasets):
@@ -351,6 +355,17 @@
                     error_message();
                     return
 
+        # Switch to turn off the global likelihood calculations
+        elif parameter=="global_likelihoods":
+            if self.status!="on":
+                self.logger.error("Please first set the recasting mode to 'on'.")
+                return
+            if value.lower() in ["on", "off"]:
+                self.global_likelihoods_switch = (value.lower()=="on")
+            else:
+                self.logger.error("You can only switch the global-likelihood machinery to 'on' or 'off'.")
+                return
+
         # other rejection if no algo specified
         else:
             self.logger.error("the recast module has no parameter called '"+str(parameter)+"'")
@@ -361,7 +376,8 @@
             if var == "add":
                 table = ["extrapolated_luminosity", "systematics"]
             else:
-                table = ["CLs_numofexps", "card_path", "store_events", "add", "THerror_combination", "error_extrapolation"]
+                table = ["CLs_numofexps", "card_path", "store_events", "add", 
+                         "THerror_combination", "error_extrapolation", "global_likelihoods"]
         else:
            table = []
         return table
@@ -383,6 +399,8 @@
                 table.extend(RecastConfiguration.userVariables["THerror_combination"])
         elif variable =="error_extrapolation":
                 table.extend(RecastConfiguration.userVariables["error_extrapolation"])
+        elif variable =="global_likelihoods":
+                table.extend(RecastConfiguration.userVariables["global_likelihoods"])
         return table
 
 
@@ -539,7 +557,7 @@
                     if analysis not in analysislist:
                         continue
                     descr = 'UNKNOWN'
-                    if analysis in self.description.keys():
+                    if analysis in list(self.description.keys()):
                         descr = self.description[analysis]
                     thecard.append(analysis.ljust(30,' ') + 'vSFS        on    ' + mycard.ljust(50, ' ')+\
                           ' # '+descr)

=== modified file 'madanalysis/configuration/tau_identification.py'
--- madanalysis/configuration/tau_identification.py	2020-07-03 08:05:49 +0000
+++ madanalysis/configuration/tau_identification.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class TauIdentification():
 
@@ -70,7 +71,7 @@
 
     
     def user_GetParameters(self):
-        return TauIdentification.userVariables.keys()
+        return list(TauIdentification.userVariables.keys())
 
 
     def user_SetParameter(self,parameter,value):

=== modified file 'madanalysis/core/expert_mode.py'
--- madanalysis/core/expert_mode.py	2020-07-03 08:05:49 +0000
+++ madanalysis/core/expert_mode.py	2021-06-30 09:39:51 +0000
@@ -22,14 +22,15 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.IOinterface.folder_writer import FolderWriter
 from madanalysis.IOinterface.job_writer import JobWriter
 import logging
 import glob
 import os
-import commands
 import sys
 import shutil
+from six.moves import input
 
 class ExpertMode:
 
@@ -46,7 +47,7 @@
           logging.getLogger('MA5').debug("Debug mode: no directory name is specified.")
           logging.getLogger('MA5').info("\nWelcome to the expert mode of MadAnalysis")
           logging.getLogger('MA5').info("Please enter a folder name for creating an empty SampleAnalyzer job")
-          answer=raw_input("Answer: ")
+          answer=input("Answer: ")
           answer=answer.replace(' ','_')
           name  =answer.replace('-','_')
         else:
@@ -120,7 +121,7 @@
         # Writing an empty analysis
         if name=="":
           logging.getLogger('MA5').info("Please enter a name for your analysis")
-          title=raw_input("Answer: ")
+          title=input("Answer: ")
           if title=="":
               title="user"
           title=title.replace(' ', '_');

=== modified file 'madanalysis/core/launcher.py'
--- madanalysis/core/launcher.py	2020-07-03 08:05:49 +0000
+++ madanalysis/core/launcher.py	2021-06-30 09:39:51 +0000
@@ -23,6 +23,8 @@
 
 
 # Setting global variables of MadAnalysis main
+from __future__ import absolute_import
+from __future__ import print_function
 from madanalysis.core.script_stack import ScriptStack
 from madanalysis.core.main         import Main
 from string_tools                  import StringTools
@@ -53,7 +55,7 @@
 ################################################################################
 def DefaultInstallCard():
     logging.getLogger('MA5').info("Generate a default installation_options.dat file...")
-    output = file('installation_options.dat','w')
+    output = open('installation_options.dat','w')
     output.write('# WARNING! MA5 SHOULD DETECT AUTOMATICALLY YOUR CONFIGURATION\n')
     output.write('# IF THIS AUTOMATED MODE FAILS, YOU CAN FORCE SOME \n')
     output.write('# OPTIONS THROUGH THIS FILE\n')
@@ -128,7 +130,7 @@
                                      ["partonlevel","hadronlevel","recolevel",\
                                       "expert","version","release","help",\
                                       "forced","script","debug","build","qmode","installcard"])
-    except getopt.GetoptError, err:
+    except getopt.GetoptError as err:
         logging.getLogger('MA5').error(str(err))
         Usage()
         sys.exit()
@@ -159,9 +161,9 @@
             mode.build = True
         elif o in ["-q","--qmode"]:
             mode.developer_mode = True
-            print ""
-            print " **** DEVELOPER MODE DETECTED **** "
-            print ""
+            print("")
+            print(" **** DEVELOPER MODE DETECTED **** ")
+            print("")
         elif o in ["-h","--help"]:
             Usage()
             sys.exit()
@@ -395,7 +397,7 @@
         try:
             import pyreadline as readline
         except:
-            print "For tab completion and history, install module readline."
+            print("For tab completion and history, install module readline.")
     else:
         import rlcompleter
     

=== modified file 'madanalysis/core/library_builder.py'
--- madanalysis/core/library_builder.py	2020-07-03 08:05:49 +0000
+++ madanalysis/core/library_builder.py	2021-06-30 09:39:51 +0000
@@ -22,11 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.system.architecture_info import ArchitectureInfo
 import logging
 import glob
 import os
-import commands
 import sys
 
 class LibraryBuilder:

=== modified file 'madanalysis/core/main.py'
--- madanalysis/core/main.py	2020-07-03 08:05:49 +0000
+++ madanalysis/core/main.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.multiparticle.multiparticle_collection import MultiParticleCollection
 from madanalysis.dataset.dataset_collection             import DatasetCollection
 from madanalysis.selection.selection                    import Selection
@@ -50,6 +51,7 @@
 import os
 import sys
 import platform
+from six.moves import range
 
 class Main():
 
@@ -228,6 +230,7 @@
 
 
     def user_DisplayParameter(self,parameter):
+        print(type(self))
         if  parameter=="currentdir":
             self.logger.info(" currentdir = "+self.get_currentdir())
         elif parameter=="stacking_method":
@@ -281,7 +284,7 @@
                 return []
 
     def user_GetParameters(self):
-        return Main.userVariables.keys()
+        return list(Main.userVariables.keys())
 
     def user_SetParameter(self,parameter,value):
         # currentdir
@@ -404,7 +407,10 @@
             os.chdir(theDir)
         except:
             self.logger.error("Impossible to access the directory : "+theDir)
-        self.user_DisplayParameter("currentdir")
+        try:
+            self.user_DisplayParameter("currentdir")
+        except:
+            pass
 
     currentdir = property(get_currentdir, set_currentdir)
 

=== modified file 'madanalysis/core/script_stack.py'
--- madanalysis/core/script_stack.py	2020-07-03 08:05:49 +0000
+++ madanalysis/core/script_stack.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 import glob
 import os
-import commands
 import sys
 import shutil
 
@@ -68,7 +68,7 @@
                 return False
             else:
                 logging.getLogger('MA5').info("Executing the commands from the script")
-                logging.getLogger('MA5').info(ScriptStack.stack[ScriptStack.main_index][0] + "...")
+                logging.getLogger('MA5').info(ScriptStack.stack[-1][0] + "...")
                 ScriptStack.main_index+=1
                 ScriptStack.sub_index=0
         else:

=== modified file 'madanalysis/dataset/dataset.py'
--- madanalysis/dataset/dataset.py	2020-07-03 08:05:49 +0000
+++ madanalysis/dataset/dataset.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.linestyle_type import LineStyleType
 from madanalysis.enumeration.backstyle_type import BackStyleType
 from madanalysis.enumeration.color_type import ColorType
@@ -83,7 +84,7 @@
             return []
 
     def user_GetParameters(self):
-        return Dataset.userVariables.keys()
+        return list(Dataset.userVariables.keys())
 
     def user_SetParameter(self,variable,value,value2="",value3=""):
         #type

=== modified file 'madanalysis/dataset/dataset_collection.py'
--- madanalysis/dataset/dataset_collection.py	2020-07-03 08:05:49 +0000
+++ madanalysis/dataset/dataset_collection.py	2021-06-30 09:39:51 +0000
@@ -22,8 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
+from __future__ import print_function
 import logging
 import madanalysis.dataset.dataset as Dataset
+import six
 
 class DatasetCollection:
 
@@ -93,7 +96,7 @@
             return
 
         # Looping over the branches of the tree
-        for key, value in datasets.GetBranches().iteritems():
+        for key, value in six.iteritems(datasets.GetBranches()):
 
             # Keeping only 'dataset' branches
             if key[0]!='dataset':
@@ -112,7 +115,7 @@
             # Getting physics parameters
             physics = value.GetBranch('physics',1)
             if physics==None:
-                print "ERROR: no physics branch"
+                print("ERROR: no physics branch")
                 continue
             else:
                 background = physics.GetParameterToBool("background")
@@ -127,7 +130,7 @@
             # Getting layout parameters
             layout = value.GetBranch('layout',1)
             if layout==None:
-                print "ERROR: no layout branch"
+                print("ERROR: no layout branch")
                 continue
             else:
                 title = layout.GetParameterToStringWithoutQuotes("title")

=== modified file 'madanalysis/dataset/sample_info.py'
--- madanalysis/dataset/sample_info.py	2020-07-03 08:05:49 +0000
+++ madanalysis/dataset/sample_info.py	2021-06-30 09:39:51 +0000
@@ -26,6 +26,6 @@
     def __init__(self):
         self.xsection = 0.
         self.xerror   = 0.
-        self.nevents  = 0L
+        self.nevents  = 0
         self.sumw_positive = 0.
         self.sumw_negative = 0.

=== modified file 'madanalysis/enumeration/argument_type.py'
--- madanalysis/enumeration/argument_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/argument_type.py	2021-06-30 09:39:51 +0000
@@ -20,15 +20,17 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+
+        def __getattr__(self, name):
+            return list(self.values.keys()).index(name)
+
[e-mail]_metaclass(metaclass)
 class ArgumentType(object):
     values = { 'COMBINATION' : [],\
                'PARTICLE' : [],\
                'INTEGER'      : [],
                'FLOAT'    : []  }
 
-    class __metaclass__(type):
-
-        def __getattr__(self, name):
-            return self.values.keys().index(name)

=== modified file 'madanalysis/enumeration/backstyle_type.py'
--- madanalysis/enumeration/backstyle_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/backstyle_type.py	2021-06-30 09:39:51 +0000
@@ -21,7 +21,26 @@
 #  
 ################################################################################
 
-
+import six
+
+class metaclass(type):
+
+        def __getattr__(self, name):
+                return list(self.values.keys()).index(name)
+
+        def convert2code(self,color):
+                name = list(self.values.keys())[color]
+                return self.values[name][0]
+
+        def convert2string(self,color):
+                name = list(self.values.keys())[color]
+                return self.values[name][1]
+
+        def convert2matplotlib(self,color):
+                name = list(self.values.keys())[color]
+                return self.values[name][2]
+
[e-mail]_metaclass(metaclass)
 class BackStyleType(object):
         values = { 'AUTO'   : [0,   'auto',  'None'],\
                    'SOLID'  : [1001,'solid', 'None'],\
@@ -32,19 +51,3 @@
 
 #            matplotlib -> hatch   = ['/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*']
 
-        class __metaclass__(type):
-
-                def __getattr__(self, name):
-                        return self.values.keys().index(name)
-
-                def convert2code(self,color):
-                        name = self.values.keys()[color]
-                        return self.values[name][0]
-
-                def convert2string(self,color):
-                        name = self.values.keys()[color]
-                        return self.values[name][1]
-
-                def convert2matplotlib(self,color):
-                        name = self.values.keys()[color]
-                        return self.values[name][2]

=== modified file 'madanalysis/enumeration/color_type.py'
--- madanalysis/enumeration/color_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/color_type.py	2021-06-30 09:39:51 +0000
@@ -20,8 +20,35 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+
+        def __getattr__(self, name):
+            if (name)=='GRAY':
+                return list(self.values.keys()).index('GREY')
+            else:
+                return list(self.values.keys()).index(name)
+
+        def convert2string(self,color):
+            name = list(self.values.keys())[color]
+            return self.values[name][0]
+  
+        def convert2hexa(self,color):
+            name = list(self.values.keys())[color]
+            return self.values[name][1]
+
+        def convert2rootcode(self,color):
+            name = list(self.values.keys())[color]
+            return self.values[name][2]
+
+        def convert2root(self,color,shade=0):
+            name = list(self.values.keys())[color]
+            return self.values[name][3][shade+4]
+
+
+
[e-mail]_metaclass(metaclass)
 class ColorType(object):
     values = { 'AUTO'   : ['auto',     '',         0, \
                            [0,0,0,0,0,0,0,0,0] ],\
@@ -48,26 +75,3 @@
                'WHITE'  : ['white',    '#FFFFFF',   10, \
                            [10,10,10,10,10,19,18,17,16] ] }
 
-    class __metaclass__(type):
-
-        def __getattr__(self, name):
-            if (name)=='GRAY':
-                return self.values.keys().index('GREY')
-            else:
-                return self.values.keys().index(name)
-
-        def convert2string(self,color):
-            name = self.values.keys()[color]
-            return self.values[name][0]
-  
-        def convert2hexa(self,color):
-            name = self.values.keys()[color]
-            return self.values[name][1]
-
-        def convert2rootcode(self,color):
-            name = self.values.keys()[color]
-            return self.values[name][2]
-
-        def convert2root(self,color,shade=0):
-            name = self.values.keys()[color]
-            return self.values[name][3][shade+4]

=== modified file 'madanalysis/enumeration/combination_type.py'
--- madanalysis/enumeration/combination_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/combination_type.py	2021-06-30 09:39:51 +0000
@@ -20,21 +20,12 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class CombinationType(object):
-    values = { 'UNKNOWN'    : [],\
-               'DEFAULT'    : [''],\
-               'SUMSCALAR'  : ['s'],\
-               'SUMVECTOR'  : ['v'],\
-               'DIFFSCALAR' : ['ds','sd'],\
-               'DIFFVECTOR' : ['d','dv','vd'],\
-               'RATIO'      : ['r'] }
-               
-    class __metaclass__(type):
+import six
+
+class metaclass(type):
 
         def __getattr__(self, name):
-            return self.values.keys().index(name)
+            return list(self.values.keys()).index(name)
 
         def convert_from_string(self,lowerletters):
             for i,j in self.values.items():
@@ -46,5 +37,18 @@
             if index==self.__getattr__('UNKNOWN'):
                 return 'ERROR'
             else:
-                name = self.values.keys()[index]
+                name = list(self.values.keys())[index]
                 return self.values[name][0]
+
+
+
[e-mail]_metaclass(metaclass)
+class CombinationType(object):
+    values = { 'UNKNOWN'    : [],\
+               'DEFAULT'    : [''],\
+               'SUMSCALAR'  : ['s'],\
+               'SUMVECTOR'  : ['v'],\
+               'DIFFSCALAR' : ['ds','sd'],\
+               'DIFFVECTOR' : ['d','dv','vd'],\
+               'RATIO'      : ['r'] }
+               

=== modified file 'madanalysis/enumeration/connector_type.py'
--- madanalysis/enumeration/connector_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/connector_type.py	2021-06-30 09:39:51 +0000
@@ -20,27 +20,30 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class ConnectorType(object):
-    values = { 'OR'      : ["or","||"],\
-               'AND'     : ["and","&&"],\
-               'XOR'     : ["xor",""],\
-               'UNKNOWN' : ["",""]
-               }
-
-    class __metaclass__(type):
+import six
+
+class metaclass(type):
     
         def __getattr__(self, name):
-            if name in self.values.keys():
-                return self.values.keys().index(name)
+            if name in list(self.values.keys()):
+                return list(self.values.keys()).index(name)
             else:
-                return self.values.keys().index('UNKNOWN')
+                return list(self.values.keys()).index('UNKNOWN')
 
         def convert2string(self,op):
-            name = self.values.keys()[op]
+            name = list(self.values.keys())[op]
             return self.values[name][0]
 
         def convert2cpp(self,op):
-            name = self.values.keys()[op]
+            name = list(self.values.keys())[op]
             return self.values[name][1]
+
+
[e-mail]_metaclass(metaclass)
+class ConnectorType(object):
+    values = { 'OR'      : ["or","||"],\
+               'AND'     : ["and","&&"],\
+               'XOR'     : ["xor",""],\
+               'UNKNOWN' : ["",""]
+               }
+

=== modified file 'madanalysis/enumeration/cut_type.py'
--- madanalysis/enumeration/cut_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/cut_type.py	2021-06-30 09:39:51 +0000
@@ -20,19 +20,22 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class CutType(object):
-    values = { 'REJECT' : ['reject'],\
-               'SELECT' : ['select'] }
-
-    class __metaclass__(type):
+import six
+
+class metaclass(type):
 
         def __getattr__(self, name):
-            return self.values.keys().index(name)
+            return list(self.values.keys()).index(name)
 
         def convert2cmdname(self,cut):
-            name = self.values.keys()[cut]
+            name = list(self.values.keys())[cut]
             return self.values[name][0]
     
 
+
+
[e-mail]_metaclass(metaclass)
+class CutType(object):
+    values = { 'REJECT' : ['reject'],\
+               'SELECT' : ['select'] }
+

=== modified file 'madanalysis/enumeration/detect_status_type.py'
--- madanalysis/enumeration/detect_status_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/detect_status_type.py	2021-06-30 09:39:51 +0000
@@ -20,12 +20,14 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return self.values.index(name)
+
[e-mail]_metaclass(metaclass)
 class DetectStatusType(object):
         values = ['FOUND','UNFOUND','ISSUE','VETOED','TOBUILD']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                return self.values.index(name)
 

=== modified file 'madanalysis/enumeration/font_type.py'
--- madanalysis/enumeration/font_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/font_type.py	2021-06-30 09:39:51 +0000
@@ -20,31 +20,34 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class FontType(object):
-        values = {'none' : ['','','',''],\
-                  'IT'   : ['\\textit{','}','<i>','</i>'],\
-                  'BF'   : ['\\textbf{','}','<b>','</b>'],\
-                  'TT'   : ['\\texttt{','}','  <tt>','</tt>'],\
-                  'ITBF' : ['\\textit{\\textbf{','}}','<i><b>','</i></b>']}
-        
-        class __metaclass__(type):
+import six
+
+class metaclass(type):
                 def __getattr__(self, name):
-                        return self.values.keys().index(name)
+                        return list(self.values.keys()).index(name)
 
                 def convert2latex(self,font):
-                        name = self.values.keys()[font]
+                        name = list(self.values.keys())[font]
                         return self.values[name][0]
 
                 def convert2latexclose(self,font):
-                        name = self.values.keys()[font]
+                        name = list(self.values.keys())[font]
                         return self.values[name][1]
 
                 def convert2html(self,font):
-                        name = self.values.keys()[font]
+                        name = list(self.values.keys())[font]
                         return self.values[name][2]
 
                 def convert2htmlclose(self,font):
-                        name = self.values.keys()[font]
+                        name = list(self.values.keys())[font]
                         return self.values[name][3]
+
[e-mail]_metaclass(metaclass)
+class FontType(object):
+        values = {'none' : ['','','',''],\
+                  'IT'   : ['\\textit{','}','<i>','</i>'],\
+                  'BF'   : ['\\textbf{','}','<b>','</b>'],\
+                  'TT'   : ['\\texttt{','}','  <tt>','</tt>'],\
+                  'ITBF' : ['\\textit{\\textbf{','}}','<i><b>','</i></b>']}
+        
+

=== modified file 'madanalysis/enumeration/graphic_render_type.py'
--- madanalysis/enumeration/graphic_render_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/graphic_render_type.py	2021-06-30 09:39:51 +0000
@@ -20,15 +20,18 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class GraphicRenderType(object):
-        values = {'NONE' : ['none'] ,'ROOT':['Root'],'MATPLOTLIB':['Matplotlib']}
-
-        class __metaclass__(type):
+import six
+
+class metaclass(type):
             def __getattr__(self, name):
-                return self.values.keys().index(name)
+                return list(self.values.keys()).index(name)
 
             def convert2string(self,index):
-                name = self.values.keys()[index]
+                name = list(self.values.keys())[index]
                 return self.values[name][0]
+
[e-mail]_metaclass(metaclass)
+class GraphicRenderType(object):
+        values = {'NONE' : ['none'] ,'ROOT':['Root'],'MATPLOTLIB':['Matplotlib']}
+
+

=== modified file 'madanalysis/enumeration/linestyle_type.py'
--- madanalysis/enumeration/linestyle_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/linestyle_type.py	2021-06-30 09:39:51 +0000
@@ -20,27 +20,31 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
-class LineStyleType(object):
-        values = { 'SOLID'      : [1,'solid','"solid"'],\
-                   'DASHED'     : [2,'dashed','"dashed"'],\
-                   'DOTTED'     : [3,'dotted','"dotted"'],\
-                   'DASHDOTTED' : [4,'dash-dotted','"dashdot"'] }
-
-        class __metaclass__(type):
+import six
+
+
+class metaclass(type):
 
                 def __getattr__(self, name):
-                        return self.values.keys().index(name)
+                        return list(self.values.keys()).index(name)
 
                 def convert2code(self,color):
-                        name = self.values.keys()[color]
+                        name = list(self.values.keys())[color]
                         return self.values[name][0]
 
                 def convert2string(self,color):
-                        name = self.values.keys()[color]
+                        name = list(self.values.keys())[color]
                         return self.values[name][1]
 
                 def convert2matplotlib(self,style):
-                        name = self.values.keys()[style]
+                        name = list(self.values.keys())[style]
                         return self.values[name][2]
+
+
[e-mail]_metaclass(metaclass)
+class LineStyleType(object):
+        values = { 'SOLID'      : [1,'solid','"solid"'],\
+                   'DASHED'     : [2,'dashed','"dashed"'],\
+                   'DOTTED'     : [3,'dotted','"dotted"'],\
+                   'DASHDOTTED' : [4,'dash-dotted','"dashdot"'] }
+

=== modified file 'madanalysis/enumeration/ma5_running_type.py'
--- madanalysis/enumeration/ma5_running_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/ma5_running_type.py	2021-06-30 09:39:51 +0000
@@ -20,12 +20,15 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+    def __getattr__(self, name):
+        return self.values.index(name)
+
[e-mail]_metaclass(metaclass)
 class MA5RunningType(object):
         values = ['PARTON','HADRON','RECO']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                            return self.values.index(name)
+
 

=== modified file 'madanalysis/enumeration/normalize_type.py'
--- madanalysis/enumeration/normalize_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/normalize_type.py	2021-06-30 09:39:51 +0000
@@ -20,12 +20,15 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return self.values.index(name)
+
[e-mail]_metaclass(metaclass)
 class NormalizeType(object):
         values = ['NONE','LUMI','LUMI_WEIGHT']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                            return self.values.index(name)
+
 

=== modified file 'madanalysis/enumeration/observable_type.py'
--- madanalysis/enumeration/observable_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/observable_type.py	2021-06-30 09:39:51 +0000
@@ -22,58 +22,27 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
 import math
-
-class ObservableType(object):
-
-    # name : accept_particles 
-    values = { 'UNKNOWN' : [False,'','','','',0,0,0,False,False],\
-               'SQRTS' :   [False,'PHYSICS->SqrtS(event.mc())','PHYSICS->SqrtS(event.mc())','','GeV',100,0.,1000., True, False],\
-               'TET' :     [False,'PHYSICS->Transverse->EventTET(event.mc())','PHYSICS->Transverse->EventTET(event.mc())','PHYSICS->Transverse->EventTET(event.rec())','GeV',100,0.,1000., True,False],\
-               'MET' :     [False,'PHYSICS->Transverse->EventMET(event.mc())','PHYSICS->Transverse->EventMET(event.mc())','PHYSICS->Transverse->EventMET(event.rec())','GeV',100,0.,1000., True,False],\
-               'THT' :     [False,'PHYSICS->Transverse->EventTHT(event.mc())','PHYSICS->Transverse->EventTHT(event.mc())','PHYSICS->Transverse->EventTHT(event.rec())','GeV',100,0.,1000., True,False],\
-               'MHT' :     [False,'PHYSICS->Transverse->EventMHT(event.mc())','PHYSICS->Transverse->EventMHT(event.mc())','PHYSICS->Transverse->EventMHT(event.rec())','GeV',100,0.,1000.,True,False],\
-               'WEIGHTS' : [False,'PHYSICS->weights(event.mc())','PHYSICS->weights(event.mc())','','',100,0.,1., True,False],\
-               'NPID':     [False,'NPID','NPID','NPID','',100,0.,100.,False,False],\
-               'NAPID':    [False,'NAPID','NAPID','NAPID','',100,0.,100.,False,False],\
-               'E'   :     [True,'e()','e()','e()','GeV',100,0.,1000.,True,True],\
-               'M'   :     [True,'m()','m()','m()','GeV/c^{2}',100,0.,1000.,True,True],\
-               'P'   :     [True,'p()','p()','p()','GeV/c',100,0.,1000.,True,True],\
-               'ET'  :     [True,'et()','et()','et()','GeV',100,0.,1000.,True,True],\
-               'MT'  :     [True,'mt()','mt()','mt()','GeV/c^{2}',100,0.,1000.,True,True],\
-               'PT'  :     [True,'pt()','pt()','pt()','GeV/c',100,0.,1000.,True,True],\
-               'PX'  :     [True,'px()','px()','px()','GeV/c',100,-1000.,1000.,True,True],\
-               'PY'  :     [True,'py()','py()','py()','GeV/c',100,-1000.,1000.,True,True],\
-               'PZ'  :     [True,'pz()','pz()','pz()','GeV/c',100,-1000.,1000.,True,True],\
-               'R'   :     [True,'r()','r()','r()','',100,0.,1000.,True,True],\
-               'THETA' :   [True,'theta()','theta()','theta()','',100,0.,2*math.pi+0.01,True,True],\
-               'ETA' :     [True,'eta()','eta()','eta()','',100,-8.0,+8.0,True,True],\
-               'PHI' :     [True,'phi()','phi()','phi()','',100,0.,2*math.pi+0.01,True,True],\
-               'Y'   :     [True,'y()','y()','y()','',100,-8.0,+8.0,True,True],\
-               'BETA' :    [True,'beta()','beta()','beta()','',100,0.,1.,True,True],\
-               'GAMMA':    [True,'gamma()','gamma()','gamma()','',100,1.,1000.,True,True],\
-               'N'    :    [True,'N()','N()','N()','',20,0.,20.,True,True],\
-               'ISOL' :    [True,'','','isolated()','',2,0,1,True,False],\
-               'HE_EE':    [True,'','','HEoverEE()','',100,0,100,True,False],\
-               'NTRACKS':  [True,'','','ntracks()','',100,0,100,True,False]  }
-
-    class __metaclass__(type):
+import six
+
+class metaclass(type):
         def __getattr__(self, name):
-            if name in self.values.keys():
-                return self.values.keys().index(name)
+            if name in list(self.values.keys()):
+                return list(self.values.keys()).index(name)
             else:
-                return self.values.keys().index('UNKNOWN')
+                return list(self.values.keys()).index('UNKNOWN')
 
         def accept_particles(self, index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][0]
 
         def convert2string(self,index):
-            return self.values.keys()[index]
+            return list(self.values.keys())[index]
 
         def convert2job_string(self,index,level):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             if level==MA5RunningType.PARTON:
                 return self.values[name][1]
             elif level==MA5RunningType.HADRON:
@@ -83,33 +52,35 @@
             return ""
 
         def convert2unit(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][4]
 
         def convert2nbins(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][5]
 
         def convert2xmin(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][6]
 
         def convert2xmax(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][7]
 
         def isCuttable(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][8]
 
         def prefix(self,index):
-            name = self.values.keys()[index]
+            name = list(self.values.keys())[index]
             return self.values[name][9]
 
-        def get_list(self,level=MA5RunningType.PARTON):
+        def get_list(self,level=None):
+            if level == None:
+                level = MA5RunningType.PARTON
             output = []
             for item in self.values.keys():
-                x = ObservableType.convert2job_string(self.values.keys().index(item),level)
+                x = ObservableType.convert2job_string(list(self.values.keys()).index(item),level)
                 if x=="":
                     continue
                 output.append(item)
@@ -124,13 +95,15 @@
                     output.append('r'+item)
             return output
 
-        def get_cutlist1(self,level=MA5RunningType.PARTON):
+        def get_cutlist1(self,level=None):
+            if level is None:
+                level = MA5RunningType.PARTON
             output = []
             for item in self.values.keys():
                 if item=="N":
                     output.append(item)
                     continue
-                x = ObservableType.convert2job_string(self.values.keys().index(item),level)
+                x = ObservableType.convert2job_string(list(self.values.keys()).index(item),level)
                 if x=="":
                     continue
                 if not self.values[item][8]:
@@ -140,10 +113,12 @@
                 output.append(item)
             return output
 
-        def get_cutlist2(self,level=MA5RunningType.PARTON):
+        def get_cutlist2(self,level=None):
+            if level is None:
+                level = MA5RunningType.PARTON
             output = []
             for item in self.values.keys():
-                x = ObservableType.convert2job_string(self.values.keys().index(item),level)
+                x = ObservableType.convert2job_string(list(self.values.keys()).index(item),level)
                 if item=="N":
                     continue
                 if x=="":
@@ -169,3 +144,39 @@
 
 
 
+
+
[e-mail]_metaclass(metaclass)
+class ObservableType(object):
+
+    # name : accept_particles 
+    values = { 'UNKNOWN' : [False,'','','','',0,0,0,False,False],\
+               'SQRTS' :   [False,'PHYSICS->SqrtS(event.mc())','PHYSICS->SqrtS(event.mc())','','GeV',100,0.,1000., True, False],\
+               'TET' :     [False,'PHYSICS->Transverse->EventTET(event.mc())','PHYSICS->Transverse->EventTET(event.mc())','PHYSICS->Transverse->EventTET(event.rec())','GeV',100,0.,1000., True,False],\
+               'MET' :     [False,'PHYSICS->Transverse->EventMET(event.mc())','PHYSICS->Transverse->EventMET(event.mc())','PHYSICS->Transverse->EventMET(event.rec())','GeV',100,0.,1000., True,False],\
+               'THT' :     [False,'PHYSICS->Transverse->EventTHT(event.mc())','PHYSICS->Transverse->EventTHT(event.mc())','PHYSICS->Transverse->EventTHT(event.rec())','GeV',100,0.,1000., True,False],\
+               'MHT' :     [False,'PHYSICS->Transverse->EventMHT(event.mc())','PHYSICS->Transverse->EventMHT(event.mc())','PHYSICS->Transverse->EventMHT(event.rec())','GeV',100,0.,1000.,True,False],\
+               'WEIGHTS' : [False,'PHYSICS->weights(event.mc())','PHYSICS->weights(event.mc())','','',100,0.,1., True,False],\
+               'NPID':     [False,'NPID','NPID','NPID','',100,0.,100.,False,False],\
+               'NAPID':    [False,'NAPID','NAPID','NAPID','',100,0.,100.,False,False],\
+               'E'   :     [True,'e()','e()','e()','GeV',100,0.,1000.,True,True],\
+               'M'   :     [True,'m()','m()','m()','GeV/c^{2}',100,0.,1000.,True,True],\
+               'P'   :     [True,'p()','p()','p()','GeV/c',100,0.,1000.,True,True],\
+               'ET'  :     [True,'et()','et()','et()','GeV',100,0.,1000.,True,True],\
+               'MT'  :     [True,'mt()','mt()','mt()','GeV/c^{2}',100,0.,1000.,True,True],\
+               'PT'  :     [True,'pt()','pt()','pt()','GeV/c',100,0.,1000.,True,True],\
+               'PX'  :     [True,'px()','px()','px()','GeV/c',100,-1000.,1000.,True,True],\
+               'PY'  :     [True,'py()','py()','py()','GeV/c',100,-1000.,1000.,True,True],\
+               'PZ'  :     [True,'pz()','pz()','pz()','GeV/c',100,-1000.,1000.,True,True],\
+               'R'   :     [True,'r()','r()','r()','',100,0.,1000.,True,True],\
+               'THETA' :   [True,'theta()','theta()','theta()','',100,0.,2*math.pi+0.01,True,True],\
+               'ETA' :     [True,'eta()','eta()','eta()','',100,-8.0,+8.0,True,True],\
+               'PHI' :     [True,'phi()','phi()','phi()','',100,0.,2*math.pi+0.01,True,True],\
+               'Y'   :     [True,'y()','y()','y()','',100,-8.0,+8.0,True,True],\
+               'BETA' :    [True,'beta()','beta()','beta()','',100,0.,1.,True,True],\
+               'GAMMA':    [True,'gamma()','gamma()','gamma()','',100,1.,1000.,True,True],\
+               'N'    :    [True,'N()','N()','N()','',20,0.,20.,True,True],\
+               'ISOL' :    [True,'','','isolated()','',2,0,1,True,False],\
+               'HE_EE':    [True,'','','HEoverEE()','',100,0,100,True,False],\
+               'NTRACKS':  [True,'','','ntracks()','',100,0,100,True,False]  }
+

=== modified file 'madanalysis/enumeration/operator_type.py'
--- madanalysis/enumeration/operator_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/operator_type.py	2021-06-30 09:39:51 +0000
@@ -20,8 +20,25 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+    
+        def __getattr__(self, name):
+            if name in list(self.values.keys()):
+                return list(self.values.keys()).index(name)
+            else:
+                return list(self.values.keys()).index('UNKNOWN')
+
+        def convert2string(self,op):
+            name = list(self.values.keys())[op]
+            return self.values[name][0]
+
+        def convert2cpp(self,op):
+            name = list(self.values.keys())[op]
+            return self.values[name][1]
+
[e-mail]_metaclass(metaclass)
 class OperatorType(object):
     values = { 'GREATER'       : [">",">"],\
                'GREATER_EQUAL' : [">=",">="],\
@@ -32,18 +49,4 @@
                'UNKNOWN'       : ["",""]
                }
 
-    class __metaclass__(type):
-    
-        def __getattr__(self, name):
-            if name in self.values.keys():
-                return self.values.keys().index(name)
-            else:
-                return self.values.keys().index('UNKNOWN')
-
-        def convert2string(self,op):
-            name = self.values.keys()[op]
-            return self.values[name][0]
-
-        def convert2cpp(self,op):
-            name = self.values.keys()[op]
-            return self.values[name][1]
+

=== modified file 'madanalysis/enumeration/report_format_type.py'
--- madanalysis/enumeration/report_format_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/report_format_type.py	2021-06-30 09:39:51 +0000
@@ -20,26 +20,30 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+
+    def __getattr__(self, name):
+        return list(self.values.keys()).index(name)
+
+    def convert2cmd(self,format):
+        name = list(self.values.keys())[format]
+        return self.values[name][0]
+
+    def convert2string(self,format):
+        return list(self.values.keys())[format]
+
+    def convert2filetype(self,format):
+        name = list(self.values.keys())[format]
+        return self.values[name][1]
+
+    
[e-mail]_metaclass(metaclass)
 class ReportFormatType(object):
     values = { 'LATEX'    : ['generate_latex','eps'],\
                'PDFLATEX' : ['generate_pdflatex','png'],\
                'HTML'     : ['generate_html','png']  }
 
-    class __metaclass__(type):
-
-        def __getattr__(self, name):
-            return self.values.keys().index(name)
-
-        def convert2cmd(self,format):
-            name = self.values.keys()[format]
-            return self.values[name][0]
-
-        def convert2string(self,format):
-            return self.values.keys()[format]
-
-        def convert2filetype(self,format):
-            name = self.values.keys()[format]
-            return self.values[name][1]
+
 

=== modified file 'madanalysis/enumeration/sb_ratio_type.py'
--- madanalysis/enumeration/sb_ratio_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/sb_ratio_type.py	2021-06-30 09:39:51 +0000
@@ -20,20 +20,23 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+            return list(self.values.keys()).index(name)
+        
+        def convert2string(self,val):
+            name = list(self.values.keys())[val]
+            return self.values[name][0]
+
[e-mail]_metaclass(metaclass)        
 class SBratioType(object):
         values = {'S_OVER_B' : ['S/B'],\
                   'B_OVER_S' : ['B/S'],\
                   'S_OVER_SB': ['S/sqrt(S+B)']}
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                return self.values.keys().index(name)
-   
-            def convert2string(self,val):
-                name = self.values.keys()[val]
-                return self.values[name][0]
+
 
   
 

=== modified file 'madanalysis/enumeration/script_type.py'
--- madanalysis/enumeration/script_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/script_type.py	2021-06-30 09:39:51 +0000
@@ -20,29 +20,32 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return list(self.values.keys()).index(name)
+
+        def latexscript(self,script):
+                name = list(self.values.keys())[script]
+                return self.values[name][0]
+
+        def latexscriptclose(self,script):
+                name = list(self.values.keys())[script]
+                return self.values[name][1]
+
+        def htmlscript(self,script):
+                name = list(self.values.keys())[script]
+                return self.values[name][2]
+        
+        def htmlscriptclose(self,script):
+                name = list(self.values.keys())[script]
+                return self.values[name][3]
+
+
[e-mail]_metaclass(metaclass)
 class ScriptType(object):
         values = {'none' : ['','','',''],\
                           'SUB'   : ['$_{','}$','<sub>','</sub>'],\
                           'SUP'   : ['$^{','}$','<sup>','</sup>']}
 
-        class __metaclass__(type):
-                def __getattr__(self, name):
-                        return self.values.keys().index(name)
-
-                def latexscript(self,script):
-                        name = self.values.keys()[script]
-                        return self.values[name][0]
-
-                def latexscriptclose(self,script):
-                        name = self.values.keys()[script]
-                        return self.values[name][1]
-
-                def htmlscript(self,script):
-                        name = self.values.keys()[script]
-                        return self.values[name][2]
-
-                def htmlscriptclose(self,script):
-                        name = self.values.keys()[script]
-                        return self.values[name][3]

=== modified file 'madanalysis/enumeration/special_particle.py'
--- madanalysis/enumeration/special_particle.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/special_particle.py	2021-06-30 09:39:51 +0000
@@ -20,12 +20,15 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return self.values.index(name)
+
+
[e-mail]_metaclass(metaclass)
 class SpecialParticleType(object):
         values = ['NONE','ALL']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                            return self.values.index(name)
 

=== modified file 'madanalysis/enumeration/stacking_method_type.py'
--- madanalysis/enumeration/stacking_method_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/stacking_method_type.py	2021-06-30 09:39:51 +0000
@@ -20,12 +20,15 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return self.values.index(name)
+
[e-mail]_metaclass(metaclass)
 class StackingMethodType(object):
         values = ['AUTO','STACK','SUPERIMPOSE','NORMALIZE2ONE']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                            return self.values.index(name)
+
 

=== modified file 'madanalysis/enumeration/uncertainty_type.py'
--- madanalysis/enumeration/uncertainty_type.py	2020-07-03 08:05:49 +0000
+++ madanalysis/enumeration/uncertainty_type.py	2021-06-30 09:39:51 +0000
@@ -20,11 +20,14 @@
 #  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
 #  
 ################################################################################
-
-
+import six
+
+class metaclass(type):
+        def __getattr__(self, name):
+                return self.values.index(name)
+
+
[e-mail]_metaclass(metaclass)
 class UncertaintyType(object):
         values = ['POISSON','BINOMIAL','IMPROVED']
 
-        class __metaclass__(type):
-            def __getattr__(self, name):
-                            return self.values.index(name)

=== modified file 'madanalysis/fastsim/ast.py'
--- madanalysis/fastsim/ast.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/ast.py	2021-06-30 09:39:51 +0000
@@ -22,10 +22,13 @@
 ################################################################################
 
 
+from __future__ import absolute_import
+from __future__ import print_function
 import logging
 import re
 from madanalysis.fastsim.ast_leaf import Leaf
 import madanalysis.observable.observable_list as obs_list
+from six.moves import range
 
 
 class AST:
@@ -144,7 +147,7 @@
                         reset=True
                         break
                 else:
-                   print frml[i]
+                   print(frml[i])
                    aieaieaaie
             if reset:
                 continue
@@ -171,7 +174,7 @@
                             replacement_done = True
                             break
                     else:
-                       print(frml, i, '->', frml[i])
+                       print((frml, i, '->', frml[i]))
                        aieaieaaie2
                 if replacement_done:
                     break
@@ -208,7 +211,7 @@
                 new_formula.append(new_leaf)
                 self.leaves.append(new_leaf)
             # unary operators
-            elif elem.lower() in self.binary1_ops.keys():
+            elif elem.lower() in list(self.binary1_ops.keys()):
                 new_leaf = Leaf(self.size(), 'bin1_op', elem.lower(), [], [])
                 new_formula.append(new_leaf)
                 self.leaves.append(new_leaf)

=== modified file 'madanalysis/fastsim/ast_leaf.py'
--- madanalysis/fastsim/ast_leaf.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/ast_leaf.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class Leaf:
 

=== modified file 'madanalysis/fastsim/fastsim.py'
--- madanalysis/fastsim/fastsim.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/fastsim.py	2021-06-30 09:39:51 +0000
@@ -22,11 +22,14 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 from madanalysis.fastsim.ast            import AST
 from madanalysis.fastsim.tagger         import Tagger
 from madanalysis.fastsim.smearer        import Smearer
 from madanalysis.fastsim.recoefficiency import RecoEfficiency
+from madanalysis.fastsim.scaling        import Scaling
+from six.moves import range
 
 
 class SuperFastSim:
@@ -37,7 +40,12 @@
         self.tagger      = Tagger()
         self.smearer     = Smearer()
         self.reco        = RecoEfficiency()
+        self.scaling     = Scaling()
         self.jetrecomode = 'jets'
+        self.mag_field   = 1e-9
+        self.radius      = 1e+99
+        self.half_length = 1e+99
+        self.propagator  = False
         self.observables = ''
 
     def InitObservables(self, obs_list):
@@ -46,23 +54,38 @@
     # Definition of a new tagging/smearing rule
     def define(self,args,prts):
         prts.Add('c',[4])
+        prts.Add('track',[]) # PDGID is not important
+        prts.Add('JES',  []) # PDGID is not important
+        prts_remove = ['c','track','JES']
+
+        ## remove all initializations when this session is over
+        def remove_prts_def(prts_remove,prts):
+            for particle in prts_remove:
+                prts.Remove(particle,     None)
+
         ## list of PDG codes associated with a a multiparticle
         def is_pdgcode(prt):
             return (prt[0] in ('-','+') and prt[1:].isdigit()) or prt.isdigit()
 
         ## Checking the length of the argument list
         if (args[0]=='tagger' and len(args)<5) or (args[0]=='smearer' and len(args)<3) \
-           or  (args[0]=='reco_efficiency' and len(args)<3):
-            self.logger.error('Not enough arguments for a tagger/smearer/reconstruction')
-            prts.Remove('c', None)
+           or  (args[0]=='reco_efficiency' and len(args)<3) or (args[0]=='jes' and len(args)<2) \
+           or (args[0]=='energy_scaling' and len(args)<3) or (args[0]=='scaling' and len(args)<4):
+            self.logger.error('Not enough arguments for tagging/smearing/reconstruction/scaling')
+            remove_prts_def(prts_remove,prts)
             return
 
         ## Checking the first argument
-        true_id = args[1]
+        if args[0]=='jes':
+            true_id = 'JES'
+        elif args[0]=='scaling':
+            true_id = args[3]
+        else:
+            true_id = args[1]
         #### First, do we have either a multiparticle or a PDG code
         if not (true_id in prts.GetNames() or is_pdgcode(true_id)):
             self.logger.error('the 1st argument must be a PDG code or (multi)particle label')
-            prts.Remove('c', None)
+            remove_prts_def(prts_remove,prts)
             return
         #### Second let's check if we have a multiparticle associated with a unique PDGID
         if true_id in prts.GetNames() and len(list(set([abs(x) for x in prts[true_id]])))==1:
@@ -78,13 +101,13 @@
         if args[0]=='tagger':
             if args[2]!='as':
                 self.logger.error('the 2nd argument must be the keyword \'as\'')
-                prts.Remove('c', None)
+                remove_prts_def(prts_remove,prts)
                 return
             reco_id = args[3]
             #### First, do we have either a multiparticle or a PDG code
             if not (reco_id in prts.GetNames() or is_pdgcode(reco_id)):
                 self.logger.error('the 4th argument must be a PDG code or (multi)particle label')
-                prts.Remove('c', None)
+                remove_prts_def(prts_remove,prts)
                 return
             #### Second let's check if we have a multiparticle associated with a unique PDGID
             if reco_id in prts.GetNames() and len(list(set([abs(x) for x in prts[reco_id]])))==1:
@@ -101,12 +124,12 @@
         elif args[0] == 'smearer':
             if args[2]!='with':
                 self.logger.error('the 2nd argument must be the keyword \'with\'')
-                prts.Remove('c', None)
+                remove_prts_def(prts_remove,prts)
                 return
             obs = args[3].upper()
             if not (obs in self.smearer.vars):
                 self.logger.error('the 4th argument must be an observable in '+ ', '.join(self.smearer.vars))
-                prts.Remove('c', None)
+                remove_prts_def(prts_remove,prts)
                 return
             to_decode=args[4:]
 
@@ -114,11 +137,30 @@
         elif args[0] == 'reco_efficiency':
             to_decode=args[2:]
 
+        ## Jet energy scaling (and scaling in general)
+        elif args[0]=='jes':
+            to_decode=args[1:]
+            obs = 'E'
+        elif args[0]=='energy_scaling':
+            to_decode=args[2:]
+            obs = 'E'
+        elif args[0]=='scaling':
+            if args[2]!='for':
+                self.logger.error('Scaling - the 2nd argument must be the keyword \'for\'')
+                remove_prts_def(prts_remove,prts)
+                return
+            obs = args[1].upper()
+            if not (obs in self.scaling.vars):
+                self.logger.error('Scaling - the 1st argument must be an observable in '+ ', '.join(self.scaling.vars))
+                remove_prts_def(prts_remove,prts)
+                return
+            to_decode=args[4:]
+
         ## Getting the bounds and the function
         function, bounds = self.decode_args(to_decode)
         if function=='':
             self.logger.error('Cannot decode the function or the bounds - ' + args[0] + ' ignored.')
-            prts.Remove('c', None)
+            remove_prts_def(prts_remove,prts)
             return
 
         ## Adding a rule to a tagger/smearer
@@ -128,7 +170,9 @@
             self.smearer.add_rule(true_id,obs,function,bounds)
         elif args[0]=='reco_efficiency':
             self.reco.add_rule(true_id,function,bounds)
-        prts.Remove('c', None)
+        elif args[0] in ['jes','energy_scaling','scaling']:
+            self.scaling.add_rule(true_id,obs,function,bounds)
+        remove_prts_def(prts_remove,prts)
         return
 
 
@@ -184,6 +228,8 @@
         ast_eff.feed(efficiency)
         return ast_eff, ast_bounds
 
+
+
     # Display of a taggers/smearer
     def display(self,args):
         if args[0]=='tagger':
@@ -192,6 +238,28 @@
             self.smearer.display(self.jetrecomode)
         elif args[0]=='reco_efficiency':
             self.reco.display()
+        elif args[0] in ['jes','energy_scaling','scaling']:
+            self.scaling.display(self.jetrecomode)
         return
 
 
+
+    # On/off checks
+    def isRecoOn(self):
+        return self.reco.rules != {}
+    def isTaggerOn(self):
+        return self.tagger.rules != {}
+    def isSmearerOn(self):
+        return self.smearer.rules != {}
+    def isPropagatorOn(self):
+        return self.propagator
+    def isScalingOn(self):
+        return self.scaling.rules != {}
+    def isRecoSmearerOn(self):
+        # all modules that modifies new_smearer body
+        return (self.isScalingOn() or self.isSmearerOn() or self.isRecoOn())
+    def isNewSmearerOn(self):
+        # all modules that modifies new_smearer header
+        return (self.isRecoSmearerOn() or self.isPropagatorOn())
+    def isSFSOn(self):
+        return (self.isNewSmearerOn() or self.isTaggerOn())

=== modified file 'madanalysis/fastsim/recoefficiency.py'
--- madanalysis/fastsim/recoefficiency.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/recoefficiency.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class RecoEfficiency:
 
@@ -38,11 +39,11 @@
         if not self.is_supported(id_reco):
             return
         ## Checking whether the reco/true pair already exists
-        key_number=len(self.rules.keys())+1
+        key_number=len(list(self.rules.keys()))+1
         for key, value in self.rules.items():
             if value['id_reco']==id_reco:
                 key_number = key
-        if not key_number in self.rules.keys():
+        if not key_number in list(self.rules.keys()):
             self.rules[key_number] = { 'id_reco':id_reco, 'efficiencies':{} }
 
         ## Defining a new rule ID for an existing tagger
@@ -73,8 +74,8 @@
 
 
     def is_supported(self, id_reco):
-        supported = {'e':'11', 'mu':'13', 'ta':'15', 'j':'21', 'a':'22'}
-        if id_reco in (supported.keys()+supported.values()):
+        supported = {'e':'11', 'mu':'13', 'ta':'15', 'j':'21', 'a':'22', 'track':'track'}
+        if id_reco in (list(supported.keys())+list(supported.values())):
             return True
         self.logger.error('The reconstruction of such an object (' + id_reco + ') is currently not supported.'+\
                               ' Reconstruction ignored.')

=== added file 'madanalysis/fastsim/scaling.py'
--- madanalysis/fastsim/scaling.py	1970-01-01 00:00:00 +0000
+++ madanalysis/fastsim/scaling.py	2021-06-30 09:39:51 +0000
@@ -0,0 +1,104 @@
+################################################################################
+#  
+#  Copyright (C) 2012-2020 Jack Araz, Eric Conte & Benjamin Fuks
+#  The MadAnalysis development team, email: <[e-mail]>
+#  
+#  This file is part of MadAnalysis 5.
+#  Official website: <https://launchpad.net/madanalysis5>
+#  
+#  MadAnalysis 5 is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#  
+#  MadAnalysis 5 is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU General Public License for more details.
+#  
+#  You should have received a copy of the GNU General Public License
+#  along with MadAnalysis 5. If not, see <http://www.gnu.org/licenses/>
+#  
+################################################################################
+
+
+from __future__ import absolute_import
+import logging
+class Scaling:
+
+    # Initialization
+    def __init__(self):
+        self.logger    = logging.getLogger('MA5');
+        self.rules     = {}
+        self.vars      = ['PT','ETA','PHI','E','PX','PY','PZ']
+
+
+    # Adding a rule to the tagger
+    # The bounds and function are written as ASTs
+    # JES option is to make sure that the jet scaling is only applied on 
+    # clustered jets
+    def add_rule(self, id_true, obs, function, bounds):
+        ## Checking whether the smearer is supported
+        check, id_true = self.is_supported(id_true, obs)
+        if not check:
+            return
+        ## Checking whether the reco/true pair already exists
+        key_number=len(list(self.rules.keys()))+1
+        for key, value in self.rules.items():
+            if value['id_true']==id_true and value['obs']==obs:
+                key_number = key
+        if not key_number in list(self.rules.keys()):
+            self.rules[key_number] = { 'id_true':id_true, 'obs':obs,
+              'efficiencies':{}}
+
+        ## Defining a new rule ID for an existing tagger
+        eff_key = len(self.rules[key_number]['efficiencies'])+1
+        self.rules[key_number]['efficiencies'][eff_key] = { 'function':function,
+            'bounds': bounds }
+
+
+    def display(self, jetrecomode):
+        self.logger.info('*********************************')
+        self.logger.info('       Scaling information       ')
+        self.logger.info('*********************************')
+        if list(self.rules.keys()) != []:
+            self.logger.info(' - Running in the '+jetrecomode+' reconstruction mode.')
+        for key in self.rules.keys():
+            myrule = self.rules[key]
+            if myrule['id_true'] == 'JES':
+                self.logger.info(str(key) + ' - Jet Energy Scaling')
+            else:
+                self.logger.info(str(key) + ' - Scaling an object of PDG ' + str(myrule['id_true']) + \
+                   ' from  the observable ' + str(myrule['obs']))
+            for eff_key in myrule['efficiencies'].keys():
+                cpp_name = 'scale_'+str(myrule['id_true'])+'_'+str(myrule['obs'])+\
+                  '_'+str(eff_key)
+                bnd_name = 'bnd_'+str(myrule['id_true'])+'_'+str(myrule['obs'])+\
+                  '_'+str(eff_key)
+                myeff = myrule['efficiencies'][eff_key]
+                self.logger.info('  ** function: ' + myeff['function'].tostring())
+                self.logger.info('  ** bounds:   ' + myeff['bounds'].tostring())
+                self.logger.debug(' C++ version for the function: \n        '  + \
+                   myeff['function'].tocpp('MAdouble64', cpp_name).replace('\n','\n        '))
+                self.logger.debug(' C++ version for the bounds: \n        '  + \
+                   myeff['bounds'].tocpp('MAbool', bnd_name).replace('\n','\n        '))
+                self.logger.info('  --------------------')
+            self.logger.info('  --------------------')
+
+
+    def is_supported(self,id_true,obs):
+        supported = {'e':'11', 'mu':'13', 'ta':'15', 'j':'21', 'a':'22', 'track':'track', 'JES':'JES'}
+        if not obs in self.vars:
+            self.logger.error('Unsupported scaling. The scaling variable must be part of ' + \
+              ', '.join(self.vars))
+            self.logger.error('Scaling ignored')
+            return False, id_true
+        if id_true in list(supported.keys()):
+            return True, supported[id_true]
+        elif id_true in list(supported.values()):
+            return True, id_true
+        else:
+            self.logger.error('Unsupported scaling ('+id_true+'). Only the following objects can be scaled: '\
+                 + ', '.join(list(supported.keys())))
+            self.logger.error('Scaling ignored')
+            return False, id_true

=== modified file 'madanalysis/fastsim/smearer.py'
--- madanalysis/fastsim/smearer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/smearer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class Smearer:
 
@@ -29,7 +30,7 @@
     def __init__(self):
         self.logger = logging.getLogger('MA5');
         self.rules = {}
-        self.vars = ['PT','ETA','PHI','E','PX','PY','PZ'] 
+        self.vars = ['PT','ETA','PHI','E','PX','PY','PZ','D0','DZ']
 
 
     # Adding a rule to the tagger
@@ -40,11 +41,11 @@
         if not check:
             return
         ## Checking whether the reco/true pair already exists
-        key_number=len(self.rules.keys())+1
+        key_number=len(list(self.rules.keys()))+1
         for key, value in self.rules.items():
             if value['id_true']==id_true and value['obs']==obs:
                 key_number = key
-        if not key_number in self.rules.keys():
+        if not key_number in list(self.rules.keys()):
             self.rules[key_number] = { 'id_true':id_true, 'obs':obs,
               'efficiencies':{} }
 
@@ -58,7 +59,7 @@
         self.logger.info('*********************************')
         self.logger.info('       Smearer information       ')
         self.logger.info('*********************************')
-        if self.rules.keys() != []:
+        if list(self.rules.keys()) != []:
             self.logger.info(' - Running in the '+jetrecomode+' reconstruction mode.')
         for key in self.rules.keys():
             myrule = self.rules[key]
@@ -81,18 +82,18 @@
 
 
     def is_supported(self,id_true,obs):
-        supported = {'e':'11', 'mu':'13', 'ta':'15', 'j':'21', 'a':'22'}
+        supported = {'e':'11', 'mu':'13', 'ta':'15', 'j':'21', 'a':'22', 'track':'track'}
         if not obs in self.vars:
             self.logger.error('Unsupported smearer. The smeared variable must be part of ' + \
               ', '.join(self.vars))
             self.logger.error('Smearer ignored')
             return False, id_true
-        if id_true in supported.keys():
+        if id_true in list(supported.keys()):
             return True, supported[id_true]
-        elif id_true in supported.values():
+        elif id_true in list(supported.values()):
             return True, id_true
         else:
             self.logger.error('Unsupported smearer ('+id_true+'). Only the following objects can be smeared: '\
-                 + ', '.join(supported.keys()))
+                 + ', '.join(list(supported.keys())))
             self.logger.error('Smearer ignored')
             return False, id_true

=== modified file 'madanalysis/fastsim/tagger.py'
--- madanalysis/fastsim/tagger.py	2020-07-03 08:05:49 +0000
+++ madanalysis/fastsim/tagger.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 class Tagger:
 
@@ -38,11 +39,11 @@
         if not self.is_supported(id_true, id_reco):
             return
         ## Checking whether the reco/true pair already exists
-        key_number=len(self.rules.keys())+1
+        key_number=len(list(self.rules.keys()))+1
         for key, value in self.rules.items():
             if value['id_true']==id_true and value['id_reco']==id_reco:
                 key_number = key
-        if not key_number in self.rules.keys():
+        if not key_number in list(self.rules.keys()):
             self.rules[key_number] = { 'id_true':id_true, 'id_reco':id_reco,
               'efficiencies':{} }
 
@@ -80,7 +81,7 @@
         supported = { '5':['21','4','5'], '4':['21','4','5'], '15':['15','21'],
                       '21' : ['11','13','22'], '11' : ['13','22', '21'],
                       '13' : ['11','22'],      '22' : ['11','13', '21']}
-        if id_reco not in supported.keys() or id_true not in supported[id_reco]:
+        if id_reco not in list(supported.keys()) or id_true not in supported[id_reco]:
             self.logger.error('This tagger is currently not supported (tagging '+ id_true + ' as ' + id_reco + '). Tagger ignored.')
             return False
         return True

=== modified file 'madanalysis/install/detector_manager.py'
--- madanalysis/install/detector_manager.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/detector_manager.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_manager      import InstallManager
 class DetectorManager():
 

=== modified file 'madanalysis/install/install_delphes.py'
--- madanalysis/install/install_delphes.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_delphes.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service    import InstallService
 from madanalysis.system.user_info           import UserInfo
 from madanalysis.system.config_checker      import ConfigChecker
@@ -48,15 +49,12 @@
         self.downloaddir = self.main.session_info.downloaddir
         self.untardir    = os.path.join(self.tmpdir, 'MA5_'+self.package)
         self.ncores      = 1
-#        self.files = {"delphes.tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.1.1.tar.gz"}
-#        self.files = {"delphes.tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.3.0.tar.gz"}
-#        self.files = {"delphes.tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.3.1.tar.gz"}
-#        self.files = {"delphes.tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.3.3.tar.gz"}
         if package == 'delphesma5tune':
-            self.files = {package+".tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.4.1.tar.gz"}
+            self.files = {package+".tar.gz" : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/delphes-3.5.0.tar.gz"}
         else:
 #             self.files = {package+".tar.gz" : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/WikiStart/delphes342pre.tar.gz"} # Delphes for LLP not release yet
-            self.files = {package+".tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.4.2.tar.gz"}
+#            self.files = {package+".tar.gz" : "http://cp3.irmp.ucl.ac.be/downloads/Delphes-3.4.2.tar.gz"}
+            self.files = {package+".tar.gz" : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/delphes3.4.3.tar.gz"}
         self.logger = logging.getLogger('MA5')
 
 
@@ -406,6 +404,49 @@
         return True
 
 
+    def AddD0(self,filename):
+        # open input file
+        try:
+            input = open(filename)
+        except:
+            self.logger.error("impossible to read the file:" + filename)
+            return False
+
+        # open output file
+        try:
+            output = open(filename+'.savema5','w')
+        except:
+            self.logger.error("impossible to read the file:" + filename+'.savema5')
+            return False
+
+        # lines
+        for line in input:
+            line2=line.lstrip()
+            line2=line2.rstrip()
+            line2=line2.replace(' ','')
+            if line2.startswith('buffer.ReplaceAll("energy"'):
+                output.write(line)
+                output.write('  buffer.ReplaceAll("d0",     "t");\n')
+            else:
+                output.write(line)
+ 
+        #close
+        input.close()
+        output.close()
+
+        try:
+            shutil.copy(filename+'.savema5',filename)
+        except:
+            self.logger.error("impossible to copy "+filename+'.savema5 in '+filename)
+            return False
+
+        return True
+
+
+
+
+
+
     def CopyFiles(self,filesToAdd):
 
         for file in filesToAdd:
@@ -507,7 +548,7 @@
         # Updating the architecture
         deac_path = libpaths[0].replace(libpaths[0].split('/')[-1],"DEACT_"+libpaths[0].split('/')[-1])
         self.main.archi_info.toLDPATH1 = [x for x in self.main.archi_info.toLDPATH1 if not self.package in x]
-        if key in self.main.archi_info.libraries.keys():
+        if key in list(self.main.archi_info.libraries.keys()):
             del self.main.archi_info.libraries[key]
 
         # If the deactivated directory already exists -> suppression
@@ -618,7 +659,7 @@
         checkup = CheckUp(self.main.archi_info, self.main.session_info, False, self.main.script)
         for link in [x.split('/')[-1] for x in originals]:
             dest = os.path.join(self.main.archi_info.ma5dir,'tools','SampleAnalyzer', 'ExternalSymLink', link)
-            if not checkup.CreateSymLink(x,dest):
+            if not checkup.CreateSymLink(link,dest):
                 return -1
 
         # Compiler setup

=== modified file 'madanalysis/install/install_fastjet.py'
--- madanalysis/install/install_fastjet.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_fastjet.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/install/install_fastjetcontrib.py'
--- madanalysis/install/install_fastjetcontrib.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_fastjetcontrib.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/install/install_gnuplot.py'
--- madanalysis/install/install_gnuplot.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_gnuplot.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/install/install_manager.py'
--- madanalysis/install/install_manager.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_manager.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 import sys
 

=== modified file 'madanalysis/install/install_matplotlib.py'
--- madanalysis/install/install_matplotlib.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_matplotlib.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/install/install_numpy.py'
--- madanalysis/install/install_numpy.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_numpy.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/install/install_pad.py'
--- madanalysis/install/install_pad.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_pad.py	2021-06-30 09:39:51 +0000
@@ -22,13 +22,11 @@
 ################################################################################
 
 
+from __future__                          import absolute_import
 from madanalysis.install.install_service import InstallService
-from shell_command import ShellCommand
-import glob
-import os
-import sys
-import logging
-import shutil
+from shell_command                       import ShellCommand
+import glob, os, logging, shutil
+
 
 class InstallPad:
 
@@ -44,19 +42,20 @@
         self.untardir    = ""
         self.ncores      = 1
         self.files= {
-          "pad.dat"    : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/pad2.dat",
-          "bib_pad.dat": "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/bib_pad2.dat",
-          "json_pad.dat":"http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/json_pad.dat"
+          "pad.dat"    : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/pad3.dat",
+          "bib_pad.dat": "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/bib_pad3.dat",
+          "json_pad.dat":"http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/json_pad3.dat"
         }
         if padname=='PADForMA5tune':
             self.files  = {
-             "padma5tune.dat"   : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/padma5tune.dat",
-             "bib_padma5tune.dat": "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/bib_padma5tune.dat"
+             "padma5tune.dat"   : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/padma5tune3.dat",
+             "bib_padma5tune.dat": "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/bib_pad3.dat"
             }
         elif padname=='PADForSFS':
             self.files  = {
-             "padsfs.dat"     : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SFS/padsfs.dat",
-             "bib_padsfs.dat" : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SFS/bib_padsfs.dat"
+             "padsfs.dat"     : "https://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SFS/padsfs3.dat",
+             "bib_padsfs.dat" : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/bib_pad3.dat",
+             "json_padsfs.dat": "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SFS/json_padsfs3.dat"
             }
         self.analyses       = []
         self.analysis_files = []
@@ -103,7 +102,7 @@
         if self.padname == 'PADForMA5tune':
             filename="cms_sus_13_011"
         elif self.padname == 'PADForSFS':
-            filename="sfs_test"
+            filename="atlas_susy_2016_07"
         logging.getLogger('MA5').debug('Calling the expert mode for file ' + filename)
         logging.getLogger('MA5').debug('BEGIN ExpertMode')
         from madanalysis.core.expert_mode import ExpertMode
@@ -141,24 +140,12 @@
         # EXIT
         return True
 
-    # Formatting
-    def formatting(self,analysis):
-        new_analysis =     analysis.replace('ATLAS_1604_07773'     ,'atlas_exot_2015_03')
-        new_analysis = new_analysis.replace('ATLAS_1711_03301'     ,'atlas_exot_2016_27')
-        new_analysis = new_analysis.replace('ATLAS_SUSY_16_07'     ,'atlas_susy_2016_07')
-        new_analysis = new_analysis.replace('atlas_1605_03814'     ,'atlas_susy_2015_06')
-        new_analysis = new_analysis.replace('CMS_EXO_16_012_2gamma','cms_exo_16_012')
-        new_analysis = new_analysis.replace('atlas_1405_7875', 'atlas_susy_2013_02')
-        new_analysis = new_analysis.replace('atlas_sus_13_05' ,'atlas_susy_2013_05')
-        new_analysis = new_analysis.replace('-','_')
-        return new_analysis.lower()
-
     def Download(self):
         # Checking connection with InSpire and the ma5 website
-        if not InstallService.check_inspire():
-            return False
         if not InstallService.check_ma5site():
             return False
+        if not InstallService.check_dataverse():
+            return False
 
         # Downloading the files with the information on the implemented analyses
         logname = os.path.normpath(self.installdir+'/wget_mainfiles.log')
@@ -167,14 +154,17 @@
 
         # Json information for pyhf
         json_dictionary    = {}
-        if self.padname=='PAD':
-            logging.getLogger('MA5').debug(" ** Getting the list of pyhf-cpompatible analyses in " + self.downloaddir+"/json_pad.dat")
-            json_input = open(os.path.join(self.downloaddir,'json_pad.dat'));
-            for line in json_input:
-                if len(line.strip())==0 or line.strip().startswith('#'):
-                    continue;
-                json_dictionary[line.strip().split('|')[0].strip()] = line.strip().split('|')[1].split();
-            json_input.close();
+        if self.padname in ['PAD', 'PADForSFS']:
+            json_struct_name = [x for x in self.files.keys() if 'json' in x]
+            if len(json_struct_name) == 1:
+                logging.getLogger('MA5').debug(" ** Getting the list of pyhf-compatible analyses in " +\
+                                               self.downloaddir+"/"+json_struct_name[0])
+                json_input = open(os.path.join(self.downloaddir,json_struct_name[0]));
+                for line in json_input:
+                    if len(line.strip())==0 or line.strip().startswith('#'):
+                        continue;
+                    json_dictionary[line.strip().split('|')[0].strip()] = [ line.strip().split('|')[1].split(), line.strip().split('|')[2].split()];
+                json_input.close();
 
         # Getting the analysis one by one (and creating first skeleton analyses for each of them)
         logging.getLogger('MA5').debug('Reading the analysis list in ' + \
@@ -194,59 +184,75 @@
             url      = line.split('|')[1].strip()
             delphes  = line.split('|')[2].strip()
             dscrptn  = line.split('|')[3].strip()
-            new_delphes  = self.formatting(delphes)
-            new_analysis = self.formatting(analysis)
+            # getting the dataverse URLs
+            delphes_url='';
+            if 'dataverse' in delphes:
+                delphes_url = 'https://dataverse.uclouvain.be/api/access/datafile/'+delphes.split()[-1][:-1];
+                if len(analysis)==0 and len(url)==0:
+                   delphes = delphes.split()[1]
+                elif self.padname!='PADForSFS':
+                   delphes = 'delphes_card_'+delphes.split()[1]+'.tcl';
+                else:
+                   delphes = 'sfs_card_'+delphes.split()[1]+'.ma5';
             # filling the global vectors
             if len(analysis)==0 and len(url)==0:
                 self.pileup_files.append(delphes)
-            elif not new_delphes in self.delphes_cards:
-                self.delphes_cards.append(new_delphes)
-                delphes_dictionary[new_delphes] = [new_analysis]
+            elif not delphes in self.delphes_cards:
+                self.delphes_cards.append(delphes)
+                delphes_dictionary[delphes] = [analysis]
             else:
-                delphes_dictionary[new_delphes].append(new_analysis)
+                delphes_dictionary[delphes].append(analysis)
                 download_delphes = False
             logname  = os.path.join(self.installdir,self.padname+'-'+analysis+'.log')
             files = {}
             # Making space in the PAD for the analysis and preparing to download the analysis files
             if len(analysis)!=0 and len(url)!=0:
-                logging.getLogger('MA5').debug(" ** Getting the analysis " + new_analysis + ' located at ' + url)
+                logging.getLogger('MA5').debug(" ** Getting the analysis " + analysis + ' located at ' + url)
                 ## Creating a skeleton if necessary (+ inclusion in the analysis list and in the main)
-                if not new_analysis in ["cms_b2g_12_012", "cms_sus_13_011", "sfs_test"]:
-                    logging.getLogger('MA5').debug('  --> Creating a skeleton analysis for ' + new_analysis)
-                    TheCommand = ['./newAnalyzer.py', new_analysis, new_analysis]
+                if not (analysis in ["cms_b2g_12_012", "cms_sus_13_011"] or (analysis=="atlas_susy_2016_07" and self.padname=='PADForSFS')):
+                    logging.getLogger('MA5').debug('  --> Creating a skeleton analysis for ' + analysis)
+                    TheCommand = ['./newAnalyzer.py', analysis, analysis]
                     logging.getLogger('MA5').debug('  -->  ' + ' '.join(TheCommand))
-                    ok, out= ShellCommand.ExecuteWithLog(TheCommand,logname,self.installdir+'/Build/SampleAnalyzer',silent=False)
+                    ok, out= ShellCommand.ExecuteWithLog(TheCommand,logname,
+                                                         self.installdir+'/Build/SampleAnalyzer',
+                                                         silent=False)
                     if not ok:
                         return False
                 ## Making space for the new files
-                for onefile in ['Build/SampleAnalyzer/User/Analyzer/'+new_analysis+'.cpp', 'Build/SampleAnalyzer/User/Analyzer/'+new_analysis+'.h', 'Build/Main/main.bak']:
+                for onefile in ['Build/SampleAnalyzer/User/Analyzer/'+analysis+'.cpp', 
+                                'Build/SampleAnalyzer/User/Analyzer/'+analysis+'.h', 
+                                'Build/Main/main.bak']:
                     TheCommand = ['rm', '-f', os.path.join(self.installdir,onefile)]
                     logging.getLogger('MA5').debug('  -->  ' + ' '.join(TheCommand))
                     ok= ShellCommand.Execute(TheCommand,self.main.archi_info.ma5dir+'/tools')
                     if not ok:
                         return False
                 ## Preparing the download of the analysis files
-                if url=='MA5-local':
-                    url='http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/'
-                    if self.padname == 'PADForSFS':
-                        url += 'SFS'
-                    else:
-                        url += 'MA5SandBox'
+                if 'dataverse' in url:
+                    exts = ['cpp', 'h', 'info'];
+                    anl_files = url.split(']')[0].split()[1:];
+                    for i in range(len(anl_files)):
+                        files[analysis+'.'+exts[i]] = 'https://dataverse.uclouvain.be/api/access/datafile/'+anl_files[i];
+                    ## json files
+                    if analysis in list(json_dictionary.keys()):
+                        for i_json in range(len(json_dictionary[analysis][0])):
+                            files[analysis+'_'+json_dictionary[analysis][0][i_json]+'.json'] =\
+                               'https://dataverse.uclouvain.be/api/access/datafile/' + json_dictionary[analysis][1][i_json]
+                            self.json_cards.append(analysis+'_'+json_dictionary[analysis][0][i_json]+'.json')
+                            self.analysis_files.append(analysis+'_'+json_dictionary[analysis][0][i_json]+'.json')
                 else:
-                    url=os.path.join(url,'files')
-                for extension in ['cpp', 'info', 'h']:
-                    if analysis=='cms_exo_12_048' and extension=='info':
-                        files[new_analysis+'.'+extension] = os.path.join(url,analysis+'.'+extension+'?version=1')
+                    if url=='MA5-local':
+                        url='http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/'
+                        if self.padname == 'PADForSFS':
+                            url += 'SFS'
+                        else:
+                            url += 'MA5SandBox'
                     else:
-                        files[new_analysis+'.'+extension] = os.path.join(url,analysis+'.'+extension)
-                    self.analysis_files.append(new_analysis+'.'+extension)
-                analysis_info[new_analysis] = dscrptn
-                ## Preparing to downloading the necessary json files
-                if analysis in json_dictionary.keys():
-                    for json in json_dictionary[analysis]:
-                        files[new_analysis+'_'+json+'.json'] = os.path.join(url,new_analysis+'_'+json+'.json')
-                        self.json_cards.append(new_analysis+'_'+json+'.json')
-                        self.analysis_files.append(new_analysis+'_'+json+'.json')
+                        url=os.path.join(url,'files')
+                    for extension in ['cpp', 'info', 'h']:
+                        files[analysis+'.'+extension] = os.path.join(url,analysis+'.'+extension)
+                        self.analysis_files.append(analysis+'.'+extension)
+                analysis_info[analysis] = dscrptn
             # Preparing to download the delphes card
             detector  = "delphes"
             wiki_page = 'MA5SandBox'
@@ -254,14 +260,14 @@
                 detector  = "MA5-SFS"
                 wiki_page = 'SFS'
             if len(delphes)!=0 and download_delphes:
-                logging.getLogger('MA5').debug(" ** Getting the " + detector + " card " + new_delphes)
-                if len(analysis)!=0:
-                    files[new_delphes] = os.path.join('http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/'+wiki_page, delphes)
-                else:
+                logging.getLogger('MA5').debug(" ** Getting the " + detector + " card " + delphes)
+                if not 'dataverse' in delphes_url:
                     files[delphes] = os.path.join('http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/'+wiki_page, delphes)
+                else:
+                    files[delphes] = delphes_url;
             # download in a temporary folder
-            if len(new_analysis)!=0:
-                logging.getLogger('MA5').info('    --> Downloading the files for ' + new_analysis)
+            if len(analysis)!=0:
+                logging.getLogger('MA5').info('    --> Downloading the files for ' + analysis)
             else:
                 logging.getLogger('MA5').info('    --> Downloading the pileup file ' + delphes)
             for onefile in files.values():
@@ -296,45 +302,12 @@
         return True
 
     def Unpack(self):
-        # Restoring the compatibility with MA5 versions posterior to v1.4
-        logging.getLogger('MA5').debug(" ** Restoring the compatibility with MA5 versions posterior to v1.4")
+        # Copying the analysis files
         for analysis in self.analyses:
-            new_analysis = self.formatting(analysis)
             for extension in ['h','cpp', 'info']:
-                newfile=open(os.path.join(self.PADdir,      new_analysis + '.'+extension),'w')
-                oldfile=open(os.path.join(self.downloaddir, new_analysis + '.'+extension),'r')
-                rootheaders=False
-                for line in oldfile:
-                    if 'RootMainHeaders.h' in line:
-                        rootheaders=True
-                    if 'TLorentzVector' in line:
-                        if new_analysis=='atlas_susy_2013_05' and extension=='h' and self.padname=='PADForMA5tune':
-                            newfile.write(line.replace('TLorentzVector','MA5::MALorentzVector'))
-                        else:
-                            newfile.write(line.replace('TLorentzVector','MALorentzVector'))
-                    elif 'WARNING' in line:
-                        newfile.write(line.replace('WARNING','//WARNING'))
-                    elif new_analysis=='atlas_susy_2013_02' and 'pt() > 130' in line and '6jm' in line and not 'AddCut' in line:
-                        newfile.write('}}}}\n')
-                        newfile.write(line)
-                    elif new_analysis=='atlas_conf_2019_040' and 'if (signalJets.size()>=1' in line:
-                        newfile.write('    if (signalJets.size()>1)\n')
-                    elif new_analysis in ['atlas_exot_2014_06', 'cms_exo_12_047'] and 'preselection=' in line:
-                        newfile.write(line.replace('preselection=','preselection=myEventWeight*'))
-                    elif new_analysis in ['atlas_exot_2016_32'] and 'tight=' in line:
-                        newfile.write(line.replace('tight=','tight=myEventWeight*'))
-                    elif analysis in line:
-                        newfile.write(line.replace(analysis, new_analysis))
-                    else:
-                        newfile.write(line)
-                newfile.close()
-                oldfile.close()
-                if (extension == 'h') and not rootheaders and self.padname != 'PADForSFS':
-                    with open(os.path.join(self.PADdir, new_analysis+'.'+extension), 'r+') as f:
-                        content = f.read()
-                        f.seek(0, 0)
-                        f.truncate()
-                        f.write(content.replace('#include','#include \"SampleAnalyzer/Interfaces/root/RootMainHeaders.h\"\n#include'))
+                newfile = os.path.join(self.PADdir,      analysis + '.'+extension)
+                oldfile = os.path.join(self.downloaddir, analysis + '.'+extension)
+                shutil.copy(oldfile,newfile)
 
         # json files fopr pyhf
         for json in self.json_cards:

=== modified file 'madanalysis/install/install_pyhf.py'
--- madanalysis/install/install_pyhf.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_pyhf.py	2021-06-30 09:39:51 +0000
@@ -22,11 +22,10 @@
 ################################################################################
 
 
+from __future__                          import absolute_import
 from madanalysis.install.install_service import InstallService
-from shell_command import ShellCommand
-import os
-import sys
-import logging
+import os, sys, logging
+
 
 class Installpyhf:
     def __init__(self,main):
@@ -37,8 +36,12 @@
         self.downloaddir = self.main.session_info.downloaddir
         self.untardir    = os.path.normpath(self.tmpdir + '/MA5_pyhf/')
         self.ncores      = 1
-        self.files = {"pyhf.tar.gz" : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/MA5SandBox/pyhf_v0.1.2.tar.gz"}
-        self.pyhf_version= "0.1.2";
+        if sys.version_info[0] == 2:
+            self.files = {"pyhf_python2.tar.gz" : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SRCombinations/pyhf_python2.tar.gz"}
+            self.pyhf_version= "0.1.2"
+        elif sys.version_info[0] > 2:
+            self.files = {"pyhf_py3.tgz" : "http://madanalysis.irmp.ucl.ac.be/raw-attachment/wiki/SRCombinations/pyhf_py3.tgz"}
+            self.pyhf_version= "0.5.4"
 
     def Detect(self):
         if not os.path.isdir(self.toolsdir):
@@ -82,29 +85,18 @@
         # Logname
         logname = os.path.normpath(self.installdir+'/unpack.log')
         # Unpacking the tarball
-        ok, packagedir = InstallService.untar(logname, self.downloaddir, self.installdir,'pyhf.tar.gz')
-        if not ok:
-            return False
+        for key in self.files.keys():
+            ok, packagedir = InstallService.untar(logname, self.downloaddir, self.installdir, key)
+            if not ok:
+                return False
         # Ok: returning the good folder
         self.tmpdir=packagedir
         return True
 
 
     def Build(self):
-        # Input
-        theCommands=[sys.executable,'setup.py','build']
-        logname=os.path.normpath(self.installdir+'/compilation.log')
-        # Execute
-        logging.getLogger('MA5').debug('shell command: '+' '.join(theCommands))
-        ok, out= ShellCommand.ExecuteWithLog(theCommands,\
-                                             logname,\
-                                             self.tmpdir,\
-                                             silent=False)
-        # return result
-        if not ok:
-            logging.getLogger('MA5').error('impossible to build the project. For more details, see the log file:')
-            logging.getLogger('MA5').error(logname)
-        return ok
+        # all checks are done in Check function.
+        return True
 
 
     def Install(self):
@@ -114,14 +106,24 @@
     def Check(self):
         try:
             if os.path.isdir(self.installdir) and not self.installdir in sys.path:
-                sys.path.append(self.installdir)
+                sys.path.insert(0, self.installdir+(sys.version_info[0] > 2)*'/src/')
             import pyhf
+            self.logger.debug("pyhf has been imported from "+" ".join(pyhf.__path__))
             if str(pyhf.__version__) != self.pyhf_version:
-                logging.getLogger('MA5').error("Not using the right version of pyhf.")
+                if sys.version_info[0] > 2:
+                    logging.getLogger('MA5').warning("An incorrect version of pyhf has been detected ("+str(pyhf.__version__)+")");
+                    logging.getLogger('MA5').warning("Please note that MadAnalysis 5 currently supports pyhf version "+\
+                                                     str(self.pyhf_version))
+                    return True
+                logging.getLogger('MA5').error("An incorrect version of pyhf has been detected ("+str(pyhf.__version__)+")");
+                logging.getLogger('MA5').error("Please note that MadAnalysis 5 currently supports pyhf version "+\
+                                               str(self.pyhf_version))
                 self.display_log()
                 return False
-        except:
-            logging.getLogger('MA5').error("Cannot use pyhf. Please double check the required dependencies and/or (re-)install it.")
+        except ImportError as err:
+            logging.getLogger('MA5').error("The pyhf module cannot be used. Please check that all requirements are available and (re-)install it.")
+            logging.getLogger('MA5').error("Using phyf requires the click, tqdm, six, jsonschema, jsonpatch and pyyaml packages")
+            logging.getLogger('MA5').debug(err)
             self.display_log()
             return False
         return True
@@ -130,9 +132,7 @@
         logging.getLogger('MA5').error("More details can be found into the log files:")
         logging.getLogger('MA5').error(" - "+os.path.normpath(self.installdir+"/wget.log"))
         logging.getLogger('MA5').error(" - "+os.path.normpath(self.installdir+"/unpack.log"))
-        logging.getLogger('MA5').error(" - "+os.path.normpath(self.installdir+"/configuration.log"))
-        logging.getLogger('MA5').error(" - "+os.path.normpath(self.installdir+"/compilation.log"))
-        logging.getLogger('MA5').error(" - "+os.path.normpath(self.installdir+"/installation.log"))
+
 
     def NeedToRestart(self):
         return False

=== modified file 'madanalysis/install/install_root.py'
--- madanalysis/install/install_root.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_root.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from madanalysis.IOinterface.folder_writer import FolderWriter
 from shell_command import ShellCommand

=== modified file 'madanalysis/install/install_samples.py'
--- madanalysis/install/install_samples.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_samples.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os
@@ -74,7 +75,7 @@
 
     def Check(self):
 
-        filesToCheck = self.files.keys()
+        filesToCheck = list(self.files.keys())
         ok=True
         for item in filesToCheck:
             logging.getLogger('MA5').debug('checking file: '+item+ ' ...')

=== modified file 'madanalysis/install/install_service.py'
--- madanalysis/install/install_service.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_service.py	2021-06-30 09:39:51 +0000
@@ -22,11 +22,15 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from shell_command import ShellCommand
 import logging
 import os
 import sys
 import shutil
+from six.moves import range
+from six.moves import input
+import six
 
 class InstallService():
 
@@ -89,7 +93,7 @@
         if not forced:
             test=False
             while(not test):
-                answer=raw_input("   => Answer: ")
+                answer=input("   => Answer: ")
                 if answer=="":
                     test=True
                     ncores=nmaxcores
@@ -196,7 +200,7 @@
         for file,url in filesToDownload.items():
             ind+=1
             result="OK"
-            logging.getLogger('MA5').info('    - ' + str(ind)+"/"+str(len(filesToDownload.keys()))+" "+url+" ...")
+            logging.getLogger('MA5').info('    - ' + str(ind)+"/"+str(len(list(filesToDownload.keys())))+" "+url+" ...")
             output = installdir+'/'+file
 
             # Try to connect the file
@@ -216,13 +220,16 @@
                 # skip the file
                 continue
 
-            
             # Decoding the size of the remote file
             logging.getLogger('MA5').debug('Decoding the size of the remote file...')
-            sizeURLFile = 0
+            sizeURLFile = 0                    
             try:
-                sizeURLFile = int(info.info().getheaders("Content-Length")[0])
-            except:
+                if six.PY2:
+                    sizeURLFile = int(info.info().getheaders("Content-Length")[0])
+                else:
+                    sizeURLFile = int(info.info().get("Content-Length"))
+            except Exception as err:
+                print(err)
                 logging.getLogger('MA5').debug('-> Problem to decode it')
                 logging.getLogger('MA5').warning("Bad description for "+url)
                 result="ERROR"
@@ -243,7 +250,7 @@
                 logging.getLogger('MA5').debug("A file with the same name '"+output+"' has been found on the machine.")
 
                 ok=True
-                        
+
                 # Decoding the size of the local file
                 if ok:
                     logging.getLogger('MA5').debug('Decoding the size of the local file...')
@@ -331,7 +338,7 @@
     @staticmethod
     def UrlAccess(url):
 
-        import urllib2
+        import six.moves.urllib.request, six.moves.urllib.error, six.moves.urllib.parse
         import ssl
         import time
 
@@ -343,9 +350,7 @@
         
         # ssl method for python v>2.7.9
         try:
-            modeSSL = (sys.version_info[0]>=2 and \
-                       sys.version_info[1]>=7 and \
-                       sys.version_info[2]>=9 )
+            modeSSL = ( (sys.version_info[0]==2 and sys.version_info[1]>=7 and sys.version_info[2]>=9) or (sys.version_info[0]==3) )
         except:
             logging.getLogger('MA5').warning("Problem with Python version decoding!")
             modeSSL = False
@@ -360,9 +365,9 @@
             logging.getLogger('MA5').debug("Attempt "+str(nAttempt+1)+"/"+str(nMaxAttempts)+" to access the url")
             try:
                 if modeSSL:
-                    info = urllib2.urlopen(url, context=ssl._create_unverified_context())
+                    info = six.moves.urllib.request.urlopen(url, context=ssl._create_unverified_context())
                 else:
-                    info = urllib2.urlopen(url)
+                    info = six.moves.urllib.request.urlopen(url)
             except:
                 logging.getLogger('MA5').warning("Impossible to access the url: "+url)
                 ok=False
@@ -389,27 +394,21 @@
     def check_ma5site():
         url='http://madanalysis.irmp.ucl.ac.be'
         logging.getLogger('MA5').debug("Testing the access to MadAnalysis 5 website: "+url+" ...")
-
         info = InstallService.UrlAccess(url)
-
         # Close the access
         if info!=None:
             info.close()
-        return True        
+        return True
 
-        
     @staticmethod
-    def check_inspire():
-        url='http://inspirehep.net/'
-        logging.getLogger('MA5').debug("Testing the access to InSpire: "+url+" ...")
-
+    def check_dataverse():
+        url='http://dataverse.uclouvain.be'
+        logging.getLogger('MA5').debug("Testing access to the MadAnalysis5 dataverse: "+url+" ...")
         info = InstallService.UrlAccess(url)
-
         # Close the access
         if info!=None:
             info.close()
         return True
-
 
     @staticmethod
     def create_tools_folder(path):

=== modified file 'madanalysis/install/install_zlib.py'
--- madanalysis/install/install_zlib.py	2020-07-03 08:05:49 +0000
+++ madanalysis/install/install_zlib.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.install.install_service import InstallService
 from shell_command import ShellCommand
 import os

=== modified file 'madanalysis/interpreter/cmd_base.py'
--- madanalysis/interpreter/cmd_base.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_base.py	2021-06-30 09:39:51 +0000
@@ -22,9 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 import glob
 import os
+from six.moves import range
 
 class CmdBase():
     """Command CMDBase"""

=== modified file 'madanalysis/interpreter/cmd_cut.py'
--- madanalysis/interpreter/cmd_cut.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_cut.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_base           import CmdBase
 from madanalysis.interpreter.cmd_selection_base import CmdSelectionBase
 from madanalysis.multiparticle.particle_object  import ParticleObject
@@ -38,6 +39,7 @@
 from madanalysis.enumeration.argument_type      import ArgumentType
 from madanalysis.observable.observable_base     import ObservableBase
 import logging
+from six.moves import range
 
 
 class CmdCut(CmdBase,CmdSelectionBase):
@@ -678,7 +680,7 @@
 
         # options mode
         if nbracket1==0 and nbracket2==1 and nbracket3==0:
-            output=Cut.userShortcuts.keys()
+            output=list(Cut.userShortcuts.keys())
             output.append("]")
             return self.finalize_complete(text,output)
 

=== modified file 'madanalysis/interpreter/cmd_define.py'
--- madanalysis/interpreter/cmd_define.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_define.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 from madanalysis.enumeration.ma5_running_type       import MA5RunningType
 import logging
@@ -35,13 +36,13 @@
     def do(self,args):
 
         # tagger / smearer
-        if args[0] in ['tagger', 'smearer', 'reco_efficiency']:
+        if args[0] in ['tagger', 'smearer', 'reco_efficiency', 'jes', 'scaling', 'energy_scaling']:
             if self.main.mode != MA5RunningType.RECO:
-                logging.getLogger('MA5').error("Smearing/tagging/reconstruction are only available in the RECO mode")
+                logging.getLogger('MA5').error("Smearing/tagging/reconstruction/scaling are only available in the RECO mode")
                 logging.getLogger('MA5').error("Please restart the program with './bin/ma5 -R '")
                 return
             if self.main.fastsim.package != 'fastjet':
-                logging.getLogger('MA5').error("Smearing/tagging/reconstruction require fastjet as a fastsim package. ")
+                logging.getLogger('MA5').error("Smearing/tagging/reconstruction/scaling requires FastJet as a fastsim package. ")
                 return
             self.main.superfastsim.define(args,self.main.multiparticles)
             return
@@ -122,6 +123,22 @@
         logging.getLogger('MA5').info("   Define the efficiency to reconstruct the object <p1>.")
         logging.getLogger('MA5').info("   The corresponding efficiency function is given by <function>.")
         logging.getLogger('MA5').info("   The bounds correspond to the domain the efficiency applies (pt > ..., eta < ..., etc.).")
+        logging.getLogger('MA5').info("")
+        logging.getLogger('MA5').info("   Syntax: define jes <function> [<bounds>]")
+        logging.getLogger('MA5').info("   Define the Jet Energy Scale (JES) corrections to apply to clustered jets.")
+        logging.getLogger('MA5').info("   The corresponding JES function is given by <function>.")
+        logging.getLogger('MA5').info("   The bounds correspond to the domain that JES applies (pt > ..., eta < ..., etc.).")
+        logging.getLogger('MA5').info("")
+        logging.getLogger('MA5').info("   Syntax: define energy_scaling <p1> <function> [<bounds>]")
+        logging.getLogger('MA5').info("   Define the rescaling corrections to apply to the energy of a reconstructed object <p1>.")
+        logging.getLogger('MA5').info("   The corresponding energy scaling function is given by <function>.")
+        logging.getLogger('MA5').info("   The bounds correspond to the domain that scaling function applies (pt > ..., eta < ..., etc.).")
+        # For the future:
+        # logging.getLogger('MA5').info("")
+        # logging.getLogger('MA5').info("   Syntax: define scaling <variable> for <p1> <function> [<bounds>]")
+        # logging.getLogger('MA5').info("   Define rescaling corrections to apply to a variable <variable> for a reconstructed object <p1>.")
+        # logging.getLogger('MA5').info("   The corresponding scaling function is given by <function>.")
+        # logging.getLogger('MA5').info("   The bounds correspond to the domain that scaling function applies (pt > ..., eta < ..., etc.).")
 
 
     def complete(self,text,line,begidx,endidx):

=== modified file 'madanalysis/interpreter/cmd_define_region.py'
--- madanalysis/interpreter/cmd_define_region.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_define_region.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
 

=== modified file 'madanalysis/interpreter/cmd_display.py'
--- madanalysis/interpreter/cmd_display.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_display.py	2021-06-30 09:39:51 +0000
@@ -22,8 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
+from six.moves import range
 
 class CmdDisplay(CmdBase.CmdBase):
     """Command DISPLAY"""
@@ -34,7 +36,6 @@
     def do_other(self,object):
 
         # Looking for one dot in the name
-#        object = object.lower()
         object = object.replace('fastsim.bjet_id.','fastsim.bjet_idXXX')
         object = object.replace('fastsim.tau_id.','fastsim.tau_idXXX')
         objs = object.split('.')
@@ -148,7 +149,7 @@
 
     def do(self,args):
         # Checking argument number
-        if len(args)>0 and args[0].lower() in ['tagger','smearer', 'reco_efficiency']:
+        if len(args)>0 and args[0].lower() in ['tagger','smearer', 'reco_efficiency', 'jes', 'energy_scaling', 'scaling']:
             return self.main.superfastsim.display(args)
         elif len(args)==1:
             return self.do_other(args[0])
@@ -202,7 +203,7 @@
         
         # Only object name
         if variable==None:
-            output = ["main","selection","tagger","smearer", 'reco_efficiency']
+            output = ["main","selection","tagger","smearer", 'reco_efficiency', 'jes', 'energy_scaling', 'scaling']
             output.extend(self.main.datasets.GetNames())
             output.extend(self.main.multiparticles.GetNames())
             output.extend(self.main.regions.GetNames())

=== modified file 'madanalysis/interpreter/cmd_display_datasets.py'
--- madanalysis/interpreter/cmd_display_datasets.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_display_datasets.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
 

=== modified file 'madanalysis/interpreter/cmd_display_multiparticles.py'
--- madanalysis/interpreter/cmd_display_multiparticles.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_display_multiparticles.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
 

=== modified file 'madanalysis/interpreter/cmd_display_particles.py'
--- madanalysis/interpreter/cmd_display_particles.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_display_particles.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
 

=== modified file 'madanalysis/interpreter/cmd_display_regions.py'
--- madanalysis/interpreter/cmd_display_regions.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_display_regions.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
 

=== modified file 'madanalysis/interpreter/cmd_import.py'
--- madanalysis/interpreter/cmd_import.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_import.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_define           import CmdDefine
 from madanalysis.enumeration.ma5_running_type     import MA5RunningType
 from madanalysis.IOinterface.ufo_reader           import UFOReader
@@ -37,6 +38,8 @@
 import glob
 import os
 import stat
+from six.moves import range
+from six.moves import input
 
 class CmdImport(CmdBase.CmdBase):
     """Command IMPORT"""
@@ -75,7 +78,8 @@
               
             
         elif len(args)==1 and os.path.isdir(filename):
-            if JobWriter.CheckJobStructureMute(filename,(self.main.recasting.status=='on')):
+            recastflag =  self.main.recasting.status=='on'
+            if JobWriter.CheckJobStructureMute(self.main.session_info,path=filename,recastflag=recastflag):
                 self.ImportJob(filename,myinterpreter,history)
                 return
             elif UFOReader.CheckStructure(filename):
@@ -141,7 +145,7 @@
             allowed_answers=['n','no','y','yes']
             answer=""
             while answer not in  allowed_answers:
-               answer=raw_input("Answer: ")
+               answer=input("Answer: ")
                answer=answer.lower()
             if answer=="no" or answer=="n":
                 return False

=== modified file 'madanalysis/interpreter/cmd_install.py'
--- madanalysis/interpreter/cmd_install.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_install.py	2021-06-30 09:39:51 +0000
@@ -22,16 +22,10 @@
 ################################################################################
 
 
+from __future__                             import absolute_import
 from madanalysis.interpreter.cmd_base       import CmdBase
 from madanalysis.install.install_manager    import InstallManager
-from madanalysis.system.user_info           import UserInfo
-from madanalysis.system.config_checker      import ConfigChecker
-import logging
-import os
-import sys
-import shutil
-import urllib
-import pwd
+import logging, os
 
 class CmdInstall(CmdBase):
     """Command INSTALL"""
@@ -73,9 +67,11 @@
                 main.archi_info.toLDPATH1.append(dpath)
 
                 if os.path.isfile(os.path.join(dpath,libname+'.so')):
-                   mylib = os.path.join(dpath,libname+'.so')
+                    mylib = os.path.join(dpath,libname+'.so')
                 elif os.path.isfile(os.path.join(dpath,libname+'.dylib')):
-                   mylib = os.path.join(dpath,libname+'.dylib')
+                    mylib = os.path.join(dpath,libname+'.dylib')
+                else:
+                    return;
 
                 main.archi_info.libraries[to_activate]= mylib+":"+str(os.stat(mylib).st_mtime)
 
@@ -141,13 +137,53 @@
                 self.logger.warning('DelphesMA5tune is not installed... please exit the program and install the pad')
                 return True
         elif args[0]=='PAD':
+            pad_install_check, padsfs_install_check = False, False
+            # PAD requires ma5 to be restarted; therefore we first install PADForSFS
+            if self.main.archi_info.has_fastjet:
+                padsfs_install_check = installer.Execute('PADForSFS')
+            else:
+                self.logger.warning("PADForSFS requires FastJet to be installed.")
+                self.logger.info("Would you like to install FastJet? [Y/N]")
+                while True:
+                    answer = input("Answer : ")
+                    if answer.lower() in ['y','n','yes','no']:
+                        break
+                if answer.lower() in ['y','yes']:
+                    if not installer.Execute('fastjet'):
+                        return False
+                    if not installer.Execute('fastjet-contrib'):
+                        return False
+                    if not installer.Execute('PADForSFS'):
+                        return False
+                    padsfs_install_check = 'restart'
             if inst_delphes(self.main,installer,'delphes',True):
-                return installer.Execute('PAD')
+                pad_install_check = installer.Execute('PAD')
             else:
-                self.logger.warning('Delphes is not installed... please exit the program and install the pad')
-                return True
+                self.logger.warning('Delphes is not installed (and will be installed). '+
+                                    'Then please exit MA5 and re-install the PAD')
+            if 'restart' in [pad_install_check, padsfs_install_check]:
+                return 'restart'
+            return any([pad_install_check, padsfs_install_check])
         elif args[0]=='PADForSFS':
-            return installer.Execute('PADForSFS')
+            padsfs_install_check = False
+            if self.main.archi_info.has_fastjet:
+                padsfs_install_check = installer.Execute('PADForSFS')
+            else:
+                self.logger.warning("PADForSFS requires FastJet to be installed.")
+                self.logger.info("Would you like to install FastJet? [Y/N]")
+                while True:
+                    answer = input("Answer : ")
+                    if answer.lower() in ['y','n','yes','no']:
+                        break
+                if answer.lower() in ['y','yes']:
+                    if not installer.Execute('fastjet'):
+                        return False
+                    if not installer.Execute('fastjet-contrib'):
+                        return False
+                    if not installer.Execute('PADForSFS'):
+                        return False
+                    return 'restart'
+            return padsfs_install_check
         elif args[0]=='pyhf':
             return installer.Execute('pyhf')
         else:

=== modified file 'madanalysis/interpreter/cmd_open.py'
--- madanalysis/interpreter/cmd_open.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_open.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_base            import CmdBase
 from madanalysis.IOinterface.html_report_writer  import HTMLReportWriter
 from madanalysis.IOinterface.latex_report_writer import LATEXReportWriter

=== modified file 'madanalysis/interpreter/cmd_plot.py'
--- madanalysis/interpreter/cmd_plot.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_plot.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_base           import CmdBase
 from madanalysis.interpreter.cmd_selection_base import CmdSelectionBase
 from madanalysis.multiparticle.particle_object  import ParticleObject
@@ -31,6 +32,7 @@
 from madanalysis.enumeration.argument_type      import ArgumentType
 from madanalysis.selection.histogram            import Histogram
 import logging
+from six.moves import range
 
 
 class CmdPlot(CmdBase,CmdSelectionBase):
@@ -442,7 +444,7 @@
 
         # options mode
         if nbracket1==0 and nbracket2==1 and nbracket3==0:
-            output=Histogram.userShortcuts.keys()
+            output=list(Histogram.userShortcuts.keys())
             output.append("]")
             return self.finalize_complete(text,output)
 

=== modified file 'madanalysis/interpreter/cmd_remove.py'
--- madanalysis/interpreter/cmd_remove.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_remove.py	2021-06-30 09:39:51 +0000
@@ -22,9 +22,11 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import madanalysis.interpreter.cmd_base as CmdBase
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
 import logging
+from six.moves import range
 
 class CmdRemove(CmdBase.CmdBase):
     """Command REMOVE"""
@@ -42,7 +44,7 @@
        # Multiparticle removal
         if self.main.multiparticles.Find(name):
             theList = self.main.selection.GetItemsUsingMultiparticle(name) 
-            if len(theList) is 0:
+            if len(theList) == 0:
                 self.main.multiparticles.Remove(name,self.main.mode)
             else:
                 logging.getLogger('MA5').error("The Particle/Multiparticle '" + name + \

=== modified file 'madanalysis/interpreter/cmd_reset.py'
--- madanalysis/interpreter/cmd_reset.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_reset.py	2021-06-30 09:39:51 +0000
@@ -22,12 +22,14 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.IOinterface.particle_reader      import ParticleReader
 from madanalysis.IOinterface.multiparticle_reader import MultiparticleReader
 from madanalysis.enumeration.ma5_running_type     import MA5RunningType
 from madanalysis.interpreter.cmd_define           import CmdDefine
 from madanalysis.interpreter.cmd_base             import CmdBase
 import logging
+from six.moves import input
 
 class CmdReset(CmdBase):
     """Command RESET"""
@@ -52,7 +54,7 @@
             allowed_answers=['n','no','y','yes']
             answer=""
             while answer not in  allowed_answers:
-               answer=raw_input("Answer: ")
+               answer=input("Answer: ")
                answer=answer.lower()
             if answer=="no" or answer=="n":
                 return False

=== modified file 'madanalysis/interpreter/cmd_selection_base.py'
--- madanalysis/interpreter/cmd_selection_base.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_selection_base.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.multiparticle.particle_object import ParticleObject
 from madanalysis.multiparticle.extraparticle   import ExtraParticle
 from madanalysis.enumeration.operator_type     import OperatorType
@@ -32,6 +33,7 @@
 from madanalysis.selection.condition_sequence  import ConditionSequence
 from madanalysis.selection.condition_connector import ConditionConnector
 import logging
+from six.moves import range
 
 class CmdSelectionBase():
 
@@ -139,6 +141,8 @@
             # float value
             elif obsRef.args[iarg]==ArgumentType.FLOAT:
                 result=self.extract_float(arguments[iarg])
+            else:
+                result=None
 
             # checking result
             if result==None:

=== modified file 'madanalysis/interpreter/cmd_set.py'
--- madanalysis/interpreter/cmd_set.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_set.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.system.config_checker            import ConfigChecker
 from madanalysis.system.user_info                 import UserInfo
 from madanalysis.enumeration.ma5_running_type     import MA5RunningType
@@ -30,6 +31,7 @@
 from madanalysis.interpreter.cmd_define           import CmdDefine
 import madanalysis.interpreter.cmd_base as CmdBase
 import logging
+from six.moves import range
 
 class CmdSet(CmdBase.CmdBase):
     """Command SET"""
@@ -144,6 +146,29 @@
                     self.main.superfastsim.jetrecomode = args[2]
                 else:
                     logging.getLogger('MA5').error("Jet smearing can only be based on the jet ('jets') or on its constituents ('constituents').")
+            elif objs[2] == 'magneticfield':
+                try:
+                    self.main.superfastsim.mag_field  = float(args[2])
+                    self.main.superfastsim.propagator = True
+                except:
+                    logging.getLogger('MA5').error("The magnetic field has to be numerical (in Tesla).")
+            elif objs[2] == 'tracker_radius':
+                try:
+                    self.main.superfastsim.radius      = float(args[2])
+                    self.main.superfastsim.propagator  = True
+                except:
+                    logging.getLogger('MA5').error("The tracker cylinder radius has to be numerical (in meters).")
+            elif objs[2] == 'half_length':
+                try:
+                    self.main.superfastsim.half_length = float(args[2])
+                    self.main.superfastsim.propagator  = True
+                except:
+                    logging.getLogger('MA5').error("The tracker cylinder half length needs to numerical (in meters).")
+            elif objs[2] == 'particle_propagator':
+                if args[2] in ['on', 'off']:
+                    self.main.superfastsim.propagator = (args[2]=='on')
+                else:
+                    logging.getLogger('MA5').error("Particle propagation can be either on or off (default: off).")
             else:
                 user_info    = UserInfo()
                 user_info.ReadUserOptions(self.main.archi_info.ma5dir+'/madanalysis/input/installation_options.dat')

=== modified file 'madanalysis/interpreter/cmd_submit.py'
--- madanalysis/interpreter/cmd_submit.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_submit.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_base                           import CmdBase
 from madanalysis.IOinterface.job_writer                         import JobWriter
 from madanalysis.IOinterface.layout_writer                      import LayoutWriter
@@ -40,8 +41,8 @@
 import logging
 import glob
 import os
-import commands
 import shutil
+from six.moves import range
 
 class CmdSubmit(CmdBase):
     """Command SUBMIT"""
@@ -76,7 +77,7 @@
             self.logger.warning("Command 'resubmit' takes no argument. Any argument will be skipped.")
 
         # Checking presence of a valid job
-        if self.main.lastjob_name is "":
+        if self.main.lastjob_name == "":
             self.logger.error("an analysis must be defined and ran before using the resubmit command.") 
             return False
 
@@ -363,12 +364,8 @@
             if not Recaster.init():
                 return False
             self.main.recasting.delphesruns = Recaster.delphes_runcard
-            ### fastsim
-            if not Recaster.fastsim():
-                self.logger.error("job submission aborted.")
-                return False
-            ### Analyses
-            if not Recaster.analysis():
+            ### Executing the PAD
+            if not Recaster.execute():
                 self.logger.error("job submission aborted.")
                 return False
         # Otherwise, standard job

=== modified file 'madanalysis/interpreter/cmd_swap.py'
--- madanalysis/interpreter/cmd_swap.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/cmd_swap.py	2021-06-30 09:39:51 +0000
@@ -22,8 +22,10 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.interpreter.cmd_base import CmdBase
 import logging
+from six.moves import range
 
 class CmdSwap(CmdBase):
     """Command SWAP"""

=== modified file 'madanalysis/interpreter/history.py'
--- madanalysis/interpreter/history.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/history.py	2021-06-30 09:39:51 +0000
@@ -23,6 +23,7 @@
 
 
 # Python import
+from __future__ import absolute_import
 import os
 
 

=== modified file 'madanalysis/interpreter/interpreter.py'
--- madanalysis/interpreter/interpreter.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/interpreter.py	2021-06-30 09:39:51 +0000
@@ -28,6 +28,8 @@
 
 
 # Import Interpreter core
+from __future__ import absolute_import
+from __future__ import print_function
 from madanalysis.interpreter.interpreter_base import InterpreterBase
 
 # Import MadAnalysis main class
@@ -60,6 +62,7 @@
 import logging
 import readline
 import os
+from six.moves import input
 
 
 #===============================================================================
@@ -219,7 +222,7 @@
            allowed_answers=['n','no','y','yes']
            answer=""
            while answer not in  allowed_answers:
-              answer=raw_input("Answer: ")
+              answer=input("Answer: ")
               answer=answer.lower()
               if answer=="no" or answer=="n":
                    YES=False
@@ -440,9 +443,9 @@
     
             self.stdout.write(self.prompt+readline.get_line_buffer())
             self.stdout.flush()
-        except Exception, error:
+        except Exception as error:
             if __debug__:
-                 print error
+                 print(error)
 
     def getTerminalSize(self):
         def ioctl_GWINSZ(fd):
@@ -521,8 +524,8 @@
                 data = compfunc(Ntext, line, Nbegidx, endidx)
                 self.completion_matches = [p[to_rm:] for p in data 
                                               if len(p)>to_rm]
-             except Exception, error:
-                 print error
+             except Exception as error:
+                 print(error)
             else:
                 self.completion_prefix = ''
                 self.completion_matches = compfunc(text, line, begidx, endidx)
@@ -533,7 +536,7 @@
         
         try:
             return self.completion_matches[state]
-        except IndexError, error:
+        except IndexError as error:
             #if __debug__:
             #    print '\n Completion ERROR:'
             #    print error

=== modified file 'madanalysis/interpreter/interpreter_base.py'
--- madanalysis/interpreter/interpreter_base.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/interpreter_base.py	2021-06-30 09:39:51 +0000
@@ -23,6 +23,7 @@
 
 
 """  A file containing different extension of the cmd basic python library"""
+from __future__ import absolute_import
 from madanalysis.IOinterface.text_file_reader import TextFileReader
 from madanalysis.core.script_stack            import ScriptStack
 from madanalysis.interpreter.history          import History
@@ -35,6 +36,7 @@
 import traceback
 import subprocess
 import readline
+from six.moves import range
 
 
 #===============================================================================
@@ -295,7 +297,7 @@
     def do_shell(self, line):
         "run a shell command"
 
-        if line.strip() is '':
+        if line.strip() == '':
             self.help_shell()
         else:
             self.logger.info("   Running the shell command: " + line + ".")

=== modified file 'madanalysis/interpreter/ma5_interpreter.py'
--- madanalysis/interpreter/ma5_interpreter.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/ma5_interpreter.py	2021-06-30 09:39:51 +0000
@@ -24,6 +24,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 import os
 import shutil
@@ -84,9 +85,9 @@
         old_environ = dict(os.environ)
 
         # Checking if the correct release of Python is installed and tab completion
-        if not sys.version_info[0] == 2 or sys.version_info[1] < 6:
+        if sys.version_info[1] < 6:
             raise InvalidPython('Python release '+ sys.version + ' not supported.\n' + \
-            'MadAnalysis 5 works only with python 2.6 or later (but not python 3.X).')
+            'MadAnalysis 5 works only with python 2.7 or  python 3.7 and later.')
 
         # Checking the MA5 path and adding it to sys.path
         if not os.path.isdir(ma5dir):
@@ -257,7 +258,7 @@
         # initialization
         install_delphes         = False
         install_delphesMA5tune  = False
-        user_info           = UserInfo()
+        user_info               = UserInfo()
 
         # A few useful methods
         def validate_bool_key(key):
@@ -285,7 +286,7 @@
                 user_info.SetValue(usrkey,value,'')
                 update_options(usrkey,value)
                 if archi_reset != '':
-                    self.main.archi_info.__dict__[archi_reset.keys()[0]] = archi_reset.values()[0]
+                    self.main.archi_info.__dict__[list(archi_reset.keys())[0]] = list(archi_reset.values())[0]
             elif opts[key] not in [True,None]:
                 self.logger.warning('Non-existing ' + key.replace('with-','') + \
                    ' path. Automatic detection used.')
@@ -326,8 +327,10 @@
                 install_delphes = validate_bool_key(key)
             elif key=='with-delphesMA5tune':
                 install_delphesMA5tune = validate_bool_key(key)
+            elif key in ['with-PADForSFS','with-padforsfs','PADForSFS']:
+                install_padforsfs = value
             else:
-                raise UNK_OPT('Unknown options for further_install')
+                raise UNK_OPT('Unknown options for further_install : '+str(key))
 
         # Muting the logger
         lvl = self.logger.getEffectiveLevel()
@@ -367,6 +370,14 @@
                 self.logger.error('Impossible to install fastjet.')
                 return False
 
+        # If FastJet is installed, install PADForSFS
+        if self.main.archi_info.has_fastjet and install_padforsfs:
+            self.logger.info('Installing PAD for SFS')
+            installer=InstallManager(self.main)
+            if not installer.Execute('padforsfs'):
+                self.logger.error('Impossible to install PAD For SFS.')
+                return False
+
         # Delphes installation
         if self.main.archi_info.has_root and user_info.delphes_veto and install_delphes:
             self.logger.warning('Delphes has been both vetoed and non-vetoed. Ignoring veto.')

=== modified file 'madanalysis/interpreter/timer.py'
--- madanalysis/interpreter/timer.py	2020-07-03 08:05:49 +0000
+++ madanalysis/interpreter/timer.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import threading
 import time
 

=== modified file 'madanalysis/job/job_candidate_cut.py'
--- madanalysis/job/job_candidate_cut.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_candidate_cut.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.histogram          import Histogram
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.observable_type  import ObservableType
@@ -33,6 +34,7 @@
 from madanalysis.enumeration.combination_type import CombinationType
 import logging
 import copy
+from six.moves import range
 
 def GetConditions(current,table):
 

=== modified file 'madanalysis/job/job_event_cut.py'
--- madanalysis/job/job_event_cut.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_event_cut.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.histogram          import Histogram
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.observable_type  import ObservableType
@@ -32,6 +33,7 @@
 from madanalysis.interpreter.cmd_cut          import CmdCut
 from madanalysis.enumeration.combination_type import CombinationType
 import logging
+from six.moves import range
 
 
 def GetConditions(current,table):
@@ -208,7 +210,7 @@
         for combi in range(len(combination)):
             file.write('      }\n')
             file.write('      }\n')
-        file('      if ( Ncounter ')
+        open('      if ( Ncounter ')
         file.write(OperatorType.convert2cpp(condition.operator) + \
                    str(condition.threshold) +   \
                    ') '+tagName+'['+tagIndex+']=true;\n')

=== modified file 'madanalysis/job/job_execute.py'
--- madanalysis/job/job_execute.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_execute.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.histogram          import Histogram
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.observable_type  import ObservableType
@@ -29,6 +30,7 @@
 from madanalysis.interpreter.cmd_cut          import CmdCut
 import logging
 import copy
+from six.moves import range
 
 def WriteExecute(file,main,part_list):
 

=== modified file 'madanalysis/job/job_finalize.py'
--- madanalysis/job/job_finalize.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_finalize.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 import logging
 def WriteJobFinalize(file,main):
 

=== modified file 'madanalysis/job/job_header.py'
--- madanalysis/job/job_header.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_header.py	2021-06-30 09:39:51 +0000
@@ -22,12 +22,10 @@
 ################################################################################
 
 
-from madanalysis.enumeration.argument_type    import ArgumentType
+from __future__ import absolute_import
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
-from madanalysis.observable.observable_base   import ObservableBase
-import logging
-import sys
+from six.moves import range
 
 def WriteHeader(file,main):
     # Preprocessor commands
@@ -40,9 +38,9 @@
     if main.archi_info.has_root:
         file.write('#include "SampleAnalyzer/Interfaces/root/RootMainHeaders.h"\n')
     file.write('\n')
-    if main.superfastsim.tagger.rules!={}:
+    if main.superfastsim.isTaggerOn():
         file.write('#include "new_tagger.h"\n')
-    if main.superfastsim.smearer.rules!={} or main.superfastsim.reco.rules!={}:
+    if main.superfastsim.isNewSmearerOn():
         file.write('#include "new_smearer_reco.h"\n')
 
     # Namespace
@@ -54,7 +52,7 @@
     file.write('  INIT_ANALYSIS(user,"MadAnalysis5job")\n\n')
     file.write(' public : \n')
     file.write('  virtual MAbool Initialize(const MA5::Configuration& cfg,\n')
-    file.write('                          const std::map<std::string,std::string>& parameters);\n')
+    file.write('                            const std::map<std::string,std::string>& parameters);\n')
     file.write('  virtual void Finalize(const SampleFormat& summary, const std::vector<SampleFormat>& files);\n')
     file.write('  virtual MAbool Execute(SampleFormat& sample, const EventFormat& event);\n')
     file.write('\n private : \n')

=== modified file 'madanalysis/job/job_initialize.py'
--- madanalysis/job/job_initialize.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_initialize.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
 import logging
 

=== modified file 'madanalysis/job/job_main.py'
--- madanalysis/job/job_main.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_main.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.histogram          import Histogram
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.observable_type  import ObservableType

=== modified file 'madanalysis/job/job_particle.py'
--- madanalysis/job/job_particle.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_particle.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.enumeration.argument_type    import ArgumentType
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.ma5_running_type import MA5RunningType
@@ -29,6 +30,7 @@
 import copy
 import logging
 import sys
+from six.moves import range
 
 def GetParticles(main):
 

=== modified file 'madanalysis/job/job_plot.py'
--- madanalysis/job/job_plot.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_plot.py	2021-06-30 09:39:51 +0000
@@ -22,6 +22,7 @@
 ################################################################################
 
 
+from __future__ import absolute_import
 from madanalysis.selection.histogram          import Histogram
 from madanalysis.selection.instance_name      import InstanceName
 from madanalysis.enumeration.observable_type  import ObservableType
@@ -30,6 +31,7 @@
 from madanalysis.enumeration.combination_type import CombinationType
 from madanalysis.interpreter.cmd_cut          import CmdCut
 import logging
+from six.moves import range
 
 
 def WritePlot(file,main,iabs,ihisto):

=== modified file 'madanalysis/job/job_smearer_reco_header.py'
--- madanalysis/job/job_smearer_reco_header.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_smearer_reco_header.py	2021-06-30 09:39:51 +0000
@@ -32,6 +32,8 @@
         self.tau_smearing         = False
         self.jet_smearing         = False
         self.constituent_smearing = False
+        self.track_smearing       = False
+        self.propagator           = fastsim.propagator
         for key, val in self.fastsim.smearer.rules.items():
             if val['id_true'] in ['21','j']:
                 self.jet_smearing         = (self.fastsim.jetrecomode == 'jets')
@@ -44,6 +46,8 @@
                 self.electron_smearing    = True
             elif val['id_true'] in ['15','ta']:
                 self.tau_smearing         = True
+            elif val['id_true'] in ['track']:
+                self.track_smearing       = True
         for key, val in self.fastsim.reco.rules.items():
             if val['id_reco'] in ['21','j']:
                 self.jet_smearing         = True
@@ -55,6 +59,26 @@
                 self.electron_smearing    = True
             elif val['id_reco'] in ['15','ta']:
                 self.tau_smearing         = True
+            elif val['id_reco'] in ['track']:
+                self.track_smearing       = True
+        for key, val in self.fastsim.scaling.rules.items():
+            if val['id_true'] == 'JES':
+                self.jet_smearing         = True
+            elif val['id_true'] in ['21','j']:
+                if self.fastsim.jetrecomode == 'jets':
+                    self.jet_smearing         = True
+                else:
+                    self.constituent_smearing = True
+            elif val['id_true'] in ['22','a']:
+                self.photon_smearing      = True
+            elif val['id_true'] in ['13','mu']:
+                self.muon_smearing        = True
+            elif val['id_true'] in ['11','e']:
+                self.electron_smearing    = True
+            elif val['id_true'] in ['15','ta']:
+                self.tau_smearing         = True
+            elif val['id_true'] in ['track']:
+                self.track_smearing       = True
 
 
     ## Writing NewSmearer.h
@@ -69,42 +93,54 @@
         file.write('{\n')
         file.write('  class NewSmearer: public SmearerBase\n')
         file.write('  {\n')
-        file.write('    private:\n')
-        file.write('      MCParticleFormat output_;\n')
         file.write('    public :\n')
         file.write('      /// Constructor without argument\n')
-        file.write('      NewSmearer() {}\n')
+        file.write('      NewSmearer()\n')
+        file.write('      {\n')
+        file.write('          output_.Reset();\n')
+        file.write('      }\n')
         file.write('      /// Destructor\n')
         file.write('      ~NewSmearer() {}\n\n')
         file.write('      /// Smearer methods: \n')
+        file.write('      /// Set parameters\n')
+        file.write('      void SetParameters()\n')
+        file.write('      {\n')
+        file.write('          // Magnetic field along beam axis\n')
+        file.write('          Bz_                 = {:.6E};\n'.format(self.fastsim.mag_field))
+        # Not in use at the moment
+        # file.write('          // Tracker cylinder radius\n')
+        # file.write('          Radius_             = {:.6E};\n'.format(self.fastsim.radius))
+        # file.write('          // Tracker half length\n')
+        # file.write('          HalfLength_         = {:.6E};\n'.format(self.fastsim.half_length))
+        file.write('          // Code-efficiency parameters\n')
+        file.write('          ParticlePropagator_ = '+(self.propagator*'true'       + (not self.propagator)*'false')+';\n')
+        file.write('          MuonSmearer_        = '+(self.muon_smearing*'true'    + (not self.muon_smearing)*'false')+';\n')
+        file.write('          ElectronSmearer_    = '+(self.electron_smearing*'true'+ (not self.electron_smearing)*'false')+';\n')
+        file.write('          PhotonSmearer_      = '+(self.photon_smearing*'true'  + (not self.photon_smearing)*'false')+';\n')
+        file.write('          TauSmearer_         = '+(self.tau_smearing*'true'     + (not self.tau_smearing)*'false')+';\n')
+        file.write('          JetSmearer_         = '+(self.jet_smearing*'true'     + (not self.jet_smearing)*'false')+';\n')
+        file.write('      }\n\n')
         if self.electron_smearing:
             file.write('      /// Electron smearing method\n')
             file.write('      MCParticleFormat ElectronSmearer(const MCParticleFormat * part);\n\n')
-            file.write('      // Boolean to check if electron smearer is on\n')
-            file.write('      MAbool isElectronSmearerOn() {return true;}\n\n')
         if self.muon_smearing:
             file.write('      /// Muon smearing method\n')
             file.write('      MCParticleFormat MuonSmearer(const MCParticleFormat * part);\n\n')
-            file.write('      // Boolean to check if muon smearer is on\n')
-            file.write('      MAbool isMuonSmearerOn() {return true;}\n\n')
         if self.photon_smearing:
             file.write('      /// Photon smearing method\n')
             file.write('      MCParticleFormat PhotonSmearer(const MCParticleFormat * part);\n\n')
-            file.write('      // Boolean to check if photon smearer is on\n')
-            file.write('      MAbool isPhotonSmearerOn() {return true;}\n\n')
         if self.tau_smearing:
             file.write('      /// Hadronic Tau smearing method\n')
             file.write('      MCParticleFormat TauSmearer(const MCParticleFormat * part);\n\n')
-            file.write('      // Boolean to check if tau smearer is on\n')
-            file.write('      MAbool isTauSmearerOn() {return true;}\n\n')
         if self.jet_smearing:
             file.write('      /// Jet smearing method\n')
             file.write('      MCParticleFormat JetSmearer(const MCParticleFormat * part);\n\n')
-            file.write('      // Boolean to check if jet smearer is on\n')
-            file.write('      MAbool isJetSmearerOn() {return true;}\n\n')
         if self.constituent_smearing:
             file.write('      /// Jet Constituent smearing method\n')
             file.write('      MCParticleFormat ConstituentSmearer(const MCParticleFormat * part);\n\n')
+        if self.track_smearing:
+            file.write('      /// Track smearing method\n')
+            file.write('      MCParticleFormat TrackSmearer(const MCParticleFormat * part);\n\n')
         file.write('  };\n')
         file.write('}\n')
         file.write('#endif')
@@ -146,3 +182,23 @@
         file.write('#endif')
 
 
+    ## scales and bounds
+    def WriteNewScales(self,file):
+        file.write('#ifndef SC_H_INCLUDED\n')
+        file.write('#define SC_H_INCLUDED\n')
+        file.write('#include <cmath>\n')
+        file.write('#include <math.h>\n')
+        file.write('#include <iostream>\n')
+        for key, value in self.fastsim.scaling.rules.items():
+            for eff_key in value['efficiencies'].keys():
+                 eff_fnc = value['efficiencies'][eff_key]['function']
+                 eff_bnd = value['efficiencies'][eff_key]['bounds'  ]
+                 file.write(eff_fnc.tocpp('MAdouble64', 'scale_'+\
+                                          str(value['id_true']) + '_' + str(value['obs'])+'_'+\
+                                          str(eff_key))+'\n')
+                 file.write(eff_bnd.tocpp('MAbool', \
+                                          'scale_bnd_'+str(value['id_true']) +\
+                                          '_' + str(value['obs'])+'_'+\
+                                          str(eff_key)) + '\n')
+        file.write('#endif')
+

=== modified file 'madanalysis/job/job_smearer_reco_main.py'
--- madanalysis/job/job_smearer_reco_main.py	2020-07-03 08:05:49 +0000
+++ madanalysis/job/job_smearer_reco_main.py	2021-06-30 09:39:51 +0000