Merge lp:~maddevelopers/mg5amcnlo/refactor_amcatnlo_run_interface into lp:~maddevelopers/mg5amcnlo/2.3.3

[Rikkert Frederix]

Major rewriting of the "def run()" function in amcatnlo_run_interface and most of the functions that are called from within the "def run()" function. This gives a much more precise control over all the jobs that need to be run and which need to be collected to get the final result.

One, very simple, improvement already applied: for fixed-order runs, only increase accuracy for each of the jobs by at most a given amount. If the results do not turn out to be accurate enough, ONLY resubmit the jobs that are not yet precise enough with higher required accuracy.

Removed the "combine_results.sh" and "sumres.py", because this is now dealt with directly from within the amcatnlo_run_interface.py file.

This is a first step towards "split generation" for fixed-order and MINT steps 0 and 1 in (N)LO+PS runs.

[lp:~maddevelopers/mg5amcnlo/refactor_amcatnlo_run_interface]

289. By Rikkert Frederix on 2015-09-29

removed a double 'self.write_input_file()'.

290. By Rikkert Frederix on 2015-09-29

removed a double 'self.prepare_directories()' for fixed order runs.

291. By Rikkert Frederix on 2015-10-02

Small fix in the driver_mintFO: the 'RUN_MODE' was not correctly read
from the input_app.txt file

[marco zaro (marco-zaro)]

Hi Rik,
excellent work, please go ahead with the merge!
Cheers,

Marco

review: Approve

=== modified file 'Template/NLO/Source/run_config.inc'
--- Template/NLO/Source/run_config.inc	2012-08-28 21:06:34 +0000
+++ Template/NLO/Source/run_config.inc	2015-10-02 07:00:47 +0000
@@ -34,7 +34,7 @@
       parameter     (PBS_QUE = 'madgraph')
 
       integer    ChanPerJob
-      parameter (ChanPerJob=1)  !Number of channels / job for survey
+      parameter (ChanPerJob=100000000)  !Number of channels / job for survey
 
 c      integer    max_np
 c      parameter (max_np=1)  !Number of channels / job for refine

=== modified file 'Template/NLO/SubProcesses/ajob_template'
--- Template/NLO/SubProcesses/ajob_template	2015-03-18 14:50:37 +0000
+++ Template/NLO/SubProcesses/ajob_template	2015-10-02 07:00:47 +0000
@@ -26,57 +26,38 @@
     exit
 fi
 
+channel=$1
+run_mode=$2
+runnumber=$3
+integration_step=$4
+
 TAGTAGTAGTAGTAGTAGTAG for i in 1 ; do
     
-    runnumber=0
-    if [[ $1 == '0' ]]; then
-        j=$2\_G$i
-        if [[ ! -e $j ]]; then
-            mkdir $j
-        fi
-        cd $j
-        if [[ "$4" != "" ]]; then
-            if [[ -e ../$4\_G$i ]]; then
-                if [[ $1 == '0' ]]; then
-                    cp -f ../$4\_G$i/mint_grids . >/dev/null 2>&1
-                    cp -f ../$4\_G$i/grid.MC_integer . >/dev/null 2>&1
-                elif [[ $1 == '1' ]]; then
-                    cp -f ../$4\_G$i/mint_grids . >/dev/null 2>&1
-                    cp -f ../$4\_G$i/grid.MC_integer . >/dev/null 2>&1
-                fi
-            else
-                echo "Cannot find directory ../$4\_G$i/" > log.txt
-                exit
-            fi
-    	fi
-    elif [[ $1 == '2' ]]; then
-        j=G$2$i
-        if [[ ! -e $j ]]; then
-            mkdir $j
-        fi
-        
-        cd $j
-        if [[ "$4" != "" ]]; then
-            if [[ "$4" == "H" ||"$4" == "S" || "$4" == "V" || "$4" == "B" || "$4" == "F" ]]; then
-                if [[ -e ../G$4$i ]]; then
-                    cp -f ../G$4$i/mint_grids ./preset_mint_grids >/dev/null 2>&1
-                    cp -f ../G$4$i/grid.MC_integer . >/dev/null 2>&1
-                else
-                    echo "Cannot find direcotry ../G$4$i/" > log.txt
-                    exit
-                fi
-            else
-                runnumber=$4
-                if [[ ! -e ../${j}_$4 ]]; then
-                    mkdir ../${j}_$4
-                fi
-                cd ../${j}_$4
-                ln -sf ../${j}/mint_grids 
-                ln -sf ../${j}/mint_grids_NLO 
-                ln -sf ../${j}/grid.MC_integer
-                ln -sf ../${j}/res_1
-            fi
-        fi
+    if [[ $run_mode == 'all' || $run_mode == 'born' ]] ; then
+	j=$run_mode\_G$i
+    else
+	if [[ $runnumber == '0' ]] ; then
+	    j=G$run_mode$i
+	else
+	    j=G$run_mode$i\_$runnumber
+	fi
+    fi
+    cd $j
+    
+    if  [[ -e res.dat ]] ; then
+	rm -f res.dat
+    fi
+    if  [[ -e log.txt ]] ; then
+	rm -f log.txt
+    fi
+    if  [[ -e MADatNLO.top ]] ; then
+	rm -f MADatNLO.top
+    fi
+    if  [[ -e MADatNLO.HwU ]] ; then
+	rm -f MADatNLO.HwU
+    fi
+    if  [[ -e MADatNLO.root ]] ; then
+	rm -f MADatNLO.root
     fi
     if  [[ -e randinit ]] ; then
 	rm -f randinit
@@ -97,67 +78,25 @@
     link1up FKS_params.dat
     link1up configs_and_props_info.dat
     link1up leshouche_info.dat
-#   Not necessary anymore
-#    link1up MadLoop5_resources
     link1up OLE_order.olc
     link1up param_card.dat
     link1up initial_states_map.dat
     
-#   check where is the basic file for the creation of input_app.txt
-#       
-    if [[ $1 == '0' ]]; then
-	if [[ $3 == '-1' && -e ./madinM1 ]] ; then
-	    input_template=./madinM1
-	else
- 	    if  [[  -e ../madin.$2 ]] ; then
- 		input_template=../madin.$2
- 	    else
- 		input_template=../../madin.$2
- 	    fi 
-	fi
-    elif [[ $1 == '2' ]]; then
-    	if [[ $3 == '0' || $3 == '2' ]]; then
-    	    if [[  -e ../madinMMC_$2.2 ]] ; then
- 		input_template=../madinMMC_$2.2
- 	    else
- 		input_template=../../madinMMC_$2.2
- 	    fi
- 	else
-	    input_template=./madinM1
-    	fi
-    fi
     
-    if [[ $1 == '0' ]]; then
-        head -n 5 $input_template >& input_app.txt
-        echo $i >> input_app.txt
-        tail -n 4 $input_template >> input_app.txt
-        T="$(date +%s)"
+    T="$(date +%s)"
+    if [[ $run_mode == 'all' || $run_mode == 'born' ]]; then
         ../madevent_mintFO > log.txt <input_app.txt 2>&1
-        status=$?
-        T="$(($(date +%s)-T))"
-        echo "Time in seconds: ${T}" >>log.txt
-    elif [[ $1 == '2' ]]; then
+    else
         if [[ $runnumber != 0 ]]; then
-            tar --extract --file=../nevents.tar nevts_${j}_$runnumber
-            mv  nevts_${j}_$runnumber nevts
             echo "$runnumber" >& moffset.dat
         fi
-        if [[ $3 == '0' || $3 == '2' ]]; then
-            head -n 6 $input_template > input_app.txt
-            echo $i >> input_app.txt
-            tail -n 3 $input_template >> input_app.txt
-        elif [[ $3 == '1' ]]; then
-            head -n 6 $input_template > input_app.txt
-            echo $i >> input_app.txt
-            tail -n 3 $input_template >> input_app.txt
-        fi
-        T="$(date +%s)"
         ../madevent_mintMC > log.txt <input_app.txt 2>&1
-        status=$?
-        T="$(($(date +%s)-T))"
-        echo "Time in seconds: ${T}" >>log.txt
-        cp -f log.txt log_MINT$3.txt  >/dev/null 2>&1
     fi
+    status=$?
+    T="$(($(date +%s)-T))"
+    echo "Time in seconds: ${T}" >>log.txt
+    cp -f log.txt log_MINT$integration_step.txt  >/dev/null 2>&1
+    cp -f res.dat res_$integration_step.dat  >/dev/null 2>&1
     exit $status
 done
     

=== removed file 'Template/NLO/SubProcesses/combine_results.sh'
--- Template/NLO/SubProcesses/combine_results.sh	2013-06-28 13:57:17 +0000
+++ Template/NLO/SubProcesses/combine_results.sh	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-#!/bin/bash
-
-# find the correct directory
-if [[ ! -d ./SubProcesses ]]; then
-    cd ../
-fi
-if [[ -d ./SubProcesses ]]; then
-    cd SubProcesses
-fi
-
-if [[ -e res.txt ]]; then
-    rm -f res.txt
-fi
-if [[ -e dirs.txt ]]; then
-    rm -f dirs.txt
-fi
-if [[ -e nevents_unweighted ]]; then
-    rm -f nevents_unweighted
-fi
-
-arg1=$1
-arg2=$2
-arg3=$3
-# shift the list of arguments by 3
-shift
-shift
-shift
-if [[ "$@" == "" ]]; then
-    echo "Please give the G directories that should be combined,"
-    echo "e.g. 'GF* GV*', as final arguments of this script" 
-    exit
-fi
-
-touch res.txt
-touch dirs.txt
-NTOT=0
-for dir in "$@" ; do
-    N=`ls -d P*/$dir | wc -l`
-    NTOT=`expr $NTOT + $N`
-    ls -d P*/$dir >> dirs.txt
-    grep -H 'Final result' P*/$dir/res_$arg1 >> res.txt
-done
-echo N of directories: $NTOT
-if [[ $arg1 == '0' ]] ; then
-    echo 'Determining the number of unweighted events per channel'
-elif [[ $arg1 == '1' ]] ; then
-    echo 'Updating the number of unweighted events per channel'
-fi
-./sumres.py $NTOT $arg2 $arg3
-
-echo 'Integrated abs(cross-section)' 
-tail -n2 res.txt | head -n1
-echo 'Integrated cross-section' 
-tail -n1 res.txt
-mv res.txt res_$arg1.txt

=== removed file 'Template/NLO/SubProcesses/combine_results_FO.sh'
--- Template/NLO/SubProcesses/combine_results_FO.sh	2013-06-28 13:57:17 +0000
+++ Template/NLO/SubProcesses/combine_results_FO.sh	1970-01-01 00:00:00 +0000
@@ -1,52 +0,0 @@
-#!/bin/bash
-
-# find the correct directory
-if [[ ! -d ./SubProcesses ]]; then
-    cd ../
-fi
-if [[ -d ./SubProcesses ]]; then
-    cd SubProcesses
-fi
-
-if [[ $1 == "0" ]] ; then
-    mint_mode=0
-    shift
-elif [[ $1 == "1" ]] ; then
-    mint_mode=1
-    shift
-elif [[ $1 == "2" ]] ; then
-    echo "Cannot combine results for mint_mode 2"
-    exit
-else
-    mint_mode=0
-fi
-
-if [[ -e res.txt ]]; then
-    rm -f res.txt
-fi
-if [[ -e dirs.txt ]]; then
-    rm -f dirs.txt
-fi
-
-req_acc=$1
-shift
-
-touch res.txt
-touch dirs.txt
-NTOT=0
-for dir in "$@" ; do
-    N=`ls -d P*/$dir | wc -l`
-    NTOT=`expr $NTOT + $N`
-    ls -d P*/$dir >> dirs.txt
-    grep -H 'Final result' P*/$dir/res_$mint_mode >> res.txt
-done
-
-sed -i.bak s/"\+\/\-"/" \+\/\-"/ res.txt
-
-echo N of directories: $NTOT
-
-./sumres.py $NTOT -1 $req_acc
-
-rm -r res.txt.bak
-
-tail -n1 res.txt

=== modified file 'Template/NLO/SubProcesses/driver_mintFO.f'
--- Template/NLO/SubProcesses/driver_mintFO.f	2015-03-09 18:27:17 +0000
+++ Template/NLO/SubProcesses/driver_mintFO.f	2015-10-02 07:00:47 +0000
@@ -18,7 +18,6 @@
 C     LOCAL
 C
       integer i,j,l,l1,l2,ndim
-      integer npoints
       character*130 buf
 c
 c     Global
@@ -219,23 +218,7 @@
             do j=1,nintervals_virt
                read (12,*) (ave_virt(j,i),i=1,ndim)
             enddo
-            if (ncall.gt.0 .and. accuracy.ne.0d0) then
-               read (12,*) ans(1),unc(1),ncall,itmax
-c Update the number of PS points based on unc(1), ncall and accuracy
-               itmax_fl=itmax*(unc(1)/accuracy)**2
-               if (itmax_fl.le.4d0) then
-                  itmax=max(nint(itmax_fl),2)
-               elseif (itmax_fl.gt.4d0 .and. itmax_fl.le.16d0) then
-                  ncall=nint(ncall*itmax_fl/4d0)
-                  itmax=4
-               else
-                  itmax=nint(sqrt(itmax_fl))
-                  ncall=nint(ncall*itmax_fl/nint(sqrt(itmax_fl)))
-               endif
-               accuracy=accuracy/ans(1) ! relative accuracy on the ABS X-section
-            else
-               read (12,*) ans(1),unc(1),dummy,dummy
-            endif
+            read (12,*) ans(1),unc(1),dummy,dummy
             read (12,*) virtual_fraction,average_virtual
             close (12)
             write (*,*) "Update iterations and points to",itmax,ncall
@@ -253,10 +236,6 @@
          call mint(sigint,ndim,ncall,itmax,imode,xgrid,ymax,ymax_virt
      $        ,ans,unc,chi2)
          call topout
-         open(unit=58,file='res_0',status='unknown')
-         write(58,*)'Final result [ABS]:',ans(1),' +/-',unc(1)
-         write(58,*)'Final result:',ans(2),' +/-',unc(2)
-         close(58)
          write(*,*)'Final result [ABS]:',ans(1),' +/-',unc(1)
          write(*,*)'Final result:',ans(2),' +/-',unc(2)
          write(*,*)'chi**2 per D.o.F.:',chi2(1)
@@ -337,6 +316,11 @@
       write(*,*) 'Time spent in Other_tasks : ',tOther
       write(*,*) 'Time spent in Total : ',tTot
 
+      open (unit=12, file='res.dat',status='unknown')
+      write (12,*)ans(1),unc(1),ans(2),unc(2),itmax,ncall,tTot
+      close(12)
+
+
       if(i_momcmp_count.ne.0)then
         write(*,*)'     '
         write(*,*)'WARNING: genps_fks code 555555'
@@ -680,8 +664,6 @@
       character * 70 idstring
       logical savegrid
 
-      character * 80 runstr
-      common/runstr/runstr
       logical usexinteg,mint
       common/cusexinteg/usexinteg,mint
       logical unwgt
@@ -692,84 +674,93 @@
       double precision volh
       common/mc_int2/volh,mc_hel,ihel,fillh
 
-
+      logical done
+      character*100 buffer
 c-----
 c  Begin Code
 c-----
       mint=.true.
       unwgt=.false.
-      write(*,'(a)') 'Enter number of events and iterations: '
-      read(*,*) ncall,itmax
-      write(*,*) 'Number of events and iterations ',ncall,itmax
-      write(*,'(a)') 'Enter desired accuracy: '
-      read(*,*) accuracy
-      write(*,*) 'Desired absolute accuracy: ',accuracy
-
-      write(*,'(a)') 'Enter 0 for fixed, 2 for adjustable grid: '
-      read(*,*) use_cut
-      if (use_cut .lt. 0 .or. use_cut .gt. 2) then
-         write(*,*) 'Bad choice, using 2',use_cut
-         use_cut = 2
-      endif
-
-      write(*,10) 'Suppress amplitude (0 no, 1 yes)? '
-      read(*,*) i
-      if (i .eq. 1) then
-         multi_channel = .true.
-         write(*,*) 'Using suppressed amplitude.'
-      else
-         multi_channel = .false.
-         write(*,*) 'Using full amplitude.'
-      endif
-
-      write(*,10) 'Exact helicity sum (0 yes, n = number/event)? '
-      read(*,*) i
-      if (i .eq. 0) then
-         mc_hel = 0
-         write(*,*) 'Explicitly summing over helicities for virt'
-      else
-         mc_hel= i
-         write(*,*) 'Summing over',i,' helicities/event for virt'
-      endif
-      isum_hel=0
-
-      write(*,10) 'Enter Configuration Number: '
-      read(*,*) dconfig
-      iconfig = int(dconfig)
-      do i=1,mapconfig(0)
-         if (iconfig.eq.mapconfig(i)) then
-            iconfig=i
-            exit
+      open (unit=83,file='input_app.txt',status='old')
+      done=.false.
+      do while (.not. done)
+         read(83,'(a)',err=222,end=222) buffer
+         if (buffer(1:7).eq.'NPOINTS') then
+            buffer=buffer(10:100)
+            read(buffer,*) ncall
+            write (*,*) 'Number of phase-space points per iteration:',ncall
+         elseif(buffer(1:11).eq.'NITERATIONS') then
+            read(buffer(14:),*) itmax
+            write (*,*) 'Maximum number of iterations is:',itmax
+         elseif(buffer(1:8).eq.'ACCURACY') then
+            read(buffer(11:),*) accuracy
+            write (*,*) 'Desired accuracy is:',accuracy
+         elseif(buffer(1:10).eq.'ADAPT_GRID') then
+            read(buffer(13:),*) use_cut
+            write (*,*) 'Using adaptive grids:',use_cut
+         elseif(buffer(1:12).eq.'MULTICHANNEL') then
+            read(buffer(15:),*) i
+            if (i.eq.1) then
+               multi_channel=.true.
+               write (*,*) 'Using Multi-channel integration'
+            else
+               multi_channel=.false.
+               write (*,*) 'Not using Multi-channel integration'
+            endif
+         elseif(buffer(1:12).eq.'SUM_HELICITY') then
+            read(buffer(15:),*) i
+            if (i.eq.0) then
+               mc_hel=0
+               write (*,*) 'Explicitly summing over helicities'
+            else
+               mc_hel=1
+               write(*,*) 'Do MC over helicities for the virtuals'
+            endif
+            isum_hel=0
+         elseif(buffer(1:7).eq.'CHANNEL') then
+            read(buffer(10:),*) dconfig
+            iconfig = int(dconfig)
+            do i=1,mapconfig(0)
+               if (iconfig.eq.mapconfig(i)) then
+                  iconfig=i
+                  exit
+               endif
+            enddo
+            write(*,12) 'Running Configuration Number: ',iconfig
+         elseif(buffer(1:5).eq.'SPLIT') then
+            read(buffer(8:),*) i
+            write (*,*) 'Splitting channel:',i
+         elseif(buffer(1:8).eq.'RUN_MODE') then
+            read(buffer(11:),*) abrvinput
+            if(abrvinput(5:5).eq.'0')then
+               nbody=.true.
+            else
+               nbody=.false.
+            endif
+            abrv=abrvinput(1:4)
+            write (*,*) "doing the ",abrv," of this channel"
+            if(nbody)then
+               write (*,*) "integration Born/virtual with Sfunction=1"
+            else
+               write (*,*) "Normal integration (Sfunction != 1)"
+            endif
+         elseif(buffer(1:7).eq.'RESTART') then
+            read(buffer(10:),*) irestart
+            if (irestart.eq.0) then
+               write (*,*) 'RESTART: Fresh run'
+            elseif(irestart.eq.-1) then
+               write (*,*) 'RESTART: Use old grids, but refil plots'
+            elseif(irestart.eq.1) then
+               write (*,*) 'RESTART: continue with existing run'
+            else
+               write (*,*) 'RESTART:',irestart
+            endif
          endif
+         cycle
+ 222     done=.true.
       enddo
-      write(*,12) 'Running Configuration Number: ',iconfig
-c
-c Enter parameters that control Vegas grids
-c
-      write(*,*)'enter id string for this run'
-      read(*,*) idstring
-      runstr=idstring
-      write(*,*)'enter 1 if you want restart files'
-      read (*,*) itmp
-      if(itmp.eq.1) then
-         savegrid = .true.
-      else
-         savegrid = .false.
-      endif
-      write(*,*)'enter 0 to exclude, 1 for new run, 2 to restart'
-      read(5,*)irestart
+      close(83)
 
-      abrvinput='     '
-      write (*,*) "'all ', 'born', 'real', 'virt', 'novi' or 'grid'?"
-      write (*,*) "Enter 'born0' or 'virt0' to perform"
-      write (*,*) " a pure n-body integration (no S functions)"
-      read(5,*) abrvinput
-      if(abrvinput(5:5).eq.'0')then
-        nbody=.true.
-      else
-        nbody=.false.
-      endif
-      abrv=abrvinput(1:4)
       if (fks_configs.eq.1) then
          if (pdg_type_d(1,fks_i_d(1)).eq.-21) then
             write (*,*) 'Process generated with [LOonly=QCD]. '/
@@ -782,26 +773,6 @@
             endif
          endif
       endif
-c Options are way too many: make sure we understand all of them
-      if ( abrv.ne.'all '.and.abrv.ne.'born'.and.abrv.ne.'real'.and.
-     &     abrv.ne.'virt'.and.
-     &     abrv.ne.'viSC'.and.abrv.ne.'viLC'.and.abrv.ne.'novA'.and.
-     &     abrv.ne.'novB'.and.abrv.ne.'viSA'.and.abrv.ne.'viSB') then
-        write(*,*)'Error in input: abrv is:',abrv
-        stop
-      endif
-      if(nbody.and.abrv.ne.'born'.and.abrv(1:2).ne.'vi'
-     &     .and. abrv.ne.'grid')then
-        write(*,*)'Error in driver: inconsistent input',abrvinput
-        stop
-      endif
-
-      write (*,*) "doing the ",abrv," of this channel"
-      if(nbody)then
-        write (*,*) "integration Born/virtual with Sfunction=1"
-      else
-        write (*,*) "Normal integration (Sfunction != 1)"
-      endif
 c
 c
 c     Here I want to set up with B.W. we map and which we don't

=== modified file 'Template/NLO/SubProcesses/driver_mintMC.f'
--- Template/NLO/SubProcesses/driver_mintMC.f	2015-08-13 12:43:02 +0000
+++ Template/NLO/SubProcesses/driver_mintMC.f	2015-10-02 07:00:47 +0000
@@ -189,7 +189,7 @@
             enddo
          else
 c to restore grids:
-            open (unit=12, file='preset_mint_grids',status='old')
+            open (unit=12, file='mint_grids',status='old')
             do j=0,nintervals
                read (12,*) (xgrid(j,i),i=1,ndim)
             enddo
@@ -285,7 +285,7 @@
          close(58)
 
 c to save grids:
-         open (unit=12, file='mint_grids_NLO',status='unknown')
+         open (unit=12, file='mint_grids',status='unknown')
          write (12,*) (xgrid(0,i),i=1,ndim)
          do j=1,nintervals
             write (12,*) (xgrid(j,i),i=1,ndim)
@@ -301,7 +301,6 @@
          write (12,*) virtual_fraction,average_virtual
          close (12)
 
-
 c*************************************************************
 c     event generation
 c*************************************************************
@@ -323,7 +322,7 @@
          ncall=nevts ! Update ncall with the number found in 'nevts'
 
 c to restore grids:
-         open (unit=12, file='mint_grids_NLO',status='unknown')
+         open (unit=12, file='mint_grids',status='unknown')
          read (12,*) (xgrid(0,i),i=1,ndim)
          do j=1,nintervals
             read (12,*) (xgrid(j,i),i=1,ndim)
@@ -468,6 +467,15 @@
       write(*,*) 'Time spent in Other_tasks : ',tOther
       write(*,*) 'Time spent in Total : ',tTot
 
+      open (unit=12, file='res.dat',status='unknown')
+      if (imode.eq.0) then
+         write (12,*)ans(1),unc(1),ans(2),unc(2),itmax,ncall,tTot
+      else
+         write (12,*)ans(1)+ans(5),sqrt(unc(1)**2+unc(5)**2),ans(2)
+     $        ,unc(2),itmax,ncall,tTot
+      endif
+      close(12)
+
       return
  999  write (*,*) 'nevts file not found'
       stop

=== removed file 'Template/NLO/SubProcesses/sumres.py'
--- Template/NLO/SubProcesses/sumres.py	2014-07-23 10:33:38 +0000
+++ Template/NLO/SubProcesses/sumres.py	1970-01-01 00:00:00 +0000
@@ -1,241 +0,0 @@
-#!/usr/bin/env python
-
-#script to combine reults and tell the number of events that need
-#  to be generated in each channel. 
-#  Replaces the sumres.f and sumres2.f files
-#  MZ, 2011-10-22
-
-from __future__ import division
-import math
-import sys
-import random
-import os
-
-nexpected=int(sys.argv[1])
-nevents=int(sys.argv[2])
-req_acc=float(sys.argv[3])
-# if nevents is >=0 the script will also determine the 
-# number of events required for each process
-
-
-def Mirrorprocs(p1, p2):
-    """determine if the folder names p1, p2 (with the _N already taken out)
-    correspond to the same process with
-    mirrror initial state. Returns true/false"""
-    return False
-
-file=open("res.txt")
-content = file.read()
-file.close()
-lines = content.split("\n")
-processes=[]
-tot=0
-err=0
-totABS=0
-errABS=0
-
-# open the file containing the list of directories
-file=open("dirs.txt")
-dirs = file.read().split("\n")
-file.close()
-dirs.remove('')
-
-# The syntax of lines should be first the ABS cross section for the
-# channel and the line after that the cross section for the same
-# channel.
-for line in range(0,len(lines),2):
-    list = lines[line].split()
-    if list:
-        proc={}
-        proc['folder'] = list[0].split('/')[0]
-        proc['subproc'] = proc['folder'][0:proc['folder'].rfind('_')]
-        proc['channel'] = list[0].split('/')[1]
-        dirs.remove(os.path.join(proc['folder'], proc['channel']))
-        proc['resultABS'] = float(list[4])
-        proc['errorABS'] = float(list[6])
-        proc['err_percABS'] = proc['errorABS']/proc['resultABS']*100.
-        processes.append(proc)
-        totABS+= proc['resultABS']
-        errABS+= math.pow(proc['errorABS'],2)
-        list = lines[line+1].split()
-        if list:
-            proc['result'] = float(list[3])
-            proc['error'] = float(list[5])
-            proc['err_perc'] = proc['error']/proc['result']*100.
-            tot+= proc['result']
-            err+= math.pow(proc['error'],2)
-if dirs:
-    print "%d jobs did not terminate correctly: " % len(dirs)
-    print '\n'.join(dirs)
-    print "The results are probably not correct. Please check the relevant log files corresponding to the above jobs for more information."
-
-processes.sort(key = lambda proc: -proc['errorABS'])
-
-correct = len(processes) == nexpected
-print "Found %d correctly terminated jobs " %len(processes) 
-if not len(processes)==nexpected:
-    print len(processes), nexpected
-
-subprocs_string=[]
-for proc in processes:
-    subprocs_string.append(proc['subproc'])
-subprocs_string=set(subprocs_string)
-
-content+='\n\nCross-section per integration channel:\n'
-for proc in processes:
-    content+='%(folder)20s  %(channel)15s   %(result)10.8e    %(error)6.4e       %(err_perc)6.4f%%  \n' %  proc
-
-content+='\n\nABS cross-section per integration channel:\n'
-for proc in processes:
-    content+='%(folder)20s  %(channel)15s   %(resultABS)10.8e    %(errorABS)6.4e       %(err_percABS)6.4f%%  \n' %  proc
-
-content+='\n\nCross-section per subprocess:\n'
-#for subpr in sorted(set(subprocs)):
-subprocesses=[]
-for sub in subprocs_string:
-    subpr={}
-    subpr['subproc']=sub
-    subpr['xsect']=0.
-    subpr['err']=0.
-    for proc in processes:
-        if proc['subproc'] == sub:
-            subpr['xsect'] += proc['result']
-            subpr['err'] += math.pow(proc['error'],2)
-    subpr['err']=math.sqrt(subpr['err'])
-    subprocesses.append(subpr)
-
-
-#find and combine mirror configurations (if in v4)
-for i1, s1 in enumerate(subprocesses):
-    for i2, s2 in enumerate(subprocesses):
-        if Mirrorprocs(s1['subproc'], s2['subproc']) and i1 >= i2:
-            s1['xsect'] += s2['xsect']
-            s1['err'] = math.sqrt(math.pow(s1['err'],2)+ math.pow(s2['err'],2))
-            s2['toremove'] = True
-
-new = []
-for s in subprocesses:
-    try:
-        a= s['toremove']
-    except KeyError:
-        new.append(s)
-subprocesses= new
-
-
-subprocesses.sort(key = lambda proc: -proc['xsect'])
-for subpr in subprocesses:
-    content+=  '%(subproc)20s    %(xsect)10.8e   %(err)6.4e\n' % subpr
- 
-
-content+='\nTotal ABS and \nTotal: \n                      %10.8e +- %6.4e  (%6.4e%%)\n                      %10.8e +- %6.4e  (%6.4e%%)\n' %\
-        (totABS, math.sqrt(errABS), math.sqrt(errABS)/totABS *100.,tot, math.sqrt(err), math.sqrt(err)/tot *100.)
-
-if not correct:
-    sys.exit('ERROR: not all jobs terminated correctly\n')
-
-file=open("res.txt", 'w')
-
-file.write(content)
-file.close()
-
-#determine the events for each process:
-if nevents>=0:
-    if req_acc<0: 
-        req_acc2_inv=nevents
-    else:
-        req_acc2_inv=1/(req_acc*req_acc)
-    #get the random number seed from the randinit file
-    file=open("randinit")
-    exec file
-    file.close
-    print "random seed found in 'randinit' is", r
-    random.seed(r)
-    totevts=nevents
-    for proc in processes:
-        proc['lhefile'] = os.path.join(proc['folder'], proc['channel'], 'events.lhe')
-        proc['nevents'] = 0
-    while totevts :
-        target = random.random() * totABS
-        crosssum = 0.
-        i = 0
-        while i<len(processes) and crosssum < target:
-            proc = processes[i]
-            crosssum += proc['resultABS']
-            i += 1            
-        totevts -= 1
-        i -= 1
-        processes[i]['nevents'] += 1
-        
-#check that we now have all the events in the channels
-    totevents = sum(proc['nevents'] for proc in processes)
-    if totevents != nevents:
-        sys.exit('failed to obtain the correct number of events. Required: %d,   Obtained: %d' \
-                 % (nevents, totevents))
-
-    content_evts = ''
-    for proc in processes:
-        content_evts+= ' '+proc['lhefile']+'              %(nevents)10d            %(resultABS)10.8e        1.0 \n' %  proc
-        nevts_file = open(os.path.join(proc['folder'], proc['channel'], 'nevts'),'w')
-        nevts_file.write('%10d\n' % proc['nevents'])
-        nevts_file.close()
-        if proc['channel'][1] == 'B':
-            fileinputs = open("madinMMC_B.2")
-        elif proc['channel'][1] == 'F':
-            fileinputs = open("madinMMC_F.2")
-        elif proc['channel'][1] == 'V':
-            fileinputs = open("madinMMC_V.2")
-        else:
-            sys.exit("ERROR, DONT KNOW WHICH INPUTS TO USE")
-        fileinputschannel = open(os.path.join(proc['folder'], proc['channel'], 'madinM1'),'w')
-        i=0
-        for line in fileinputs:
-            i += 1
-            if i == 2:
-                accuracy=min(math.sqrt(totABS/(req_acc2_inv*proc['resultABS'])),0.2)
-                fileinputschannel.write('%10.8e\n' % accuracy)
-            elif i == 8:
-                fileinputschannel.write('1        ! MINT mode\n')
-            else:
-                fileinputschannel.write(line)
-        fileinputschannel.close()
-        fileinputs.close()
-
-    evts_file = open('nevents_unweighted', 'w')
-    evts_file.write(content_evts)
-    evts_file.close()
-
-# if nevents = -1 and req_acc >= 0, we need to determine the required
-# accuracy in each of the channels: this is for fixed order running!
-elif req_acc>=0 and nevents==-1:
-    req_accABS=req_acc*abs(tot)/totABS
-    content_evts = ''
-    for proc in processes:
-        if proc['channel'][0:3] == 'all':
-            fileinputs = open("madin.all")
-        elif proc['channel'][0:4] == 'novB':
-            fileinputs = open("madin.novB")
-        elif proc['channel'][0:4] == 'born':
-            fileinputs = open("madin.born")
-        elif proc['channel'][0:4] == 'grid':
-            fileinputs = open("madin.grid")
-        elif proc['channel'][0:4] == 'viSB':
-            fileinputs = open("madin.viSB")
-        elif proc['channel'][0:4] == 'virt':
-            fileinputs = open("madin.virt")
-        elif proc['channel'][0:4] == 'novi':
-            fileinputs = open("madin.novi")
-        else:
-            sys.exit("ERROR, DONT KNOW WHICH INPUTS TO USE")
-        fileinputschannel = open(os.path.join(proc['folder'], proc['channel'], 'madinM1'),'w')
-        i=0
-        for line in fileinputs:
-            i += 1
-            if i == 2:
-                accuracy=req_accABS*math.sqrt(totABS*proc['resultABS'])
-                fileinputschannel.write('%10.8e\n' % accuracy)
-            elif i == 9:
-                fileinputschannel.write('-1        ! restart from existing grids\n')
-            else:
-                fileinputschannel.write(line)
-        fileinputschannel.close()
-        fileinputs.close()

=== modified file 'Template/NLO/SubProcesses/symmetry_fks_v3.f'
--- Template/NLO/SubProcesses/symmetry_fks_v3.f	2014-06-26 08:45:41 +0000
+++ Template/NLO/SubProcesses/symmetry_fks_v3.f	2015-10-02 07:00:47 +0000
@@ -541,6 +541,8 @@
       lname=4
       mname='mg'
       call open_bash_file(26,fname,lname,mname)
+      call close_bash_file(26)
+      open(unit=26,file='channels.txt',status='unknown')
       ic = 0      
       do i=1,mapconfig(0)
          if (use_config(i) .gt. 0) then
@@ -567,15 +569,6 @@
             done = .false.
             do while (.not. done)
                call enCode(icode,iarray,ibase,imax)
-               ic=ic+1
-               if (ic .gt. ChanPerJob) then
-                  call close_bash_file(26)
-                  fname='ajob'
-                  lname=4
-                  mname='mg'
-                  call open_bash_file(26,fname,lname,mname)
-                  ic = 1
-               endif
 c               write(*,*) 'mapping',ic,mapconfig(i)
 c$$$               if (r_from_b(mapconfig(i)) .lt. 10) then
 c$$$                  write(26,'(i1$)') r_from_b(mapconfig(i))
@@ -611,7 +604,7 @@
             enddo
          endif
       enddo
-      call close_bash_file(26)
+      close(26)
       if (mapconfig(0) .gt. 9999) then
          write(*,*) 'Only writing first 9999 jobs',mapconfig(0)
       endif

=== modified file 'Template/NLO/SubProcesses/write_ajob.f'
--- Template/NLO/SubProcesses/write_ajob.f	2012-10-18 06:17:30 +0000
+++ Template/NLO/SubProcesses/write_ajob.f	2015-10-02 07:00:47 +0000
@@ -53,7 +53,7 @@
          if (index(buff,'TAGTAGTAGTAGTAG').ne.0) exit
          write(lun,15) buff
       enddo
-      write(lun,'(a$)') 'for i in '
+      write(lun,'(a$)') 'for i in $channel '
       return
  99   write (*,*) 'ajob_template or ajob_template_cluster '/
      &     /'does not have the correct format'

=== modified file 'madgraph/interface/amcatnlo_run_interface.py'
--- madgraph/interface/amcatnlo_run_interface.py	2015-10-01 16:00:08 +0000
+++ madgraph/interface/amcatnlo_run_interface.py	2015-10-02 07:00:47 +0000
@@ -1202,7 +1202,7 @@
         self.compile(mode, options) 
         evt_file = self.run(mode, options)
         
-        if int(self.run_card['nevents']) == 0 and not mode in ['LO', 'NLO']:
+        if self.run_card['nevents'] == 0 and not mode in ['LO', 'NLO']:
             logger.info('No event file generated: grids have been set-up with a '\
                             'relative precision of %s' % self.run_card['req_acc'])
             return
@@ -1222,7 +1222,7 @@
 
 
         self.update_status('', level='all', update_results=True)
-        if int(self.run_card['ickkw']) == 3 and mode in ['noshower', 'aMC@NLO']:
+        if self.run_card['ickkw'] == 3 and mode in ['noshower', 'aMC@NLO']:
             logger.warning("""You are running with FxFx merging enabled.
 To be able to merge samples of various multiplicities without double counting,
 you have to remove some events after showering 'by hand'.
@@ -1248,59 +1248,11 @@
 
         self.update_status('', level='all', update_results=True)
 
-    def print_results_in_shell(self, data):
-        """Have a nice results prints in the shell,
-        data should be of type: gen_crossxhtml.OneTagResults"""
-        if not data:
-            return
-        logger.info("  === Results Summary for run: %s tag: %s ===\n" % (data['run_name'],data['tag']))
-        if self.ninitial == 1:
-            logger.info("     Width :   %.4g +- %.4g GeV" % (data['cross'], data['error']))
-        else:
-            logger.info("     Cross-section :   %.4g +- %.4g pb" % (data['cross'], data['error']))
-        logger.info("     Nb of events :  %s" % data['nb_event'] )
-        #if data['cross_pythia'] and data['nb_event_pythia']:
-        #    if self.ninitial == 1:
-        #        logger.info("     Matched Width :   %.4g +- %.4g GeV" % (data['cross_pythia'], data['error_pythia']))
-        #    else:
-        #        logger.info("     Matched Cross-section :   %.4g +- %.4g pb" % (data['cross_pythia'], data['error_pythia']))            
-        #    logger.info("     Nb of events after Matching :  %s" % data['nb_event_pythia'])
-        #    if self.run_card['use_syst'] in self.true:
-        #        logger.info("     Be carefull that matched information are here NOT for the central value. Refer to SysCalc output for it")    
-        logger.info(" " )
-
-    def print_results_in_file(self, data, path, mode='w'):
-        """Have a nice results prints in the shell,
-        data should be of type: gen_crossxhtml.OneTagResults"""
-        if not data:
-            return
-        
-        fsock = open(path, mode)
-        
-        fsock.write("  === Results Summary for run: %s tag: %s  process: %s ===\n" % \
-                    (data['run_name'],data['tag'], os.path.basename(self.me_dir)))
-        
-        if self.ninitial == 1:
-            fsock.write("     Width :   %.4g +- %.4g GeV\n" % (data['cross'], data['error']))
-        else:
-            fsock.write("     Cross-section :   %.4g +- %.4g pb\n" % (data['cross'], data['error']))
-        fsock.write("     Nb of events :  %s\n" % data['nb_event'] )
-        #if data['cross_pythia'] and data['nb_event_pythia']:
-        #    if self.ninitial == 1:
-        #        fsock.write("     Matched Width :   %.4g +- %.4g GeV\n" % (data['cross_pythia'], data['error_pythia']))
-        #    else:
-        #        fsock.write("     Matched Cross-section :   %.4g +- %.4g pb\n" % (data['cross_pythia'], data['error_pythia']))            
-        #    fsock.write("     Nb of events after Matching :  %s\n" % data['nb_event_pythia'])
-        fsock.write(" \n" )
-
-
-
-
 
     def update_random_seed(self):
         """Update random number seed with the value from the run_card. 
         If this is 0, update the number according to a fresh one"""
-        iseed = int(self.run_card['iseed'])
+        iseed = self.run_card['iseed']
         if iseed == 0:
             randinit = open(pjoin(self.me_dir, 'SubProcesses', 'randinit'))
             iseed = int(randinit.read()[2:]) + 1
@@ -1317,218 +1269,94 @@
         if not 'only_generation' in options.keys():
             options['only_generation'] = False
 
+        # for second step in applgrid mode, do only the event generation step
         if mode in ['LO', 'NLO'] and self.run_card['iappl'] == 2 and not options['only_generation']:
             options['only_generation'] = True
         self.get_characteristics(pjoin(self.me_dir, 'SubProcesses', 'proc_characteristics'))
-
-        if self.cluster_mode == 1:
-            cluster_name = self.options['cluster_type']
-            self.cluster = cluster.from_name[cluster_name](**self.options)
-        if self.cluster_mode == 2:
-            try:
-                import multiprocessing
-                if not self.nb_core:
-                    try:
-                        self.nb_core = int(self.options['nb_core'])
-                    except TypeError:
-                        self.nb_core = multiprocessing.cpu_count()
-                logger.info('Using %d cores' % self.nb_core)
-            except ImportError:
-                self.nb_core = 1
-                logger.warning('Impossible to detect the number of cores => Using One.\n'+
-                        'Use set nb_core X in order to set this number and be able to'+
-                        'run in multicore.')
-
-            self.cluster = cluster.MultiCore(**self.options)
+        self.setup_cluster_or_multicore()
         self.update_random_seed()
         #find and keep track of all the jobs
         folder_names = {'LO': ['born_G*'], 'NLO': ['all_G*'],
                     'aMC@LO': ['GB*'], 'aMC@NLO': ['GF*']}
         folder_names['noshower'] = folder_names['aMC@NLO']
         folder_names['noshowerLO'] = folder_names['aMC@LO']
-        job_dict = {}
         p_dirs = [d for d in \
                 open(pjoin(self.me_dir, 'SubProcesses', 'subproc.mg')).read().split('\n') if d]
-        #find jobs and clean previous results
-        if not options['only_generation'] and not options['reweightonly']:
-            self.update_status('Cleaning previous results', level=None)
-        for dir in p_dirs:
-            job_dict[dir] = [file for file in \
-                                 os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)) \
-                                 if file.startswith('ajob')] 
-            #find old folders to be removed
-            for obj in folder_names[mode]:
-                to_rm = [file for file in \
-                             os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)) \
-                             if file.startswith(obj[:-1]) and \
-                            (os.path.isdir(pjoin(self.me_dir, 'SubProcesses', dir, file)) or \
-                             os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir, file)))] 
-                #always clean dirs for the splitted event generation
-                # do not include the born_G/ grid_G which should be kept when
-                # doing a f.o. run keeping old grids
-                to_always_rm = [file for file in \
-                             os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)) \
-                             if file.startswith(obj[:-1]) and
-                             '_' in file and not '_G' in file and \
-                            (os.path.isdir(pjoin(self.me_dir, 'SubProcesses', dir, file)) or \
-                             os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir, file)))]
-
-                if not options['only_generation'] and not options['reweightonly']:
-                    to_always_rm.extend(to_rm)
-                    if os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir,'MadLoop5_resources.tar.gz')):
-                        to_always_rm.append(pjoin(self.me_dir, 'SubProcesses', dir,'MadLoop5_resources.tar.gz'))
-                files.rm([pjoin(self.me_dir, 'SubProcesses', dir, d) for d in to_always_rm])
-
-        mcatnlo_status = ['Setting up grid', 'Computing upper envelope', 'Generating events']
-
-        if self.run_card['iappl'] == 2:
-            self.applgrid_distribute(options,mode,p_dirs)
+        #Clean previous results
+        self.clean_previous_results(options,p_dirs,folder_names[mode])
+
+        mcatnlo_status = ['Setting up grids', 'Computing upper envelope', 'Generating events']
+
 
         if options['reweightonly']:
             event_norm=self.run_card['event_norm']
-            nevents=int(self.run_card['nevents'])
+            nevents=self.run_card['nevents']
             return self.reweight_and_collect_events(options, mode, nevents, event_norm)
 
         devnull = os.open(os.devnull, os.O_RDWR) 
+
         if mode in ['LO', 'NLO']:
             # this is for fixed order runs
             mode_dict = {'NLO': 'all', 'LO': 'born'}
             logger.info('Doing fixed order %s' % mode)
             req_acc = self.run_card['req_acc_FO']
-            if not options['only_generation'] and req_acc != -1:
-                self.write_madin_file(pjoin(self.me_dir, 'SubProcesses'), mode_dict[mode], 0, '-1', '6','0.10') 
-                self.update_status('Setting up grids', level=None)
-                self.run_all(job_dict, [['0', mode_dict[mode], '0']], 'Setting up grids')
-            elif not options['only_generation']:
-                npoints = self.run_card['npoints_FO_grid']
-                niters = self.run_card['niters_FO_grid']
-                self.write_madin_file(pjoin(self.me_dir, 'SubProcesses'), mode_dict[mode], 0, npoints, niters) 
-                self.update_status('Setting up grids', level=None)
-                self.run_all(job_dict, [['0', mode_dict[mode], '0']], 'Setting up grids')
-
-            if req_acc != -1 and req_acc <= 0.003 and not options['only_generation']:
-                # required accuracy is rather smal. It is more
-                # efficient to do an extra step in between with a
-                # required accuracy of 10*req_acc, and only after that
-                # to go to final req_acc. This is particularly true
-                # for the plots, that otherwise might see larger
-                # fluctuations from the first (couple of) iterations.
-                req_accs=[min(req_acc*10,0.01),req_acc]
-            else:
-                req_accs=[req_acc]
-
-            for req_acc in req_accs:
-                npoints = self.run_card['npoints_FO']
-                niters = self.run_card['niters_FO']
-                self.write_madin_file(pjoin(self.me_dir, 'SubProcesses'), mode_dict[mode], -1, npoints, niters) 
-                # collect the results and logs
-                self.collect_log_files(folder_names[mode], 0)
-                p = misc.Popen(['./combine_results_FO.sh', str(req_acc), '%s_G*' % mode_dict[mode]], \
-                               stdout=subprocess.PIPE, \
-                               cwd=pjoin(self.me_dir, 'SubProcesses'))
-                output = p.communicate()
-
-                self.cross_sect_dict = self.read_results(output, mode)
-                self.print_summary(options, 0, mode)
-                cross, error = sum_html.make_all_html_results(self, ['%s*' % mode_dict[mode]])
-                self.results.add_detail('cross', cross)
-                self.results.add_detail('error', error) 
-
-                self.update_status('Computing cross-section', level=None)
-                self.run_all(job_dict, [['0', mode_dict[mode], '0', mode_dict[mode]]], 'Computing cross-section')
-
-            # collect the results and logs
-            self.collect_log_files(folder_names[mode], 1)
-            p = misc.Popen(['./combine_results_FO.sh', '-1'] + folder_names[mode], \
-                                stdout=subprocess.PIPE, 
-                                cwd=pjoin(self.me_dir, 'SubProcesses'))
-            output = p.communicate()
-            self.cross_sect_dict = self.read_results(output, mode)
-
-            # collect the scale and PDF uncertainties
-            scale_pdf_info={}
-            if self.run_card['reweight_scale'] or self.run_card['reweight_PDF']:
-                data_files=[]
-                for dir in p_dirs:
-                    for obj in folder_names[mode]:
-                        for file in os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)):
-                            if file.startswith(obj[:-1]) and \
-                                    (os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir, file,'scale_pdf_dependence.dat'))):
-                                data_files.append(pjoin(dir,file,'scale_pdf_dependence.dat'))
-                scale_pdf_info = self.pdf_scale_from_reweighting(data_files)
-            # print the results:
-            self.print_summary(options, 1, mode, scale_pdf_info)
-
-            files.cp(pjoin(self.me_dir, 'SubProcesses', 'res.txt'),
-                     pjoin(self.me_dir, 'Events', self.run_name))
-            
-            if self.analyse_card['fo_analysis_format'].lower() == 'topdrawer':
-                misc.call(['./combine_plots_FO.sh'] + folder_names[mode], \
-                                stdout=devnull, 
-                                cwd=pjoin(self.me_dir, 'SubProcesses'))
-                files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.top'),
-                                pjoin(self.me_dir, 'Events', self.run_name))
-                logger.info('The results of this run and the TopDrawer file with the plots' + \
-                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
-            elif self.analyse_card['fo_analysis_format'].lower() == 'hwu':
-                self.combine_plots_HwU(folder_names[mode])
-                files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.HwU'),
-                                pjoin(self.me_dir, 'Events', self.run_name))
-                files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.gnuplot'),
-                                pjoin(self.me_dir, 'Events', self.run_name))
-                try:
-                    misc.call(['gnuplot','MADatNLO.gnuplot'],\
-                              stdout=os.open(os.devnull, os.O_RDWR),\
-                              stderr=os.open(os.devnull, os.O_RDWR),\
-                              cwd=pjoin(self.me_dir, 'Events', self.run_name))
-                except Exception:
-                    pass
-
-
-                logger.info('The results of this run and the HwU and GnuPlot files with the plots' + \
-                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
-            elif self.analyse_card['fo_analysis_format'].lower() == 'root':
-                misc.call(['./combine_root.sh'] + folder_names[mode], \
-                                stdout=devnull, 
-                                cwd=pjoin(self.me_dir, 'SubProcesses'))
-                files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.root'),
-                                pjoin(self.me_dir, 'Events', self.run_name))
-                logger.info('The results of this run and the ROOT file with the plots' + \
-                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
-            else:
-                logger.info('The results of this run' + \
-                            ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
-                
-            cross, error = sum_html.make_all_html_results(self, folder_names[mode])
-            self.results.add_detail('cross', cross)
-            self.results.add_detail('error', error)
-            if self.run_card['iappl'] != 0:
-                self.applgrid_combine(cross,error)
+
+            # Re-distribute the grids for the 2nd step of the applgrid
+            # running
+            if self.run_card['iappl'] == 2:
+                self.applgrid_distribute(options,mode_dict[mode],p_dirs)
+
+            # create a list of dictionaries "jobs_to_run" with all the
+            # jobs that need to be run
+            integration_step=-1
+            jobs_to_run,integration_step = self.create_jobs_to_run(options,p_dirs, \
+                                req_acc,mode_dict[mode],integration_step,mode,fixed_order=True)
+            jobs_to_collect=copy.copy(jobs_to_run)
+            self.prepare_directories(jobs_to_run,mode)
+
+            # loop over the integration steps. After every step, check
+            # if we have the required accuracy. If this is the case,
+            # stop running, else do another step.
+            while True:
+                integration_step=integration_step+1
+                self.run_all_jobs(jobs_to_run,integration_step)
+                self.collect_log_files(jobs_to_run,integration_step)
+                jobs_to_run,jobs_to_collect=self.collect_the_results(options,req_acc,jobs_to_run, \
+                                  jobs_to_collect,integration_step,mode,mode_dict[mode])
+                if not jobs_to_run:
+                    # there are no more jobs to run (jobs_to_run is empty)
+                    break
+            # We are done.
+            self.finalise_run_FO(folder_names[mode],jobs_to_collect)
             self.update_status('Run complete', level='parton', update_results=True)
-
             return
 
         elif mode in ['aMC@NLO','aMC@LO','noshower','noshowerLO']:
+            mode_dict = {'aMC@NLO': 'all', 'aMC@LO': 'born',\
+                         'noshower': 'all', 'noshowerLO': 'born'}
             shower = self.run_card['parton_shower'].upper()
-            nevents = int(self.run_card['nevents'])
+            nevents = self.run_card['nevents']
             req_acc = self.run_card['req_acc']
-            if nevents == 0 and float(req_acc) < 0 :
+            if nevents == 0 and req_acc < 0 :
                 raise aMCatNLOError('Cannot determine the required accuracy from the number '\
                                         'of events, because 0 events requested. Please set '\
-                                        'the "req_acc" parameter in the run_card to a value between 0 and 1')
-            elif float(req_acc) >1 or float(req_acc) == 0 :
+                                        'the "req_acc" parameter in the run_card to a value '\
+                                        'between 0 and 1')
+            elif req_acc >1 or req_acc == 0 :
                 raise aMCatNLOError('Required accuracy ("req_acc" in the run_card) should '\
                                         'be between larger than 0 and smaller than 1, '\
-                                        'or set to -1 for automatic determination. Current value is %s' % req_acc)
+                                        'or set to -1 for automatic determination. Current '\
+                                        'value is %f' % req_acc)
 # For more than 1M events, set req_acc to 0.001 (except when it was explicitly set in the run_card)
-            elif float(req_acc) < 0 and nevents > 1000000 :
-                req_acc='0.001'
+            elif req_acc < 0 and nevents > 1000000 :
+                req_acc=0.001
 
             shower_list = ['HERWIG6', 'HERWIGPP', 'PYTHIA6Q', 'PYTHIA6PT', 'PYTHIA8']
 
             if not shower in shower_list:
-                raise aMCatNLOError('%s is not a valid parton shower. Please use one of the following: %s' \
-                    % (shower, ', '.join(shower_list)))
+                raise aMCatNLOError('%s is not a valid parton shower. '\
+                                    'Please use one of the following: %s' \
+                                    % (shower, ', '.join(shower_list)))
 
 # check that PYTHIA6PT is not used for processes with FSR
             if shower == 'PYTHIA6PT' and self.proc_characteristics['has_fsr']:
@@ -1541,98 +1369,538 @@
             elif options['only_generation']:
                 logger.info('Generating events starting from existing results')
             
-
-            for i, status in enumerate(mcatnlo_status):
-                #check if need to split jobs 
-                # at least one channel must have enough events
-                try:
-                    nevents_unweighted = open(pjoin(self.me_dir, 
-                                                'SubProcesses', 
-                                                'nevents_unweighted')).read().split('\n')
-                except IOError:
-                    nevents_unweighted = []
-
-                split = i == 2 and \
-                        int(self.run_card['nevt_job']) > 0 
-
-                if i == 2 or not options['only_generation']:
-                    # if the number of events requested is zero,
-                    # skip mint step 2
-                    if i==2 and nevents==0:
-                        self.print_summary(options, 2,mode)
-                        return
-
-                    if split:
-                        # split the event generation
-                        misc.call([pjoin(self.me_dir, 'bin', 'internal', 'split_jobs.py')] + \
-                                   [str(self.run_card['nevt_job'])],
-                                   stdout = devnull,
-                                   cwd = pjoin(self.me_dir, 'SubProcesses'))
-                        assert os.path.exists(pjoin(self.me_dir, 'SubProcesses', 
-                            'nevents_unweighted_splitted'))
-
-                    self.update_status(status, level='parton')
-                    if mode in ['aMC@NLO', 'noshower']:
-                        self.write_madinMMC_file(pjoin(self.me_dir, 'SubProcesses'), 'all', i) 
-                        self.run_all(job_dict, [['2', 'F', '%d' % i]], status, split_jobs = split)
-                        
-                    elif mode in ['aMC@LO', 'noshowerLO']:
-                        self.write_madinMMC_file(
-                            pjoin(self.me_dir, 'SubProcesses'), 'born', i) 
-                        self.run_all(job_dict, 
-                                     [['2', 'B', '%d' % i]], 
-                                     '%s at LO' % status, split_jobs = split)
-
-                if (i < 2 and not options['only_generation']) or i == 1 :
-                    # collect the results and logs
-                    self.collect_log_files(folder_names[mode], i)
-                    p = misc.Popen(['./combine_results.sh'] + \
-                                   ['%d' % i,'%d' % nevents, '%s' % req_acc ] + \
-                                   folder_names[mode],
-                                   stdout=subprocess.PIPE, 
-                                   cwd = pjoin(self.me_dir, 'SubProcesses'))
-                    output = p.communicate()
-                    files.cp(pjoin(self.me_dir, 'SubProcesses', 'res_%d.txt' % i), \
-                             pjoin(self.me_dir, 'Events', self.run_name))
-
-                    self.cross_sect_dict = self.read_results(output, mode)
-                    self.print_summary(options, i, mode)
-
-                    cross, error = sum_html.make_all_html_results(self, folder_names[mode])
-                    self.results.add_detail('cross', cross)
-                    self.results.add_detail('error', error) 
-
-                #check that split jobs are all correctly terminated
-                if split:
-                    self.check_event_files()
-
-        if self.cluster_mode == 1:
-            #if cluster run, wait 15 sec so that event files are transferred back
-            self.update_status(
+            jobs_to_run,integration_step = self.create_jobs_to_run(options,p_dirs, \
+                                            req_acc,mode_dict[mode],1,mode,fixed_order=False)
+            jobs_to_collect=copy.copy(jobs_to_run)
+            self.prepare_directories(jobs_to_run,mode,fixed_order=False)
+
+            # Make sure to update all the jobs to be ready for the event generation step
+            if options['only_generation']:
+                jobs_to_run,jobs_to_collect=self.collect_the_results(options,req_acc,jobs_to_run, \
+                                jobs_to_collect,1,mode,mode_dict[mode],fixed_order=False)
+
+            # Main loop over the three MINT generation steps:
+            for mint_step, status in enumerate(mcatnlo_status):
+                if options['only_generation'] and mint_step < 2:
+                    continue
+                self.update_status(status, level='parton')
+                self.run_all_jobs(jobs_to_run,mint_step,fixed_order=False)
+                self.collect_log_files(jobs_to_run,mint_step)
+                jobs_to_run,jobs_to_collect=self.collect_the_results(options,req_acc,jobs_to_run, \
+                                jobs_to_collect,mint_step,mode,mode_dict[mode],fixed_order=False)
+            # Sanity check on the event files. If error the jobs are resubmitted
+            self.check_event_files(jobs_to_collect)
+
+            if self.cluster_mode == 1:
+            #if cluster run, wait 10 sec so that event files are transferred back
+                self.update_status(
                     'Waiting while files are transferred back from the cluster nodes',
                     level='parton')
-            time.sleep(10)
-        if split:
-            files.cp(pjoin(self.me_dir, 'SubProcesses', 'nevents_unweighted_splitted'), \
-                     pjoin(self.me_dir, 'SubProcesses', 'nevents_unweighted'))
-
-
-        event_norm=self.run_card['event_norm']
-        self.collect_log_files(folder_names[mode], 2)
-        return self.reweight_and_collect_events(options, mode, nevents, event_norm)
-
-    def combine_plots_HwU(self,folder_names):
+                time.sleep(10)
+
+            event_norm=self.run_card['event_norm']
+            return self.reweight_and_collect_events(options, mode, nevents, event_norm)
+
+    def create_jobs_to_run(self,options,p_dirs,req_acc,run_mode,\
+                           integration_step,mode,fixed_order=True):
+        """Creates a list of dictionaries with all the jobs to be run"""
+        jobs_to_run=[]
+        if not options['only_generation']:
+            # Fresh, new run. Check all the P*/channels.txt files
+            # (created by the 'gensym' executable) to set-up all the
+            # jobs using the default inputs.
+            npoints = self.run_card['npoints_FO_grid']
+            niters = self.run_card['niters_FO_grid']
+            for p_dir in p_dirs:
+                with open(pjoin(self.me_dir,'SubProcesses',p_dir,'channels.txt')) as chan_file:
+                    channels=chan_file.readline().split()
+                for channel in channels:
+                    job={}
+                    job['p_dir']=p_dir
+                    job['channel']=channel
+                    job['split']=0
+                    if fixed_order and req_acc == -1:
+                        job['accuracy']=0
+                        job['niters']=niters
+                        job['npoints']=npoints
+                    elif fixed_order and req_acc > 0:
+                        job['accuracy']=0.10
+                        job['niters']=6
+                        job['npoints']=-1
+                    elif not fixed_order:
+                        job['accuracy']=0.03
+                        job['niters']=12
+                        job['npoints']=-1
+                    else:
+                        raise aMCatNLOError('No consistent "req_acc_FO" set. Use a value '+
+                                            'between 0 and 1 or set it equal to -1.')
+                    job['mint_mode']=0
+                    job['run_mode']=run_mode
+                    job['wgt_frac']=1.0
+                    jobs_to_run.append(job)
+        else:
+            # if options['only_generation'] is true, we need to loop
+            # over all the existing G* directories and create the jobs
+            # from there.
+            name_suffix={'born' :'B', 'all':'F'}
+            for p_dir in p_dirs:
+                for chan_dir in os.listdir(pjoin(self.me_dir,'SubProcesses',p_dir)):
+                    if ((chan_dir.startswith(run_mode+'_G') and fixed_order) or\
+                        (chan_dir.startswith('G'+name_suffix[run_mode]) and (not fixed_order))) and \
+                       (os.path.isdir(pjoin(self.me_dir, 'SubProcesses', p_dir, chan_dir)) or \
+                        os.path.exists(pjoin(self.me_dir, 'SubProcesses', p_dir, chan_dir))):
+                        job={}
+                        job['p_dir']=p_dir
+                        if fixed_order:
+                            channel=chan_dir.split('_')[1]
+                            job['channel']=channel[1:] # remove the 'G'
+                            if len(chan_dir.split('_')) == 3:
+                                split=int(chan_dir.split('_')[2])
+                            else:
+                                split=0
+                        else:
+                            if len(chan_dir.split('_')) == 2:
+                                split=int(chan_dir.split('_')[1])
+                                channel=chan_dir.split('_')[0]
+                                job['channel']=channel[2:] # remove the 'G'
+                            else:
+                                job['channel']=chan_dir[2:] # remove the 'G'
+                                split=0
+                        job['split']=split
+                        job['run_mode']=run_mode
+                        job['dirname']=pjoin(self.me_dir, 'SubProcesses', p_dir, chan_dir)
+                        job['wgt_frac']=1.0
+                        if not fixed_order: job['mint_mode']=1
+                        jobs_to_run.append(job)
+            jobs_to_collect=copy.copy(jobs_to_run) # These are all jobs
+            if fixed_order:
+                jobs_to_run,jobs_to_collect=self.collect_the_results(options,req_acc,jobs_to_run,
+                                                 jobs_to_collect,integration_step,mode,run_mode)
+                # Update the integration_step to make sure that nothing will be overwritten
+                integration_step=1
+                for job in jobs_to_run:
+                    while os.path.exists(pjoin(job['dirname'],'res_%s.dat' % integration_step)):
+                        integration_step=integration_step+1
+                integration_step=integration_step-1
+            else:
+                self.append_the_results(jobs_to_collect,integration_step)
+        return jobs_to_run,integration_step
+
+    def prepare_directories(self,jobs_to_run,mode,fixed_order=True):
+        """Set-up the G* directories for running"""
+        name_suffix={'born' :'B' , 'all':'F'}
+        for job in jobs_to_run:
+            if job['split'] == 0:
+                if fixed_order :
+                    dirname=pjoin(self.me_dir,'SubProcesses',job['p_dir'],
+                                  job['run_mode']+'_G'+job['channel'])
+                else:
+                    dirname=pjoin(self.me_dir,'SubProcesses',job['p_dir'],
+                                  'G'+name_suffix[job['run_mode']]+job['channel'])
+            else:
+                if fixed_order :
+                    dirname=pjoin(self.me_dir,'SubProcesses',job['p_dir'],
+                            job['run_mode']+'_G'+job['channel']+'_'+str(job['split']))
+                else:
+                    dirname=pjoin(self.me_dir,'SubProcesses',job['p_dir'],
+                            'G'+name_suffix[job['run_mode']]+job['channel']+'_'+str(job['split']))
+            job['dirname']=dirname
+            if not os.path.isdir(dirname):
+                os.makedirs(dirname)
+            self.write_input_file(job,fixed_order)
+            if not fixed_order:
+                # copy the grids from the base directory to the split directory:
+                if job['split'] != 0:
+                    for f in ['grid.MC_integer','mint_grids','res_1']:
+                        if not os.path.isfile(pjoin(job['dirname'],f)):
+                            files.ln(pjoin(job['dirname'].rsplit("_",1)[0],f),job['dirname'])
+
+
+    def write_input_file(self,job,fixed_order):
+        """write the input file for the madevent_mint* executable in the appropriate directory"""
+        if fixed_order:
+            content= \
+"""NPOINTS = %(npoints)s
+NITERATIONS = %(niters)s
+ACCURACY = %(accuracy)s
+ADAPT_GRID = 2
+MULTICHANNEL = 1
+SUM_HELICITY = 1
+CHANNEL = %(channel)s
+SPLIT = %(split)s
+RUN_MODE = %(run_mode)s
+RESTART = %(mint_mode)s
+""" \
+              % job
+        else:
+            content = \
+"""-1 12      ! points, iterations
+%(accuracy)s       ! desired fractional accuracy
+1 -0.1     ! alpha, beta for Gsoft
+-1 -0.1    ! alpha, beta for Gazi
+1          ! Suppress amplitude (0 no, 1 yes)?
+1          ! Exact helicity sum (0 yes, n = number/event)?
+%(channel)s          ! Enter Configuration Number:
+%(mint_mode)s          ! MINT imode: 0 to set-up grids, 1 to perform integral, 2 generate events
+1 1 1      ! if imode is 1: Folding parameters for xi_i, phi_i and y_ij
+%(run_mode)s        ! all, born, real, virt
+""" \
+                    % job
+        with open(pjoin(job['dirname'], 'input_app.txt'), 'w') as input_file:
+            input_file.write(content)
+
+
+    def run_all_jobs(self,jobs_to_run,integration_step,fixed_order=True):
+        """Loops over the jobs_to_run and executes them using the function 'run_exe'"""
+        if fixed_order:
+            if integration_step == 0:
+                self.update_status('Setting up grids', level=None)
+            else:
+                self.update_status('Refining results, step %i' % integration_step, level=None)
+        self.ijob = 0
+        name_suffix={'born' :'B', 'all':'F'}
+        for job in jobs_to_run:
+            executable='ajob1'
+            if fixed_order:
+                arguments=[job['channel'],job['run_mode'], \
+                                    str(job['split']),str(integration_step)]
+                run_type="Fixed order integration step %s" % integration_step
+            else:
+                arguments=[job['channel'],name_suffix[job['run_mode']], \
+                                    str(job['split']),str(integration_step)]
+                run_type="MINT step %s" % integration_step
+            self.run_exe(executable,arguments,run_type,
+                         cwd=pjoin(self.me_dir,'SubProcesses',job['p_dir']))
+
+        if self.cluster_mode == 2:
+            time.sleep(1) # security to allow all jobs to be launched
+        self.njobs=len(jobs_to_run)
+        self.wait_for_complete(run_type)
+
+
+    def collect_the_results(self,options,req_acc,jobs_to_run,jobs_to_collect,\
+                            integration_step,mode,run_mode,fixed_order=True):
+        """Collect the results, make HTML pages, print the summary and
+           determine if there are more jobs to run. Returns the list
+           of the jobs that still need to be run, as well as the
+           complete list of jobs that need to be collected to get the
+           final answer.
+        """
+# Get the results of the current integration/MINT step
+        self.append_the_results(jobs_to_run,integration_step)
+        self.cross_sect_dict = self.write_res_txt_file(jobs_to_collect,integration_step)
+# Update HTML pages
+        if fixed_order:
+            cross, error = sum_html.make_all_html_results(self, ['%s*' % run_mode])
+        else:
+            name_suffix={'born' :'B' , 'all':'F'}
+            cross, error = sum_html.make_all_html_results(self, ['G%s*' % name_suffix[run_mode]])
+        self.results.add_detail('cross', cross)
+        self.results.add_detail('error', error) 
+# Set-up jobs for the next iteration/MINT step
+        jobs_to_run_new=self.update_jobs_to_run(req_acc,integration_step,jobs_to_run,fixed_order)
+        # if there are no more jobs, we are done!
+# Print summary
+        if (not jobs_to_run_new) and fixed_order:
+            # print final summary of results (for fixed order)
+            scale_pdf_info=self.collect_scale_pdf_info(options,jobs_to_collect)
+            self.print_summary(options,integration_step,mode,scale_pdf_info,done=True)
+            return jobs_to_run_new,jobs_to_collect
+        elif jobs_to_run_new:
+            # print intermediate summary of results
+            scale_pdf_info={}
+            self.print_summary(options,integration_step,mode,scale_pdf_info,done=False)
+        else:
+            # When we are done for (N)LO+PS runs, do not print
+            # anything yet. This will be done after the reweighting
+            # and collection of the events
+            scale_pdf_info={}
+# Prepare for the next integration/MINT step
+        if (not fixed_order) and integration_step+1 == 2 :
+            # next step is event generation (mint_step 2)
+            jobs_to_run_new,jobs_to_collect_new= \
+                    self.check_the_need_to_split(jobs_to_run_new,jobs_to_collect)
+            self.prepare_directories(jobs_to_run_new,mode,fixed_order)
+            self.write_nevents_unweighted_file(jobs_to_collect_new)
+            self.write_nevts_files(jobs_to_run_new)
+        else:
+            self.prepare_directories(jobs_to_run_new,mode,fixed_order)
+            jobs_to_collect_new=jobs_to_collect
+        return jobs_to_run_new,jobs_to_collect_new
+
+
+    def write_nevents_unweighted_file(self,jobs):
+        """writes the nevents_unweighted file in the SubProcesses directory"""
+        content=[]
+        for job in jobs:
+            path=pjoin(job['dirname'].split('/')[-2],job['dirname'].split('/')[-1])
+            lhefile=pjoin(path,'events.lhe')
+            content.append(' %s     %d     %9e     %9e' % \
+                (lhefile.ljust(40),job['nevents'],job['resultABS']*job['wgt_frac'],job['wgt_frac']))
+        with open(pjoin(self.me_dir,'SubProcesses',"nevents_unweighted"),'w') as f:
+            f.write('\n'.join(content)+'\n')
+
+    def write_nevts_files(self,jobs):
+        """write the nevts files in the SubProcesses/P*/G*/ directories"""
+        for job in jobs:
+            with open(pjoin(job['dirname'],'nevts'),'w') as f:
+                f.write('%i\n' % job['nevents'])
+
+    def check_the_need_to_split(self,jobs_to_run,jobs_to_collect):
+        """Looks in the jobs_to_run to see if there is the need to split the
+           event generation step. Updates jobs_to_run and
+           jobs_to_collect to replace the split-job by its
+           splits. Also removes jobs that do not need any events.
+        """
+        nevt_job=self.run_card['nevt_job']
+        if nevt_job > 0:
+            jobs_to_collect_new=copy.copy(jobs_to_collect)
+            for job in jobs_to_run:
+                nevents=job['nevents']
+                if nevents == 0:
+                    jobs_to_collect_new.remove(job)
+                elif nevents > nevt_job:
+                    jobs_to_collect_new.remove(job)
+                    nsplit=int(nevents/nevt_job)+1
+                    for i in range(1,nsplit+1):
+                        job_new=copy.copy(job)
+                        left_over=nevents % nsplit
+                        if i <= left_over:
+                            job_new['nevents']=int(nevents/nsplit)+1
+                            job_new['wgt_frac']=float(job_new['nevents'])/float(nevents)
+                        else:
+                            job_new['nevents']=int(nevents/nsplit)
+                            job_new['wgt_frac']=float(job_new['nevents'])/float(nevents)
+                        job_new['split']=i
+                        job_new['dirname']=job['dirname']+'_%i' % job_new['split']
+                        jobs_to_collect_new.append(job_new)
+            jobs_to_run_new=copy.copy(jobs_to_collect_new)
+        else:
+            jobs_to_run_new=copy.copy(jobs_to_collect)
+            for job in jobs_to_collect:
+                if job['nevents'] == 0:
+                    jobs_to_run_new.remove(job)
+            jobs_to_collect_new=copy.copy(jobs_to_run_new)
+
+        return jobs_to_run_new,jobs_to_collect_new
+    
+
+    def update_jobs_to_run(self,req_acc,step,jobs,fixed_order=True):
+        """
+        For (N)LO+PS:    determines the number of events and/or the required
+                         accuracy per job.
+        For fixed order: determines which jobs need higher precision and
+                         returns those with the newly requested precision.
+        """
+        err=self.cross_sect_dict['errt']
+        tot=self.cross_sect_dict['xsect']
+        errABS=self.cross_sect_dict['erra']
+        totABS=self.cross_sect_dict['xseca']
+        jobs_new=[]
+        if fixed_order:
+            if req_acc == -1:
+                if step == 0:
+                    npoints = self.run_card['npoints_FO']
+                    niters = self.run_card['niters_FO']
+                    for job in jobs:
+                        job['mint_mode']=-1
+                        job['niters']=niters
+                        job['npoints']=npoints
+                        jobs_new.append(job)
+                elif step > 0:
+                    raise aMCatNLOError('Cannot determine number of iterations and PS points '+
+                                        'for integration step %i' % step )
+            elif ( req_acc > 0 and err/tot > req_acc*1.2 ) or step == 0:
+                req_accABS=req_acc*abs(tot)/totABS # overal relative required accuracy on ABS Xsec.
+                for job in jobs:
+                    job['mint_mode']=-1
+                    # Determine relative required accuracy on the ABS for this job
+                    job['accuracy']=req_accABS*math.sqrt(totABS/job['resultABS'])
+                    # If already accurate enough, skip running
+                    if job['accuracy'] > job['errorABS']/job['resultABS'] and step != 0:
+                        continue
+                    # Update the number of PS points based on errorABS, ncall and accuracy
+                    itmax_fl=job['niters_done']*math.pow(job['errorABS']/
+                                                         (job['accuracy']*job['resultABS']),2)
+                    if itmax_fl <= 4.0 :
+                        job['niters']=max(int(round(itmax_fl)),2)
+                        job['npoints']=job['npoints_done']*2
+                    elif itmax_fl > 4.0 and itmax_fl <= 16.0 :
+                        job['niters']=4
+                        job['npoints']=int(round(job['npoints_done']*itmax_fl/4.0))*2
+                    else:
+                        if itmax_fl > 100.0 : itmax_fl=50.0
+                        job['niters']=int(round(math.sqrt(itmax_fl)))
+                        job['npoints']=int(round(job['npoints_done']*itmax_fl/
+                                                 round(math.sqrt(itmax_fl))))*2
+                    # Add the job to the list of jobs that need to be run
+                    jobs_new.append(job)
+            return jobs_new
+        elif step+1 <= 2:
+            nevents=self.run_card['nevents']
+            # Total required accuracy for the upper bounding envelope
+            if req_acc<0: 
+                req_acc2_inv=nevents
+            else:
+                req_acc2_inv=1/(req_acc*req_acc)
+            if step+1 == 1:
+                # determine the req. accuracy for each of the jobs for Mint-step = 1
+                for job in jobs:
+                    accuracy=min(math.sqrt(totABS/(req_acc2_inv*job['resultABS'])),0.2)
+                    job['accuracy']=accuracy
+            elif step+1 == 2:
+                # Randomly (based on the relative ABS Xsec of the job) determine the 
+                # number of events each job needs to generate for MINT-step = 2.
+                r=self.get_randinit_seed()
+                random.seed(r)
+                totevts=nevents
+                for job in jobs:
+                    job['nevents'] = 0
+                while totevts :
+                    target = random.random() * totABS
+                    crosssum = 0.
+                    i = 0
+                    while i<len(jobs) and crosssum < target:
+                        job = jobs[i]
+                        crosssum += job['resultABS']
+                        i += 1            
+                    totevts -= 1
+                    i -= 1
+                    jobs[i]['nevents'] += 1
+            for job in jobs:
+                job['mint_mode']=step+1 # next step
+            return jobs
+        else:
+            return []
+
+
+    def get_randinit_seed(self):
+        """ Get the random number seed from the randinit file """
+        with open(pjoin(self.me_dir,"SubProcesses","randinit")) as randinit:
+            # format of the file is "r=%d".
+            iseed = int(randinit.read()[2:])
+        return iseed
+
+
+    def append_the_results(self,jobs,integration_step):
+        """Appends the results for each of the jobs in the job list"""
+        error_found=False
+        for job in jobs:
+            try:
+                if integration_step >= 0 :
+                    with open(pjoin(job['dirname'],'res_%s.dat' % integration_step)) as res_file:
+                        results=res_file.readline().split()
+                else:
+                # should only be here when doing fixed order with the 'only_generation'
+                # option equal to True. Take the results from the final run done.
+                    with open(pjoin(job['dirname'],'res.dat')) as res_file:
+                        results=res_file.readline().split()
+            except IOError:
+                if not error_found:
+                    error_found=True
+                    error_log=[]
+                error_log.append(pjoin(job['dirname'],'log.txt'))
+                continue
+            job['resultABS']=float(results[0])
+            job['errorABS']=float(results[1])
+            job['result']=float(results[2])
+            job['error']=float(results[3])
+            job['niters_done']=int(results[4])
+            job['npoints_done']=int(results[5])
+            job['time_spend']=float(results[6])
+            job['err_percABS'] = job['errorABS']/job['resultABS']*100.
+            job['err_perc'] = job['error']/job['result']*100.
+        if error_found:
+            raise aMCatNLOError('An error occurred during the collection of results.\n' + 
+                   'Please check the .log files inside the directories which failed:\n' +
+                                '\n'.join(error_log)+'\n')
+
+
+
+    def write_res_txt_file(self,jobs,integration_step):
+        """writes the res.txt files in the SubProcess dir"""
+        jobs.sort(key = lambda job: -job['errorABS'])
+        content=[]
+        content.append('\n\nCross-section per integration channel:')
+        for job in jobs:
+            content.append('%(p_dir)20s  %(channel)15s   %(result)10.8e    %(error)6.4e       %(err_perc)6.4f%%  ' %  job)
+        content.append('\n\nABS cross-section per integration channel:')
+        for job in jobs:
+            content.append('%(p_dir)20s  %(channel)15s   %(resultABS)10.8e    %(errorABS)6.4e       %(err_percABS)6.4f%%  ' %  job)
+        totABS=0
+        errABS=0
+        tot=0
+        err=0
+        for job in jobs:
+            totABS+= job['resultABS']
+            errABS+= math.pow(job['errorABS'],2)
+            tot+= job['result']
+            err+= math.pow(job['error'],2)
+        content.append('\nTotal ABS and \nTotal: \n                      %10.8e +- %6.4e  (%6.4e%%)\n                      %10.8e +- %6.4e  (%6.4e%%) \n' %\
+            (totABS, math.sqrt(errABS), math.sqrt(errABS)/totABS *100.,tot, math.sqrt(err), math.sqrt(err)/tot *100.))
+        with open(pjoin(self.me_dir,'SubProcesses','res_%s.txt' % integration_step),'w') as res_file:
+            res_file.write('\n'.join(content))
+        randinit=self.get_randinit_seed()
+        return {'xsect':tot,'xseca':totABS,'errt':math.sqrt(err),\
+                'erra':math.sqrt(errABS),'randinit':randinit}
+        
+
+    def collect_scale_pdf_info(self,options,jobs):
+        """read the scale_pdf_dependence.dat files and collects there results"""
+        scale_pdf_info={}
+        if self.run_card['reweight_scale'] or self.run_card['reweight_PDF']:
+            data_files=[]
+            for job in jobs:
+                data_files.append(pjoin(job['dirname'],'scale_pdf_dependence.dat'))
+            scale_pdf_info = self.pdf_scale_from_reweighting(data_files)
+        return scale_pdf_info
+
+
+    def combine_plots_FO(self,folder_name,jobs):
+        """combines the plots and puts then in the Events/run* directory"""
+        devnull = os.open(os.devnull, os.O_RDWR) 
+        if self.analyse_card['fo_analysis_format'].lower() == 'topdrawer':
+            misc.call(['./combine_plots_FO.sh'] + folder_name, \
+                      stdout=devnull, 
+                      cwd=pjoin(self.me_dir, 'SubProcesses'))
+            files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.top'),
+                     pjoin(self.me_dir, 'Events', self.run_name))
+            logger.info('The results of this run and the TopDrawer file with the plots' + \
+                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
+        elif self.analyse_card['fo_analysis_format'].lower() == 'hwu':
+            self.combine_plots_HwU(jobs)
+            files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.HwU'),
+                     pjoin(self.me_dir, 'Events', self.run_name))
+            files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.gnuplot'),
+                     pjoin(self.me_dir, 'Events', self.run_name))
+            try:
+                misc.call(['gnuplot','MADatNLO.gnuplot'],\
+                          stdout=devnull,stderr=devnull,\
+                          cwd=pjoin(self.me_dir, 'Events', self.run_name))
+            except Exception:
+                pass
+            logger.info('The results of this run and the HwU and GnuPlot files with the plots' + \
+                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
+        elif self.analyse_card['fo_analysis_format'].lower() == 'root':
+            misc.call(['./combine_root.sh'] + folder_name, \
+                      stdout=devnull, 
+                      cwd=pjoin(self.me_dir, 'SubProcesses'))
+            files.cp(pjoin(self.me_dir, 'SubProcesses', 'MADatNLO.root'),
+                     pjoin(self.me_dir, 'Events', self.run_name))
+            logger.info('The results of this run and the ROOT file with the plots' + \
+                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
+        else:
+            logger.info('The results of this run' + \
+                        ' have been saved in %s' % pjoin(self.me_dir, 'Events', self.run_name))
+
+
+    def combine_plots_HwU(self,jobs):
         """Sums all the plots in the HwU format."""
-        
         logger.debug('Combining HwU plots.')
-        
-        with open(pjoin(self.me_dir,'SubProcesses','dirs.txt')) as dirf:
-            all_histo_paths = dirf.readlines()
-        all_histo_paths = [pjoin(self.me_dir,'SubProcesses',
-                      path.rstrip(),"MADatNLO.HwU") for path in all_histo_paths]
-        
+        all_histo_paths=[]
+        for job in jobs:
+            all_histo_paths.append(pjoin(job['dirname'],"MADatNLO.HwU"))
         histogram_list = histograms.HwUList(all_histo_paths[0])
-
         for histo_path in all_histo_paths[1:]:
             for i, histo in enumerate(histograms.HwUList(histo_path)):
                 # First make sure the plots have the same weight labels and such
@@ -1644,19 +1912,18 @@
         histogram_list.output(pjoin(self.me_dir,'SubProcesses',"MADatNLO"),
                                                              format = 'gnuplot')
 
-    def applgrid_combine(self,cross,error):
+    def applgrid_combine(self,cross,error,jobs):
         """Combines the APPLgrids in all the SubProcess/P*/all_G*/ directories"""
         logger.debug('Combining APPLgrids \n')
         applcomb=pjoin(self.options['applgrid'].rstrip('applgrid-config'),
                                                             'applgrid-combine')
-        with open(pjoin(self.me_dir,'SubProcesses','dirs.txt')) as dirf:
-            all_jobs=dirf.readlines()
+        all_jobs=[]
+        for job in jobs:
+            all_jobs.append(job['dirname'])
         ngrids=len(all_jobs)
-        nobs  =len([name for name in os.listdir(pjoin(self.me_dir,'SubProcesses',
-                          all_jobs[0].rstrip())) if name.endswith("_out.root")])
+        nobs  =len([name for name in os.listdir(all_jobs[0]) if name.endswith("_out.root")])
         for obs in range(0,nobs):
-            gdir = [pjoin(self.me_dir,'SubProcesses',job.rstrip(),"grid_obs_"+
-                                     str(obs)+"_out.root") for job in all_jobs]
+            gdir = [pjoin(job,"grid_obs_"+str(obs)+"_out.root") for job in all_jobs]
             # combine APPLgrids from different channels for observable 'obs'
             if self.run_card["iappl"] == 1:
                 misc.call([applcomb,'-o', pjoin(self.me_dir,"Events",self.run_name,
@@ -1668,8 +1935,7 @@
                         self.run_name,"aMCfast_obs_"+str(obs)+".root"),'-s',
                                   str(unc2_inv),'--weight',str(unc2_inv)]+ gdir)
                 for job in all_jobs:
-                    os.remove(pjoin(self.me_dir,'SubProcesses',job.rstrip(),
-                                               "grid_obs_"+str(obs)+"_in.root"))
+                    os.remove(pjoin(job,"grid_obs_"+str(obs)+"_in.root"))
             else:
                 raise aMCatNLOError('iappl parameter can only be 0, 1 or 2')
             # after combining, delete the original grids
@@ -1710,14 +1976,10 @@
         if not hasattr(self, 'appl_start_grid') or not self.appl_start_grid:
             raise self.InvalidCmd('No APPLgrid name currently defined.'+
                                              'Please provide this information.')             
-        if mode == 'NLO':
-            gdir='all_G'
-        elif mode == 'LO':
-            gdir='born_G'
         #copy the grid to all relevant directories
         for pdir in p_dirs:
             g_dirs = [file for file in os.listdir(pjoin(self.me_dir,
-              "SubProcesses",pdir)) if file.startswith(gdir) and 
+                        "SubProcesses",pdir)) if file.startswith(mode+'_G') and 
                    os.path.isdir(pjoin(self.me_dir,"SubProcesses",pdir, file))]
             for g_dir in g_dirs:
                 for grid in all_grids:
@@ -1726,28 +1988,20 @@
                                                     'grid_obs_'+obs+'_in.root'))
 
 
-    def collect_log_files(self, folders, istep):
+
+
+    def collect_log_files(self, jobs, integration_step):
         """collect the log files and put them in a single, html-friendly file
-        inside the run_... directory"""
-        step_list = ['Grid setting', 'Cross-section computation', 
-                                                             'Event generation']
+        inside the Events/run_.../ directory"""
         log_file = pjoin(self.me_dir, 'Events', self.run_name, 
-                'alllogs_%d.html' % istep)
-        # this keeps track of which step has been computed for which channel
-        channel_dict = {}
-        log_files = []
-        for folder in folders:
-            log_files += glob.glob(pjoin(self.me_dir, 'SubProcesses', 'P*', 
-                                                             folder, 'log.txt'))
+                         'alllogs_%d.html' % integration_step)
+        outfile = open(log_file, 'w')
 
         content = ''
-
-        outfile = open(log_file, 'w')
-
         content += '<HTML><BODY>\n<font face="courier" size=2>'
-        for log in log_files:
-            channel_dict[os.path.dirname(log)] = [istep]
+        for job in jobs:
             # put an anchor
+            log=pjoin(job['dirname'],'log_MINT%s.txt' % integration_step)
             content += '<a name=%s></a>\n' % (os.path.dirname(log).replace(
                                           pjoin(self.me_dir,'SubProcesses'),''))
             # and put some nice header
@@ -1755,7 +2009,7 @@
             content += '<br>LOG file for integration channel %s, %s <br>' % \
                     (os.path.dirname(log).replace(pjoin(self.me_dir,
                                                            'SubProcesses'), ''), 
-                     step_list[istep])
+                     integration_step)
             content += '</font>\n'
             #then just flush the content of the small log inside the big log
             #the PRE tag prints everything verbatim
@@ -1768,53 +2022,78 @@
         outfile.close()
 
 
-    def read_results(self, output, mode):
-        """extract results (cross-section, absolute cross-section and errors)
-        from output, which should be formatted as
-            Found 4 correctly terminated jobs 
-            random seed found in 'randinit' is 33
-            Integrated abs(cross-section)
-            7.94473937e+03 +- 2.9953e+01  (3.7702e-01%)
-             Integrated cross-section
-            6.63392298e+03 +- 3.7669e+01  (5.6782e-01%)
-        for aMC@NLO/aMC@LO, and as
-
-        for NLO/LO
-        The cross_sect_dict is returned"""
-        res = {}
-        if mode in ['aMC@LO', 'aMC@NLO', 'noshower', 'noshowerLO']:
-            pat = re.compile(\
-'''Found (\d+) correctly terminated jobs 
-random seed found in 'randinit' is (\d+)
-Integrated abs\(cross-section\)
-\s*(\d+\.\d+e[+-]\d+) \+\- (\d+\.\d+e[+-]\d+)  \((\d+\.\d+e[+-]\d+)\%\)
-Integrated cross-section
-\s*(\-?\d+\.\d+e[+-]\d+) \+\- (\d+\.\d+e[+-]\d+)  \((\-?\d+\.\d+e[+-]\d+)\%\)''')
-        else:
-            pat = re.compile(\
-'''Found (\d+) correctly terminated jobs 
-\s*(\-?\d+\.\d+e[+-]\d+) \+\- (\d+\.\d+e[+-]\d+)  \((\-?\d+\.\d+e[+-]\d+)\%\)''')
-            pass
-
-        match = re.search(pat, output[0])
-        if not match or output[1]:
-            logger.info('Return code of the event collection: '+str(output[1]))
-            logger.info('Output of the event collection:\n'+output[0])
-            raise aMCatNLOError('An error occurred during the collection of results.\n' + 
-            'Please check the .log files inside the directories which failed.')
-#        if int(match.groups()[0]) != self.njobs:
-#            raise aMCatNLOError('Not all jobs terminated successfully')
-        if mode in ['aMC@LO', 'aMC@NLO', 'noshower', 'noshowerLO']:
-            return {'randinit' : int(match.groups()[1]),
-                    'xseca' : float(match.groups()[2]),
-                    'erra' : float(match.groups()[3]),
-                    'xsect' : float(match.groups()[5]),
-                    'errt' : float(match.groups()[6])}
-        else:
-            return {'xsect' : float(match.groups()[1]),
-                    'errt' : float(match.groups()[2])}
-
-    def print_summary(self, options, step, mode, scale_pdf_info={}):
+    def finalise_run_FO(self,folder_name,jobs):
+        """Combine the plots and put the res*.txt files in the Events/run.../ folder."""
+        # Copy the res_*.txt files to the Events/run* folder
+        res_files=glob.glob(pjoin(self.me_dir, 'SubProcesses', 'res_*.txt'))
+        for res_file in res_files:
+            files.mv(res_file,pjoin(self.me_dir, 'Events', self.run_name))
+        # Collect the plots and put them in the Events/run* folder
+        self.combine_plots_FO(folder_name,jobs)
+        # If doing the applgrid-stuff, also combine those grids
+        # and put those in the Events/run* folder
+        if self.run_card['iappl'] != 0:
+            self.applgrid_combine(cross,error)
+
+
+    def setup_cluster_or_multicore(self):
+        """setup the number of cores for multicore, and the cluster-type for cluster runs"""
+        if self.cluster_mode == 1:
+            cluster_name = self.options['cluster_type']
+            self.cluster = cluster.from_name[cluster_name](**self.options)
+        if self.cluster_mode == 2:
+            try:
+                import multiprocessing
+                if not self.nb_core:
+                    try:
+                        self.nb_core = int(self.options['nb_core'])
+                    except TypeError:
+                        self.nb_core = multiprocessing.cpu_count()
+                logger.info('Using %d cores' % self.nb_core)
+            except ImportError:
+                self.nb_core = 1
+                logger.warning('Impossible to detect the number of cores => Using One.\n'+
+                        'Use set nb_core X in order to set this number and be able to'+
+                        'run in multicore.')
+
+            self.cluster = cluster.MultiCore(**self.options)
+
+
+    def clean_previous_results(self,options,p_dirs,folder_name):
+        """Clean previous results.
+             o.  If doing only the reweighting step, do not delete anything and return directlty.
+             o.  Always remove all the G*_* files (from split event generation).
+             o.  Remove the G* (or born_G* or all_G*) only when NOT doing only_generation or reweight_only."""
+        if options['reweightonly']:
+            return
+        if not options['only_generation']:
+            self.update_status('Cleaning previous results', level=None)
+        for dir in p_dirs:
+            #find old folders to be removed
+            for obj in folder_name:
+                # list all the G* (or all_G* or born_G*) directories
+                to_rm = [file for file in \
+                             os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)) \
+                             if file.startswith(obj[:-1]) and \
+                            (os.path.isdir(pjoin(self.me_dir, 'SubProcesses', dir, file)) or \
+                             os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir, file)))] 
+                # list all the G*_* directories (from split event generation)
+                to_always_rm = [file for file in \
+                             os.listdir(pjoin(self.me_dir, 'SubProcesses', dir)) \
+                             if file.startswith(obj[:-1]) and
+                             '_' in file and not '_G' in file and \
+                            (os.path.isdir(pjoin(self.me_dir, 'SubProcesses', dir, file)) or \
+                             os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir, file)))]
+
+                if not options['only_generation']:
+                    to_always_rm.extend(to_rm)
+                    if os.path.exists(pjoin(self.me_dir, 'SubProcesses', dir,'MadLoop5_resources.tar.gz')):
+                        to_always_rm.append(pjoin(self.me_dir, 'SubProcesses', dir,'MadLoop5_resources.tar.gz'))
+                files.rm([pjoin(self.me_dir, 'SubProcesses', dir, d) for d in to_always_rm])
+        return
+
+
+    def print_summary(self, options, step, mode, scale_pdf_info={}, done=True):
         """print a summary of the results contained in self.cross_sect_dict.
         step corresponds to the mintMC step, if =2 (i.e. after event generation)
         some additional infos are printed"""
@@ -1833,17 +2112,16 @@
         if mode in ['aMC@NLO', 'aMC@LO', 'noshower', 'noshowerLO']: 
             log_GV_files =  glob.glob(pjoin(self.me_dir, \
                                     'SubProcesses', 'P*','G*','log_MINT*.txt'))
-            all_log_files = glob.glob(pjoin(self.me_dir, \
-                                          'SubProcesses', 'P*','G*','log*.txt'))
+            all_log_files = log_GV_files
         elif mode == 'NLO':
             log_GV_files =  glob.glob(pjoin(self.me_dir, \
-                                    'SubProcesses', 'P*','all_G*','log*.txt'))
-            all_log_files = sum([glob.glob(pjoin(self.me_dir,'SubProcesses', 'P*',
-              '%sG*'%foldName,'log*.txt')) for foldName in ['all_']],[])
+                                    'SubProcesses', 'P*','all_G*','log_MINT*.txt'))
+            all_log_files = log_GV_files
+
         elif mode == 'LO':
             log_GV_files = ''
-            all_log_files = sum([glob.glob(pjoin(self.me_dir,'SubProcesses', 'P*',
-              '%sG*'%foldName,'log*.txt')) for foldName in ['born_']],[])
+            all_log_files = glob.glob(pjoin(self.me_dir, \
+                                    'SubProcesses', 'P*','born_G*','log_MINT*.txt'))
         else:
             raise aMCatNLOError, 'Running mode %s not supported.'%mode
             
@@ -1886,18 +2164,22 @@
                          misc.format_timer(time.time()-self.start_time))
 
         elif mode in ['NLO', 'LO']:
-            status = ['Results after grid setup (cross-section is non-physical):',
+            status = ['Results after grid setup:','Current results:',
                       'Final results and run summary:']
-            if step == 0:
-                message = '\n      ' + status[step] + \
-                     '\n      Total cross-section:      %(xsect)8.3e +- %(errt)6.1e pb' % \
-                             self.cross_sect_dict
-            elif step == 1:
-                message = '\n      ' + status[step] + proc_info + \
+            if (not done) and (step == 0):
+                message = '\n      ' + status[0] + \
+                     '\n      Total cross-section:      %(xsect)8.3e +- %(errt)6.1e pb' % \
+                             self.cross_sect_dict
+            elif not done:
+                message = '\n      ' + status[1] + \
+                     '\n      Total cross-section:      %(xsect)8.3e +- %(errt)6.1e pb' % \
+                             self.cross_sect_dict
+            elif done:
+                message = '\n      ' + status[2] + proc_info + \
                      '\n      Total cross-section:      %(xsect)8.3e +- %(errt)6.1e pb' % \
                              self.cross_sect_dict
                 if self.run_card['reweight_scale']:
-                    if int(self.run_card['ickkw'])!=-1:
+                    if self.run_card['ickkw'] != -1:
                         message = message + \
                             ('\n      Ren. and fac. scale uncertainty: +%0.1f%% -%0.1f%%') % \
                             (scale_pdf_info['scale_upp'], scale_pdf_info['scale_low'])
@@ -1910,7 +2192,7 @@
                         ('\n      PDF uncertainty: +%0.1f%% -%0.1f%%') % \
                         (scale_pdf_info['pdf_upp'], scale_pdf_info['pdf_low'])
         
-        if (mode in ['NLO', 'LO'] and step!=1) or \
+        if (mode in ['NLO', 'LO'] and not done) or \
            (mode in ['aMC@NLO', 'aMC@LO', 'noshower', 'noshowerLO'] and step!=2):
             logger.info(message+'\n')
             return
@@ -2371,7 +2653,6 @@
         scale_pdf_info={}
         if self.run_card['reweight_scale'] or self.run_card['reweight_PDF'] :
             scale_pdf_info = self.run_reweight(options['reweightonly'])
-
         self.update_status('Collecting events', level='parton', update_results=True)
         misc.compile(['collect_events'], 
                     cwd=pjoin(self.me_dir, 'SubProcesses'))
@@ -2395,6 +2676,10 @@
         misc.gzip(pjoin(self.me_dir, 'SubProcesses', filename), stdout=evt_file)
         if not options['reweightonly']:
             self.print_summary(options, 2, mode, scale_pdf_info)
+            res_files=glob.glob(pjoin(self.me_dir, 'SubProcesses', 'res*.txt'))
+            for res_file in res_files:
+                files.mv(res_file,pjoin(self.me_dir, 'Events', self.run_name))
+
         logger.info('The %s file has been generated.\n' % (evt_file))
         self.results.add_detail('nb_event', nevents)
         self.update_status('Events generated', level='parton', update_results=True)
@@ -2415,9 +2700,9 @@
 
         #check that the number of split event files divides the number of
         # events, otherwise set it to 1
-        if int(int(self.banner.get_detail('run_card', 'nevents')) / \
+        if int(self.banner.get_detail('run_card', 'nevents') / \
                 self.shower_card['nsplit_jobs']) * self.shower_card['nsplit_jobs'] \
-                != int(self.banner.get_detail('run_card', 'nevents')):
+                != self.banner.get_detail('run_card', 'nevents'):
             logger.warning(\
                 'nsplit_jobs in the shower card is not a divisor of the number of events.\n' + \
                 'Setting it to 1.')
@@ -2425,7 +2710,7 @@
 
         # don't split jobs if the user asks to shower only a part of the events
         if self.shower_card['nevents'] > 0 and \
-           self.shower_card['nevents'] < int(self.banner.get_detail('run_card', 'nevents')) and \
+           self.shower_card['nevents'] < self.banner.get_detail('run_card', 'nevents') and \
            self.shower_card['nsplit_jobs'] != 1:
             logger.warning(\
                 'Only a part of the events will be showered.\n' + \
@@ -3011,8 +3296,8 @@
         init_dict = self.get_init_dict(evt_file)
 
         if nevents < 0 or \
-           nevents > int(self.banner.get_detail('run_card', 'nevents')):
-            nevents = int(self.banner.get_detail('run_card', 'nevents'))
+           nevents > self.banner.get_detail('run_card', 'nevents'):
+            nevents = self.banner.get_detail('run_card', 'nevents')
 
         nevents = nevents / self.shower_card['nsplit_jobs']
 
@@ -3024,7 +3309,7 @@
 
         content = 'EVPREFIX=%s\n' % pjoin(os.path.split(evt_file)[1])
         content += 'NEVENTS=%d\n' % nevents
-        content += 'NEVENTS_TOT=%d\n' % (int(self.banner.get_detail('run_card', 'nevents')) /\
+        content += 'NEVENTS_TOT=%d\n' % (self.banner.get_detail('run_card', 'nevents') /\
                                              self.shower_card['nsplit_jobs'])
         content += 'MCMODE=%s\n' % shower
         content += 'PDLABEL=%s\n' % pdlabel
@@ -3137,7 +3422,7 @@
 
 
     def run_reweight(self, only):
-        """runs the reweight_xsec_events eecutables on each sub-event file generated
+        """runs the reweight_xsec_events executables on each sub-event file generated
         to compute on the fly scale and/or PDF uncertainities"""
         logger.info('   Doing reweight')
 
@@ -3255,7 +3540,7 @@
                 scale_pdf_info['scale_low'] = 0.0
 
         # get the pdf uncertainty in percent (according to the Hessian method)
-        lhaid=int(self.run_card['lhaid'])
+        lhaid=self.run_card['lhaid']
         pdf_upp=0.0
         pdf_low=0.0
         if lhaid <= 90000:
@@ -3270,7 +3555,6 @@
                 else:
                     scale_pdf_info['pdf_upp'] = 0.0
                     scale_pdf_info['pdf_low'] = 0.0
-
         else:
             # use Gaussian method (NNPDF)
             pdf_stdev=0.0
@@ -3287,7 +3571,6 @@
 
     def wait_for_complete(self, run_type):
         """this function waits for jobs on cluster to complete their run."""
-
         starttime = time.time()
         #logger.info('     Waiting for submitted jobs to complete')
         update_status = lambda i, r, f: self.update_status((i, r, f, run_type), 
@@ -3300,29 +3583,15 @@
 
     def run_all(self, job_dict, arg_list, run_type='monitor', split_jobs = False):
         """runs the jobs in job_dict (organized as folder: [job_list]), with arguments args"""
-        njob_split = 0
         self.ijob = 0
-
-        #  this is to keep track, if splitting evt generation, of the various 
-        # folders/args in order to resubmit the jobs if some of them fail
-        self.split_folders = {}
-
         if run_type != 'shower':
             self.njobs = sum(len(jobs) for jobs in job_dict.values()) * len(arg_list)
             for args in arg_list:
                 for Pdir, jobs in job_dict.items():
                     for job in jobs:
-                        if not split_jobs:
-                            self.run_exe(job, args, run_type, cwd=pjoin(self.me_dir, 'SubProcesses', Pdir) )
-                        else:
-                            for n in self.find_jobs_to_split(Pdir, job, args[1]):
-                                self.run_exe(job, args + [n], run_type, cwd=pjoin(self.me_dir, 'SubProcesses', Pdir) )
-                                njob_split += 1
-                        # print some statistics if running serially
+                        self.run_exe(job, args, run_type, cwd=pjoin(self.me_dir, 'SubProcesses', Pdir) )
             if self.cluster_mode == 2:
                 time.sleep(1) # security to allow all jobs to be launched
-            if njob_split > 0:
-                self.njobs = njob_split
         else:
             self.njobs = len(arg_list)
             for args in arg_list:
@@ -3333,37 +3602,27 @@
 
 
 
-    def check_event_files(self):
+    def check_event_files(self,jobs):
         """check the integrity of the event files after splitting, and resubmit 
         those which are not nicely terminated"""
-        to_resubmit = []
-        for dir in self.split_folders.keys():
+        jobs_to_resubmit = []
+        for job in jobs:
             last_line = ''
             try:
                 last_line = subprocess.Popen(
-                        ['tail', '-n1', pjoin(dir, 'events.lhe')], \
+                        ['tail', '-n1', pjoin(job['dirname'], 'events.lhe')], \
                     stdout = subprocess.PIPE).stdout.read().strip()
             except IOError:
                 pass
-
             if last_line != "</LesHouchesEvents>":
-                to_resubmit.append(dir)
-
+                jobs_to_resubmit.append(job)
         self.njobs = 0
-        if to_resubmit:
+        if jobs_to_resubmit:
             run_type = 'Resubmitting broken jobs'
             logger.info('Some event files are broken, corresponding jobs will be resubmitted.')
-            logger.debug('Resubmitting\n' + '\n'.join(to_resubmit) + '\n')
-            for dir in to_resubmit:
-                files.rm([dir])
-                job = self.split_folders[dir][0]
-                args = self.split_folders[dir][1:]
-                run_type = 'monitor'
-                cwd = os.path.split(dir)[0]
-                self.run_exe(job, args, run_type, cwd=cwd )
-                self.njobs +=1
-
-            self.wait_for_complete(run_type)
+            for job in jobs_to_resubmit:
+                logger.debug('Resubmitting ' + job['dirname'] + '\n')
+            self.run_all_jobs(jobs_to_resubmit,2,fixed_order=False)
 
 
     def find_jobs_to_split(self, pdir, job, arg):
@@ -3436,16 +3695,16 @@
             # the 'standard' amcatnlo job
             # check if args is a list of string 
             if type(args[0]) == str:
-                input_files, output_files, required_output, args = self.getIO_ajob(exe,cwd, args)
+                input_files, output_files, required_output, args = self.getIO_ajob(exe,cwd,args)
                 #submitting
                 self.cluster.submit2(exe, args, cwd=cwd, 
                              input_files=input_files, output_files=output_files,
                              required_output=required_output)
 
-                # keep track of folders and arguments for splitted evt gen
-                subfolder=output_files[-1].split('/')[0]
-                if len(args) == 4 and '_' in subfolder:
-                    self.split_folders[pjoin(cwd,subfolder)] = [exe] + args
+#                # keep track of folders and arguments for splitted evt gen
+#                subfolder=output_files[-1].split('/')[0]
+#                if len(args) == 4 and '_' in subfolder:
+#                    self.split_folders[pjoin(cwd,subfolder)] = [exe] + args
 
         elif 'shower' in exe:
             # a shower job
@@ -3511,7 +3770,6 @@
         # use local disk if possible => need to stands what are the 
         # input/output files
         
-        keep_fourth_arg = False
         output_files = []
         required_output = []
         input_files = [pjoin(self.me_dir, 'SubProcesses', 'randinit'),
@@ -3536,84 +3794,48 @@
                                                            dereference=True)
             tf.add(pjoin(cwd,'MadLoop5_resources'),arcname='MadLoop5_resources')
             tf.close()
-
-        Ire = re.compile("for i in ([\d\s]*) ; do")
-        try : 
-            fsock = open(exe)
-        except IOError:
-            fsock = open(pjoin(cwd,exe))
-        text = fsock.read()
-        data = Ire.findall(text)
-        subdir = ' '.join(data).split()
                
-        if args[0] == '0':
+        if args[1] == 'born' or args[1] == 'all':
             # MADEVENT MINT FO MODE
             input_files.append(pjoin(cwd, 'madevent_mintFO'))
-            input_files.append(pjoin(self.me_dir, 'SubProcesses','madin.%s' % args[1]))
-            #j=$2\_G$i
-            for i in subdir:
-                current = '%s_G%s' % (args[1],i)
-                if os.path.exists(pjoin(cwd,current)):
-                    input_files.append(pjoin(cwd, current))
-                output_files.append(current)
+            if args[2] == '0':
+                current = '%s_G%s' % (args[1],args[0])
+            else:
+                current = '%s_G%s_%s' % (args[1],args[0],args[2])
+            if os.path.exists(pjoin(cwd,current)):
+                input_files.append(pjoin(cwd, current))
+            output_files.append(current)
 
-                required_output.append('%s/results.dat' % current)
-                required_output.append('%s/log.txt' % current)
-                required_output.append('%s/mint_grids' % current)
-                required_output.append('%s/grid.MC_integer' % current)
-                if len(args) == 4:
-                    required_output.append('%s/scale_pdf_dependence.dat' % current)
-                    args[2] = '-1'
-                    # use a grid train on another part
-                    base = '%s_G%s' % (args[3],i)
-                    if args[0] == '0':
-                        to_move = ['grid.MC_integer','mint_grids']
-                    elif args[0] == '1':
-                        to_move = ['mint_grids', 'grid.MC_integer']
-                    else: 
-                        to_move  = []
-                    if self.run_card['iappl'] == 2:
-                        for grid in glob.glob(pjoin(cwd,base,'grid_obs_*_in.root')):
-                            to_move.append(grid)
-                    if not os.path.exists(pjoin(cwd,current)):
-                        os.mkdir(pjoin(cwd,current))
-                        input_files.append(pjoin(cwd, current))
-                    for name in to_move:
-                        files.cp(pjoin(cwd,base, name), 
-                                        pjoin(cwd,current))
-                    files.cp(pjoin(cwd,base, 'grid.MC_integer'), 
-                                        pjoin(cwd,current))
+            required_output.append('%s/results.dat' % current)
+            required_output.append('%s/res_%s.dat' % (current,args[3]))
+            required_output.append('%s/log_MINT%s.txt' % (current,args[3]))
+            required_output.append('%s/mint_grids' % current)
+            required_output.append('%s/grid.MC_integer' % current)
+            if args[3] != '0':
+                required_output.append('%s/scale_pdf_dependence.dat' % current)
                             
-        elif args[0] == '2':
+        elif args[1] == 'F' or args[1] == 'B':
             # MINTMC MODE
             input_files.append(pjoin(cwd, 'madevent_mintMC'))
-            if args[2] in ['0','2']:
-                input_files.append(pjoin(self.me_dir, 'SubProcesses','madinMMC_%s.2' % args[1]))
-
-            for i in subdir:
-                current = 'G%s%s' % (args[1], i)
-                if os.path.exists(pjoin(cwd,current)):
-                    input_files.append(pjoin(cwd, current))
-                output_files.append(current)
-                if len(args) == 4 and args[3] in ['H','S','V','B','F']:
-                    # use a grid train on another part
-                    base = '%s_%s' % (args[3],i)
-                    files.ln(pjoin(cwd,base,'mint_grids'), name = 'preset_mint_grids', 
-                                            starting_dir=pjoin(cwd,current))
-                    files.ln(pjoin(cwd,base,'grid.MC_integer'), 
-                                          starting_dir=pjoin(cwd,current))
-                elif len(args) ==4:
-                    keep_fourth_arg = True
-                    # this is for the split event generation
-                    output_files.append('G%s%s_%s' % (args[1], i, args[3]))
-                    required_output.append('G%s%s_%s/log_MINT%s.txt' % (args[1], i, args[3],args[2]))
-
-                else:
-                    required_output.append('%s/log_MINT%s.txt' % (current,args[2]))
-                if args[2] in ['0','1']:
-                    required_output.append('%s/results.dat' % current)
-                if args[2] == '1':
-                    output_files.append('%s/results.dat' % current)
+
+            if args[2] == '0':
+                current = 'G%s%s' % (args[1],args[0])
+            else:
+                current = 'G%s%s_%s' % (args[1],args[0],args[2])
+            if os.path.exists(pjoin(cwd,current)):
+                input_files.append(pjoin(cwd, current))
+            output_files.append(current)
+            if args[2] > '0':
+                # this is for the split event generation
+                output_files.append('G%s%s_%s' % (args[1], args[0], args[2]))
+                required_output.append('G%s%s_%s/log_MINT%s.txt' % (args[1],args[0],args[2],args[3]))
+
+            else:
+                required_output.append('%s/log_MINT%s.txt' % (current,args[3]))
+            if args[3] in ['0','1']:
+                required_output.append('%s/results.dat' % current)
+            if args[3] == '1':
+                output_files.append('%s/results.dat' % current)
 
         else:
             raise aMCatNLOError, 'not valid arguments: %s' %(', '.join(args))
@@ -3621,73 +3843,9 @@
         #Find the correct PDF input file
         pdfinput = self.get_pdf_input_filename()
         if os.path.exists(pdfinput):
-            input_files.append(pdfinput)
-
-        if len(args) == 4 and not keep_fourth_arg:
-            args = args[:3]
-            
+            input_files.append(pdfinput)            
         return input_files, output_files, required_output,  args
-            
-    def write_madinMMC_file(self, path, run_mode, mint_mode):
-        """writes the madinMMC_?.2 file"""
-        #check the validity of the arguments
-        run_modes = ['born', 'virt', 'novi', 'all', 'viSB', 'novB']
-        if run_mode not in run_modes:
-            raise aMCatNLOError('%s is not a valid mode for run. Please use one of the following: %s' \
-                    % (run_mode, ', '.join(run_modes)))
-        mint_modes = [0, 1, 2]
-        if mint_mode not in mint_modes:
-            raise aMCatNLOError('%s is not a valid mode for mintMC. Please use one of the following: %s' \
-                    % (mint_mode, ', '.join(mint_modes)))
-        if run_mode in ['born']:
-            name_suffix = 'B'
-        elif run_mode in ['virt', 'viSB']:
-            name_suffix = 'V'
-        else:
-            name_suffix = 'F'
-
-        content = \
-"""-1 12      ! points, iterations
-0.03       ! desired fractional accuracy
-1 -0.1     ! alpha, beta for Gsoft
--1 -0.1    ! alpha, beta for Gazi
-1          ! Suppress amplitude (0 no, 1 yes)?
-1          ! Exact helicity sum (0 yes, n = number/event)?
-1          ! Enter Configuration Number:
-%1d          ! MINT imode: 0 to set-up grids, 1 to perform integral, 2 generate events
-1 1 1      ! if imode is 1: Folding parameters for xi_i, phi_i and y_ij
-%s        ! all, born, real, virt
-""" \
-                    % (mint_mode, run_mode)
-        file = open(pjoin(path, 'madinMMC_%s.2' % name_suffix), 'w')
-        file.write(content)
-        file.close()
-
-    def write_madin_file(self, path, run_mode, vegas_mode, npoints, niters, accuracy='0'):
-        """writes the madin.run_mode file"""
-        #check the validity of the arguments
-        run_modes = ['born', 'virt', 'novi', 'all', 'viSB', 'novB', 'grid']
-        if run_mode not in run_modes:
-            raise aMCatNLOError('%s is not a valid mode for run. Please use one of the following: %s' \
-                    % (run_mode, ', '.join(run_modes)))
-        name_suffix = run_mode
-
-        content = \
-"""%s %s  ! points, iterations
-%s ! accuracy
-2 ! 0 fixed grid 2 adjust
-1 ! 1 suppress amp, 0 doesnt
-1 ! 0 for exact hel sum
-1 ! hel configuration numb
-'test'
-1 ! 1 to save grids
-%s ! 0 to exclude, 1 for new run, 2 to restart, 3 to reset w/ keeping grid
-%s        ! all, born, real, virt
-""" \
-                    % (npoints,niters,accuracy,vegas_mode,run_mode)
-        file = open(pjoin(path, 'madin.%s' % name_suffix), 'w')
-        file.write(content)
-        file.close()
+
 
     def compile(self, mode, options):
         """compiles aMC@NLO to compute either NLO or NLO matched to shower, as
@@ -3750,10 +3908,10 @@
 
             self.link_lhapdf(libdir, [pjoin('SubProcesses', p) for p in p_dirs])
             pdfsetsdir = self.get_lhapdf_pdfsetsdir()
-            lhaid_list = [int(self.run_card['lhaid'])]
+            lhaid_list = [self.run_card['lhaid']]
             if self.run_card['reweight_PDF']:
-                lhaid_list.append(int(self.run_card['PDF_set_min']))
-                lhaid_list.append(int(self.run_card['PDF_set_max']))
+                lhaid_list.append(self.run_card['PDF_set_min'])
+                lhaid_list.append(self.run_card['PDF_set_max'])
             self.copy_lhapdf_set(lhaid_list, pdfsetsdir)
 
         else:
@@ -4292,9 +4450,9 @@
                     if mode in ['LO','aMC@LO','noshowerLO']:
                         self.run_name += '_LO' 
             self.set_run_name(self.run_name, self.run_tag, 'parton')
-            if int(self.run_card['ickkw']) == 3 and mode in ['LO', 'aMC@LO', 'noshowerLO']:
+            if self.run_card['ickkw'] == 3 and mode in ['LO', 'aMC@LO', 'noshowerLO']:
                 raise self.InvalidCmd("""FxFx merging (ickkw=3) not allowed at LO""")
-            elif int(self.run_card['ickkw']) == 3 and mode in ['aMC@NLO', 'noshower']:
+            elif self.run_card['ickkw'] == 3 and mode in ['aMC@NLO', 'noshower']:
                 logger.warning("""You are running with FxFx merging enabled.  To be able to merge
     samples of various multiplicities without double counting, you
     have to remove some events after showering 'by hand'.  Please
@@ -4310,7 +4468,7 @@
                         error = '''Stop opertation'''
                         self.ask_run_configuration(mode, options)
     #                    raise aMCatNLOError(error)
-            elif int(self.run_card['ickkw']) == -1 and mode in ['aMC@NLO', 'noshower']:
+            elif self.run_card['ickkw'] == -1 and mode in ['aMC@NLO', 'noshower']:
                     # NNLL+NLO jet-veto only possible for LO event generation or fNLO runs.
                 raise self.InvalidCmd("""NNLL+NLO jet veto runs (ickkw=-1) only possible for fNLO or LO.""")
         if 'aMC@' in mode or mode == 'onlyshower':