~maddevelopers/mg5amcnlo/ResummationPlugin

« back to all changes in this revision

Viewing changes to Resummation/resummation_runner.py

  • Committer: marco zaro
  • Date: 2018-12-10 11:10:47 UTC
  • Revision ID: marco.zaro@gmail.com-20181210111047-yg8ckvwtukdp7rw1
much more efficient memory usage when resummed events are collected

Show diffs side-by-side

added added

removed removed

Lines of Context:
253
253
                  raise Exception, ' '.join(linelist)
254
254
               if linelist[0]=="EVENT": 
255
255
                     i=int(linelist[1])
256
 
                     self.job_results[i-1]={}
257
 
                     self.job_results[i-1]["LOG"]=""
 
256
                     self.job_results.append({})
 
257
                     self.job_results[-1]["nevent"] = i
 
258
                     self.job_results[-1]["LOG"]=""
258
259
 
259
 
                     for res in to_retrieve_muf: self.job_results[i-1][res]=[0]*nb_muf_scales
260
 
                     for res in to_retrieve_allscales: self.job_results[i-1][res]=[0]*nb_set_scales
 
260
                     for res in to_retrieve_muf: self.job_results[-1][res]=[0]*nb_muf_scales
 
261
                     for res in to_retrieve_allscales: self.job_results[-1][res]=[0]*nb_set_scales
261
262
 
262
263
               else:
263
 
                     self.job_results[i-1]["LOG"]+=line+"\n"
 
264
                     self.job_results[-1]["LOG"]+=line+"\n"
264
265
 
265
266
                     if linelist[0] in to_retrieve_muf:
266
267
                        index=int(linelist[2])-1 
267
 
                        self.job_results[i-1][linelist[0]][index]=float(linelist[1])
 
268
                        self.job_results[-1][linelist[0]][index]=float(linelist[1])
268
269
 
269
270
                     elif linelist[0] in to_retrieve_allscales:
270
271
                        index=int(linelist[3])-1 
271
 
                        self.job_results[i-1][linelist[0]][index]=float(linelist[1])
 
272
                        self.job_results[-1][linelist[0]][index]=float(linelist[1])
272
273
           
273
274
        #print self.job_results[0]         
274
275
        trappe.close()
275
276
        return 1
276
277
 
277
278
 
278
 
    def write_resummed_weight(self,filename='resummed_events.lhe'):
 
279
    def collect_and_write_resummed_weight(self,filename='resummed_events.lhe'):
279
280
        """write resummed event file"""
280
281
 
281
282
        logger.info(' ' )
283
284
        self.outputfile = open(pjoin(self.path_me,filename), 'w')
284
285
        self.banner.write(self.outputfile, close_tag=False) 
285
286
 
286
 
 
287
287
        if self.checks:
288
 
           logfile = open(pjoin(self.path_me,'logfile'), 'w')
 
288
          logfile = open(pjoin(self.path_me,'logfile'), 'w')
289
289
        
290
290
        event_nb, fail_nb = 0, 0
291
291
        nb_skip = 0 
296
296
 
297
297
        nb_scale_muf=len(self.mufrescale)
298
298
        nb_scale_sets=len(self.scalechoices)
299
 
        while 1: # loop on event file
300
 
 
301
 
            try:
302
 
                self.curr_event = self.evtfile.next()
303
 
            except StopIteration: 
304
 
                break
305
 
 
306
 
            weightLO=self.curr_event.wgt
307
 
            tot_old_weight+=weightLO
308
 
            event_nb+=1
309
 
            if  event_nb and \
310
 
                (event_nb % max(int(10**int(math.log10(float(event_nb)))),1000)==0): 
311
 
                logger.info('Event nb %s ' % event_nb)
312
 
            if (event_nb==10001): logger.info('reducing number of print status. Next status update in 10000 events')
313
 
 
314
 
            if self.checks:
315
 
               logfile.write("\n ")
316
 
               logfile.write("Production event %s \n" % event_nb)
317
 
               #logfile.write("Inputs: \n")
318
 
               #for line in stdin_text:
319
 
               #    logfile.write(line)
320
 
               logfile.write("Outputs: \n")
321
 
               logfile.write(self.job_results[event_nb-1]["LOG"])
322
 
 
323
 
 
324
 
 
325
 
            weights0=[0]*nb_scale_muf
326
 
            self.curr_event.parse_reweight()
327
 
            for scale in self.mufrescale:
328
 
                scale_id = scale[0]
329
 
                scale_index = scale[1]
330
 
                weights0[scale_index-1] = self.curr_event.reweight_data[str(scale_id)]
331
 
 
332
 
            # Here we can reset reweight_data
333
 
            self.curr_event.reweight_data = {}
334
 
 
335
 
            for scaleset in self.scalechoices:
336
 
                index_muf=scaleset[0]
337
 
                index_set=scaleset[1]
338
 
                muf=scaleset[2]
339
 
                muh=scaleset[3]
340
 
                mus=scaleset[4]
341
 
                currweightLO=weights0[index_muf-1]
342
 
                MEweight1=self.job_results[event_nb-1]["RESUMMED_WEIGHT"][index_set-1]
343
 
                MEweight0=self.job_results[event_nb-1]["LO_WEIGHT"][index_muf-1]
344
 
 
345
 
                self.curr_event.reweight_data[str(index_set)] = currweightLO*MEweight1/MEweight0
346
 
 
347
 
            for scale in self.mufrescale:
348
 
                index_muf=scale[1]
349
 
                muf=scale[2]
350
 
                currweightLO=weights0[index_muf-1]
351
 
                MEweight0=self.job_results[event_nb-1]["LO_WEIGHT"][index_muf-1]
352
 
                EXPANDED=self.job_results[event_nb-1]["EXPANDED_WEIGHT"][index_muf-1]
353
 
 
354
 
                self.curr_event.reweight_data[str(2*index_muf-1+nb_scale_sets)] = currweightLO
355
 
                self.curr_event.reweight_data[str(2*index_muf+nb_scale_sets)] = currweightLO*EXPANDED/MEweight0
356
 
                self.curr_event.reweight_data = collections.OrderedDict(sorted(self.curr_event.reweight_data.items()))
357
 
 
358
 
            self.outputfile.write(str(self.curr_event))
 
299
 
 
300
        # start looping on the jobs
 
301
        # events in the event file are randomized by initial state
 
302
        # however, the order in the various jobs should follow
 
303
        # the order in the event file
 
304
        ievt_old = 0
 
305
        ndone = 0
 
306
        ndone_job=0
 
307
        for path in self.jobs:
 
308
            logger.info("Directory : %s " % path)
 
309
            for job_index in range(self.jobs[path]["job_index"]+1):
 
310
                print 'new job', job_index , self.jobs[path]["job_index"]+1, ' previous',ndone_job
 
311
                ndone_job=0
 
312
                file_name=pjoin(path,"job_%s_out" % job_index)
 
313
                self.job_results = []
 
314
                succeed=self.read_output(file_name)
 
315
 
 
316
 
 
317
 
 
318
 
 
319
                for job in self.job_results:
 
320
                    ndone_job+=1
 
321
                    ievt_new = job['nevent']
 
322
                    if ievt_new < ievt_old:
 
323
                        print 'restarting'
 
324
                        ievt_old = 0
 
325
                        self.evtfile.seek(0)
 
326
                    # read up to event # ievt_new
 
327
                    for i in range(ievt_new - ievt_old):
 
328
                        self.curr_event = self.evtfile.next()
 
329
                                #try:
 
330
                                #self.curr_event = self.evtfile.next()
 
331
                                #            except StopIteration:
 
332
                                #                                break
 
333
                    ievt_old = ievt_new
 
334
 
 
335
                    ndone+= 1
 
336
 
 
337
                    ###if self.curr_event.get_next_event() == 'no_event': break
 
338
                    weightLO=self.curr_event.wgt
 
339
                    tot_old_weight+=weightLO
 
340
                    event_nb+=1
 
341
                    if  event_nb and \
 
342
                        (event_nb % max(int(10**int(math.log10(float(event_nb)))),1000)==0): 
 
343
                        logger.info('Event nb %s ' % event_nb)
 
344
                    if (event_nb==10001): logger.info('reducing number of print status. Next status update in 10000 events')
 
345
 
 
346
                    if self.checks:
 
347
                       logfile.write("\n ")
 
348
                       logfile.write("Production event %s \n" % event_nb)
 
349
                       #logfile.write("Inputs: \n")
 
350
                       #for line in stdin_text:
 
351
                       #    logfile.write(line)
 
352
                       logfile.write("Outputs: \n")
 
353
                       logfile.write(self.job_results[-1]["LOG"])
 
354
 
 
355
                    weights0=[0]*nb_scale_muf
 
356
                    self.curr_event.parse_reweight()
 
357
                    for scale in self.mufrescale:
 
358
                        scale_id = scale[0]
 
359
                        scale_index = scale[1]
 
360
                        weights0[scale_index-1] = self.curr_event.reweight_data[str(scale_id)]
 
361
 
 
362
                    # Here we can reset reweight_data
 
363
                    self.curr_event.reweight_data = {}
 
364
 
 
365
                    for scaleset in self.scalechoices:
 
366
                        index_muf=scaleset[0]
 
367
                        index_set=scaleset[1]
 
368
                        muf=scaleset[2]
 
369
                        muh=scaleset[3]
 
370
                        mus=scaleset[4]
 
371
                        currweightLO=weights0[index_muf-1]
 
372
                        MEweight1=self.job_results[-1]["RESUMMED_WEIGHT"][index_set-1]
 
373
                        MEweight0=self.job_results[-1]["LO_WEIGHT"][index_muf-1]
 
374
 
 
375
                        self.curr_event.reweight_data[str(index_set)] = currweightLO*MEweight1/MEweight0
 
376
 
 
377
                    for scale in self.mufrescale:
 
378
                        index_muf=scale[1]
 
379
                        muf=scale[2]
 
380
                        currweightLO=weights0[index_muf-1]
 
381
                        MEweight0=self.job_results[-1]["LO_WEIGHT"][index_muf-1]
 
382
                        EXPANDED=self.job_results[-1]["EXPANDED_WEIGHT"][index_muf-1]
 
383
 
 
384
                        self.curr_event.reweight_data[str(2*index_muf-1+nb_scale_sets)] = currweightLO
 
385
                        self.curr_event.reweight_data[str(2*index_muf+nb_scale_sets)] = currweightLO*EXPANDED/MEweight0
 
386
                        self.curr_event.reweight_data = collections.OrderedDict(sorted(self.curr_event.reweight_data.items()))
 
387
 
 
388
                    self.outputfile.write(str(self.curr_event))
359
389
            
360
390
        self.outputfile.write('</LesHouchesEvents>\n')
361
391
        self.evtfile.close()
802
832
                  logfile.write("HARD SCALE = %s \n" % hs)
803
833
                  logfile.write("SOFT SCALE = %s \n" % ss)
804
834
               else:             
805
 
                  logfile.write(self.job_results[event_nb-1]["LOG"])
 
835
                  logfile.write(self.job_results[-1]["LOG"])
806
836
 
807
837
            if (ss=="unknown"): logger.warning("Cannot read soft scale from fortran exe ") 
808
838
            if (hs=="unknown"): logger.warning("Cannot read hard scale from fortran exe ")