← Back to branch summary

~maddevelopers/mg5amcnlo/2.6.6_bug_1813292

« back to all changes in this revision

Viewing changes to madgraph/iolibs/ufo_expression_parsers.py

  • Committer: olivier-mattelaer
  • Date: 2017-05-26 07:48:55 UTC
  • mfrom: (271.1.33 2.5.5)
  • Revision ID: olivier-mattelaer-20170526074855-r463wfxlom110fiu
pass the 2.5.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
madgraph/iolibs/ufo_expression_parsers.py
58
58
        
59
59
    def parse(self, buf):
60
60
        """Parse the string buf"""
 
61
        self.clean()
61
62
        self.y.parse(buf)
62
63
        return self.parsed_string
63
64
 
163
164
        logger.error("Illegal character '%s'" % t.value[0])
164
165
        t.lexer.skip(1)
165
166
 
 
167
    def clean(self):
 
168
        """remove variable related to the latest parsing"""
 
169
        #nothing to do here
 
170
        return
 
171
        
 
172
 
166
173
    # Build the lexer
167
174
    def build(self,**kwargs):
168
175
        self.lexer = lex.lex(module=self, **kwargs)
268
275
    """A parser for UFO algebraic expressions, outputting
269
276
    Fortran-style code."""
270
277
 
 
278
 
 
279
 
271
280
    # The following parser expressions need to be defined for each
272
281
    # output language/framework
273
282
    
280
289
                     'or':'.OR.',
281
290
                     'and':'.AND.'}
282
291
 
 
292
    def __init__(self, *args, **opts):
 
293
        """ """
 
294
        out = super(UFOExpressionParserFortran,self).__init__(*args, **opts)
 
295
        self.to_define = set()
 
296
        
 
297
    def clean(self):
 
298
        """remove information about object parse for previous parsing
 
299
        """
 
300
        self.to_define = set()
 
301
        
 
302
        
 
303
 
 
304
 
283
305
    def p_expression_number(self, p):
284
306
        "expression : NUMBER"
285
307
        if p[1].endswith('j'):
307
329
    def p_expression_if(self,p):
308
330
        "expression :   expression IF boolexpression ELSE expression "
309
331
        p[0] = 'CONDIF(%s,DCMPLX(%s),DCMPLX(%s))' % (p[3], p[1], p[5])
 
332
        self.to_define.add('condif')
310
333
            
311
334
    def p_expression_ifimplicit(self,p):
312
335
        "expression :   expression IF expression ELSE expression "
313
336
        p[0] = 'CONDIF(DCMPLX(%s).NE.(0d0,0d0),DCMPLX(%s),DCMPLX(%s))'\
314
337
                                                             %(p[3], p[1], p[5])
 
338
        self.to_define.add('condif')
315
339
 
316
340
    def p_expression_cond(self, p):
317
341
        "expression :  COND '(' expression ',' expression ',' expression ')'"
318
342
        p[0] = 'COND(DCMPLX('+p[3]+'),DCMPLX('+p[5]+'),DCMPLX('+p[7]+'))'
 
343
        self.to_define.add('cond')
319
344
 
320
345
    def p_expression_recms(self, p):
321
346
        "expression : RECMS '(' boolexpression ',' expression ')'"
322
347
        p[0] = 'RECMS('+p[3]+',DCMPLX('+p[5]+'))'
 
348
        self.to_define.add('recms')
323
349
 
324
350
    def p_expression_complex(self, p):
325
351
        "expression : COMPLEX '(' expression ',' expression ')'"
356
382
        elif p[1] == 'reglogp': p[0] = 'reglogp(DCMPLX' + p[2] + ')'
357
383
        elif p[1] == 'reglogm': p[0] = 'reglogm(DCMPLX' + p[2] + ')'
358
384
 
 
385
        if p[1] in ['reglog', 'reglogp', 'reglogm']:
 
386
            self.to_define.add(p[1])
359
387
 
360
388
    def p_expression_real(self, p):
361
389
        ''' expression : expression RE2 '''
374
402
    def p_expression_pi(self, p):
375
403
        '''expression : PI'''
376
404
        p[0] = 'pi'
 
405
        self.to_define.add('pi')
377
406
 
378
407
class UFOExpressionParserMPFortran(UFOExpressionParserFortran):
379
408
    """A parser for UFO algebraic expressions, outputting
413
442
    def p_expression_if(self,p):
414
443
        "expression :   expression IF boolexpression ELSE expression "
415
444
        p[0] = 'MP_CONDIF(%s,CMPLX(%s,KIND=16),CMPLX(%s,KIND=16))' % (p[3], p[1], p[5])
416
 
            
 
445
        self.to_define.add('mp_condif')
 
446
        
417
447
    def p_expression_ifimplicit(self,p):
418
448
        "expression :   expression IF expression ELSE expression "
419
449
        p[0] = 'MP_CONDIF(CMPLX(%s,KIND=16).NE.(0.0e0_16,0.0e0_16),CMPLX(%s,KIND=16),CMPLX(%s,KIND=16))'\
420
450
                                                             %(p[3], p[1], p[5])
421
 
 
 
451
        self.to_define.add('mp_condif')
 
452
        
422
453
    def p_expression_complex(self, p):
423
454
        "expression : COMPLEX '(' expression ',' expression ')'"
424
455
        p[0] = 'CMPLX(' + p[3] + ',' + p[5] + ',KIND=16)'
427
458
        "expression :  COND '(' expression ',' expression ',' expression ')'"
428
459
        p[0] = 'MP_COND(CMPLX('+p[3]+',KIND=16),CMPLX('+p[5]+\
429
460
                                          ',KIND=16),CMPLX('+p[7]+',KIND=16))'
 
461
        self.to_define.add('mp_cond')
430
462
 
431
463
    def p_expression_recms(self, p):
432
464
        "expression : RECMS '(' boolexpression ',' expression ')'"
433
465
        p[0] = 'MP_RECMS('+p[3]+',CMPLX('+p[5]+',KIND=16))'
 
466
        self.to_define.add('mp_recms')
434
467
 
435
468
    def p_expression_func(self, p):
436
469
        '''expression : CSC group
463
496
        elif p[1] == 'reglogp': p[0] = 'mp_reglogp(CMPLX(' + p[2] + ',KIND=16))'
464
497
        elif p[1] == 'reglogm': p[0] = 'mp_reglogm(CMPLX(' + p[2] + ',KIND=16))'
465
498
 
 
499
        if p[1] in ['reglog', 'reglogp', 'reglogm']:
 
500
            self.to_define.add(p[1])
 
501
            
466
502
    def p_expression_real(self, p):
467
503
        ''' expression : expression RE2 '''
468
504
        
481
517
    def p_expression_pi(self, p):
482
518
        '''expression : PI'''
483
519
        p[0] = self.mp_prefix+'pi'
484
 
 
 
520
        self.to_define.add(self.mp_prefix+'pi')
 
521
        
485
522
class UFOExpressionParserCPP(UFOExpressionParser):
486
523
    """A parser for UFO algebraic expressions, outputting
487
524
    C++-style code."""