← Back to branch summary

~madteam/mg5amcnlo/series2.0

« back to all changes in this revision

Viewing changes to madgraph/core/base_objects.py

  • Committer: olivier-mattelaer
  • Date: 2020-08-21 09:16:56 UTC
  • mfrom: (284.2.24 python3)
  • Revision ID: olivier-mattelaer-20200821091656-iizux2mj94tkssuo
pass to 2.8.0 (and move to python3 branch)

Show diffs side-by-side

added added

removed removed

Lines of Context:
madgraph/core/base_objects.py
15
15
"""Definitions of all basic objects used in the core code: particle, 
16
16
interaction, model, leg, vertex, process, ..."""
17
17
 
 
18
from __future__ import absolute_import
18
19
import copy
19
20
import itertools
20
21
import logging
22
23
import numbers
23
24
import os
24
25
import re
25
 
import StringIO
 
26
import six
 
27
StringIO = six
26
28
import madgraph.core.color_algebra as color
27
29
import collections
28
30
from madgraph import MadGraph5Error, MG5DIR, InvalidCmd
29
31
import madgraph.various.misc as misc 
 
32
from six.moves import range
 
33
from six.moves import zip
 
34
from functools import reduce
30
35
 
31
36
 
32
37
logger = logging.getLogger('madgraph.base_objects')
81
86
        assert isinstance(name, str), \
82
87
                                 "Property name %s is not a string" % repr(name)
83
88
 
84
 
        if name not in self.keys():
85
 
            raise self.PhysicsObjectError, \
86
 
                        """%s is not a valid property for this object: %s\n
87
 
    Valid property are %s""" % (name,self.__class__.__name__, self.keys())
 
89
        if name not in list(self.keys()):
 
90
            raise self.PhysicsObjectError("""%s is not a valid property for this object: %s\n
 
91
    Valid property are %s""" % (name,self.__class__.__name__, list(self.keys())))
88
92
        return True
89
93
 
90
94
    def get(self, name):
105
109
                self.filter(name, value)
106
110
                self[name] = value
107
111
                return True
108
 
            except self.PhysicsObjectError, why:
 
112
            except self.PhysicsObjectError as why:
109
113
                logger.warning("Property " + name + " cannot be changed:" + \
110
114
                                str(why))
111
115
                return False
120
124
        """Returns the object keys sorted in a certain way. By default,
121
125
        alphabetical."""
122
126
 
123
 
        return self.keys().sort()
 
127
        return list(self.keys()).sort()
124
128
 
125
129
    def __str__(self):
126
130
        """String representation of the object. Outputs valid Python 
273
277
            # Forbid special character but +-~_
274
278
            p=re.compile('''^[\w\-\+~_]+$''')
275
279
            if not p.match(value):
276
 
                raise self.PhysicsObjectError, \
277
 
                        "%s is not a valid particle name" % value
 
280
                raise self.PhysicsObjectError("%s is not a valid particle name" % value)
278
281
 
279
 
        if name is 'ghost':
 
282
        if name == 'ghost':
280
283
            if not isinstance(value,bool):
281
 
                raise self.PhysicsObjectError, \
282
 
                 "%s is not a valid bool for the 'ghost' attribute" % str(value)
 
284
                raise self.PhysicsObjectError("%s is not a valid bool for the 'ghost' attribute" % str(value))
283
285
    
284
 
        if name is 'counterterm':
 
286
        if name == 'counterterm':
285
287
            if not isinstance(value,dict):
286
 
                raise self.PhysicsObjectError, \
287
 
                    "counterterm %s is not a valid dictionary" % repr(value)
 
288
                raise self.PhysicsObjectError("counterterm %s is not a valid dictionary" % repr(value))
288
289
            for key, val in value.items():
289
290
                if not isinstance(key,tuple):
290
 
                    raise self.PhysicsObjectError, \
291
 
                        "key %s is not a valid tuple for counterterm key" % repr(key)
 
291
                    raise self.PhysicsObjectError("key %s is not a valid tuple for counterterm key" % repr(key))
292
292
                if not isinstance(key[0],str):
293
 
                    raise self.PhysicsObjectError, \
294
 
                        "%s is not a valid string" % repr(key[0])
 
293
                    raise self.PhysicsObjectError("%s is not a valid string" % repr(key[0]))
295
294
                if not isinstance(key[1],tuple):
296
 
                    raise self.PhysicsObjectError, \
297
 
                        "%s is not a valid list" % repr(key[1])
 
295
                    raise self.PhysicsObjectError("%s is not a valid list" % repr(key[1]))
298
296
                for elem in key[1]:
299
297
                    if not isinstance(elem,tuple):
300
 
                        raise self.PhysicsObjectError, \
301
 
                            "%s is not a valid list" % repr(elem)
 
298
                        raise self.PhysicsObjectError("%s is not a valid list" % repr(elem))
302
299
                    for partPDG in elem:
303
300
                        if not isinstance(partPDG,int):
304
 
                            raise self.PhysicsObjectError, \
305
 
                                "%s is not a valid integer for PDG" % repr(partPDG)
 
301
                            raise self.PhysicsObjectError("%s is not a valid integer for PDG" % repr(partPDG))
306
302
                        if partPDG<=0:
307
 
                            raise self.PhysicsObjectError, \
308
 
                                "%s is not a valid positive PDG" % repr(partPDG)
 
303
                            raise self.PhysicsObjectError("%s is not a valid positive PDG" % repr(partPDG))
309
304
                if not isinstance(val,dict):
310
 
                    raise self.PhysicsObjectError, \
311
 
                        "value %s is not a valid dictionary for counterterm value" % repr(val)
 
305
                    raise self.PhysicsObjectError("value %s is not a valid dictionary for counterterm value" % repr(val))
312
306
                for vkey, vvalue in val.items():
313
307
                    if vkey not in [0,-1,-2]:
314
 
                        raise self.PhysicsObjectError, \
315
 
                            "Key %s is not a valid laurent serie order" % repr(vkey)
 
308
                        raise self.PhysicsObjectError("Key %s is not a valid laurent serie order" % repr(vkey))
316
309
                    if not isinstance(vvalue,str):
317
 
                        raise self.PhysicsObjectError, \
318
 
                            "Coupling %s is not a valid string" % repr(vvalue)
319
 
        if name is 'spin':
 
310
                        raise self.PhysicsObjectError("Coupling %s is not a valid string" % repr(vvalue))
 
311
        if name == 'spin':
320
312
            if not isinstance(value, int):
321
 
                raise self.PhysicsObjectError, \
322
 
                    "Spin %s is not an integer" % repr(value)
 
313
                raise self.PhysicsObjectError("Spin %s is not an integer" % repr(value))
323
314
            if (value < 1 or value > 5) and value != 99:
324
 
                raise self.PhysicsObjectError, \
325
 
                   "Spin %i not valid" % value
 
315
                raise self.PhysicsObjectError("Spin %i not valid" % value)
326
316
 
327
 
        if name is 'color':
 
317
        if name == 'color':
328
318
            if not isinstance(value, int):
329
 
                raise self.PhysicsObjectError, \
330
 
                    "Color %s is not an integer" % repr(value)
 
319
                raise self.PhysicsObjectError("Color %s is not an integer" % repr(value))
331
320
            if value not in [1, 3, 6, 8]:
332
 
                raise self.PhysicsObjectError, \
333
 
                   "Color %i is not valid" % value
 
321
                raise self.PhysicsObjectError("Color %i is not valid" % value)
334
322
 
335
323
        if name in ['mass', 'width']:
336
324
            # Must start with a letter, followed by letters, digits or _
337
325
            p = re.compile('\A[a-zA-Z]+[\w\_]*\Z')
338
326
            if not p.match(value):
339
 
                raise self.PhysicsObjectError, \
340
 
                        "%s is not a valid name for mass/width variable" % \
341
 
                        value
 
327
                raise self.PhysicsObjectError("%s is not a valid name for mass/width variable" % \
 
328
                        value)
342
329
 
343
 
        if name is 'pdg_code':
 
330
        if name == 'pdg_code':
344
331
            if not isinstance(value, int):
345
 
                raise self.PhysicsObjectError, \
346
 
                    "PDG code %s is not an integer" % repr(value)
 
332
                raise self.PhysicsObjectError("PDG code %s is not an integer" % repr(value))
347
333
 
348
 
        if name is 'line':
 
334
        if name == 'line':
349
335
            if not isinstance(value, str):
350
 
                raise self.PhysicsObjectError, \
351
 
                    "Line type %s is not a string" % repr(value)
 
336
                raise self.PhysicsObjectError("Line type %s is not a string" % repr(value))
352
337
            if value not in ['None','dashed', 'straight', 'wavy', 'curly', 'double','swavy','scurly','dotted']:
353
 
                raise self.PhysicsObjectError, \
354
 
                   "Line type %s is unknown" % value
 
338
                raise self.PhysicsObjectError("Line type %s is unknown" % value)
355
339
 
356
 
        if name is 'charge':
 
340
        if name == 'charge':
357
341
            if not isinstance(value, float):
358
 
                raise self.PhysicsObjectError, \
359
 
                    "Charge %s is not a float" % repr(value)
 
342
                raise self.PhysicsObjectError("Charge %s is not a float" % repr(value))
360
343
 
361
 
        if name is 'propagating':
 
344
        if name == 'propagating':
362
345
            if not isinstance(value, bool):
363
 
                raise self.PhysicsObjectError, \
364
 
                    "Propagating tag %s is not a boolean" % repr(value)
 
346
                raise self.PhysicsObjectError("Propagating tag %s is not a boolean" % repr(value))
365
347
 
366
348
        if name in ['is_part', 'self_antipart']:
367
349
            if not isinstance(value, bool):
368
 
                raise self.PhysicsObjectError, \
369
 
                    "%s tag %s is not a boolean" % (name, repr(value))
 
350
                raise self.PhysicsObjectError("%s tag %s is not a boolean" % (name, repr(value)))
370
351
 
371
352
        return True
372
353
 
392
373
            # type "QCD".
393
374
            if len(int.get('orders'))>1:
394
375
                continue
395
 
            if order in int.get('orders').keys() and self.get('pdg_code') in \
 
376
            if order in list(int.get('orders').keys()) and self.get('pdg_code') in \
396
377
              [part.get('pdg_code') for part in int.get('particles')]:
397
378
                return True
398
379
            
487
468
            # Massive tensor
488
469
            res = [-2, -1, 0, 1, 2]
489
470
        else:
490
 
            raise self.PhysicsObjectError, \
491
 
              "No helicity state assignment for spin %d particles" % spin
 
471
            raise self.PhysicsObjectError("No helicity state assignment for spin %d particles" % spin)
492
472
                  
493
473
        if allow_reverse and not self.get('is_part'):
494
474
            res.reverse()
690
670
        if name == 'id':
691
671
            #Should be an integer
692
672
            if not isinstance(value, int):
693
 
                raise self.PhysicsObjectError, \
694
 
                        "%s is not a valid integer" % str(value)
 
673
                raise self.PhysicsObjectError("%s is not a valid integer" % str(value))
695
674
 
696
675
        if name == 'particles':
697
676
            #Should be a list of valid particle names
698
677
            if not isinstance(value, ParticleList):
699
 
                raise self.PhysicsObjectError, \
700
 
                        "%s is not a valid list of particles" % str(value)
 
678
                raise self.PhysicsObjectError("%s is not a valid list of particles" % str(value))
701
679
 
702
680
        if name == 'perturbation_type':
703
681
            if value!=None and not isinstance(value, str):
704
 
                raise self.PhysicsObjectError, \
705
 
                        "%s is not a valid string" % str(value)            
 
682
                raise self.PhysicsObjectError("%s is not a valid string" % str(value))            
706
683
 
707
684
        if name == 'type':
708
685
            #Should be a string
709
686
            if not isinstance(value, str):
710
 
                raise self.PhysicsObjectError, \
711
 
                        "%s is not a valid string" % str(value)
 
687
                raise self.PhysicsObjectError("%s is not a valid string" % str(value))
712
688
        if name == 'loop_particles':
713
689
            if isinstance(value,list):
714
690
                for l in value:
715
691
                    if isinstance(l,list):
716
692
                        for part in l:
717
693
                            if not isinstance(part,int):
718
 
                                raise self.PhysicsObjectError, \
719
 
                                    "%s is not a valid integer" % str(part)
 
694
                                raise self.PhysicsObjectError("%s is not a valid integer" % str(part))
720
695
                            if part<0:
721
 
                                raise self.PhysicsObjectError, \
722
 
                                    "%s is not a valid positive integer" % str(part)
 
696
                                raise self.PhysicsObjectError("%s is not a valid positive integer" % str(part))
723
697
 
724
698
        if name == 'orders':
725
699
            #Should be a dict with valid order names ask keys and int as values
726
700
            if not isinstance(value, dict):
727
 
                raise self.PhysicsObjectError, \
728
 
                        "%s is not a valid dict for coupling orders" % \
729
 
                                                                    str(value)
 
701
                raise self.PhysicsObjectError("%s is not a valid dict for coupling orders" % \
 
702
                                                                    str(value))
730
703
            for order in value.keys():
731
704
                if not isinstance(order, str):
732
 
                    raise self.PhysicsObjectError, \
733
 
                        "%s is not a valid string" % str(order)
 
705
                    raise self.PhysicsObjectError("%s is not a valid string" % str(order))
734
706
                if not isinstance(value[order], int):
735
 
                    raise self.PhysicsObjectError, \
736
 
                        "%s is not a valid integer" % str(value[order])
 
707
                    raise self.PhysicsObjectError("%s is not a valid integer" % str(value[order]))
737
708
 
738
709
        if name in ['color']:
739
710
            #Should be a list of list strings
740
711
            if not isinstance(value, list):
741
 
                raise self.PhysicsObjectError, \
742
 
                        "%s is not a valid list of Color Strings" % str(value)
 
712
                raise self.PhysicsObjectError("%s is not a valid list of Color Strings" % str(value))
743
713
            for mycolstring in value:
744
714
                if not isinstance(mycolstring, color.ColorString):
745
 
                    raise self.PhysicsObjectError, \
746
 
                            "%s is not a valid list of Color Strings" % str(value)
 
715
                    raise self.PhysicsObjectError("%s is not a valid list of Color Strings" % str(value))
747
716
 
748
717
        if name in ['lorentz']:
749
718
            #Should be a list of list strings
750
719
            if not isinstance(value, list):
751
 
                raise self.PhysicsObjectError, \
752
 
                        "%s is not a valid list of strings" % str(value)
 
720
                raise self.PhysicsObjectError("%s is not a valid list of strings" % str(value))
753
721
            for mystr in value:
754
722
                if not isinstance(mystr, str):
755
 
                    raise self.PhysicsObjectError, \
756
 
                        "%s is not a valid string" % str(mystr)
 
723
                    raise self.PhysicsObjectError("%s is not a valid string" % str(mystr))
757
724
 
758
725
        if name == 'couplings':
759
726
            #Should be a dictionary of strings with (i,j) keys
760
727
            if not isinstance(value, dict):
761
 
                raise self.PhysicsObjectError, \
762
 
                        "%s is not a valid dictionary for couplings" % \
763
 
                                                                str(value)
 
728
                raise self.PhysicsObjectError("%s is not a valid dictionary for couplings" % \
 
729
                                                                str(value))
764
730
 
765
731
            for key in value.keys():
766
732
                if not isinstance(key, tuple):
767
 
                    raise self.PhysicsObjectError, \
768
 
                        "%s is not a valid tuple" % str(key)
 
733
                    raise self.PhysicsObjectError("%s is not a valid tuple" % str(key))
769
734
                if len(key) != 2:
770
 
                    raise self.PhysicsObjectError, \
771
 
                        "%s is not a valid tuple with 2 elements" % str(key)
 
735
                    raise self.PhysicsObjectError("%s is not a valid tuple with 2 elements" % str(key))
772
736
                if not isinstance(key[0], int) or not isinstance(key[1], int):
773
 
                    raise self.PhysicsObjectError, \
774
 
                        "%s is not a valid tuple of integer" % str(key)
 
737
                    raise self.PhysicsObjectError("%s is not a valid tuple of integer" % str(key))
775
738
                if not isinstance(value[key], str):
776
 
                    raise self.PhysicsObjectError, \
777
 
                        "%s is not a valid string" % value[key]
 
739
                    raise self.PhysicsObjectError("%s is not a valid string" % value[key])
778
740
 
779
741
        return True
780
742
 
797
759
 
798
760
        # Precaution only useful because some tests have a predefined model
799
761
        # bypassing the default_setup and for which type was not defined.
800
 
        if 'type' in self.keys():
 
762
        if 'type' in list(self.keys()):
801
763
            return (len(self['type'])>=2 and self['type'][:2]=='R2')
802
764
        else:
803
765
            return False
807
769
 
808
770
        # Precaution only useful because some tests have a predefined model
809
771
        # bypassing the default_setup and for which type was not defined.
810
 
        if 'type' in self.keys():
 
772
        if 'type' in list(self.keys()):
811
773
            return (len(self['type'])>=2 and self['type'][:2]=='UV')
812
774
        else:
813
775
            return False
817
779
 
818
780
        # Precaution only useful because some tests have a predefined model
819
781
        # bypassing the default_setup and for which type was not defined.
820
 
        if 'type' in self.keys():
 
782
        if 'type' in list(self.keys()):
821
783
            return (len(self['type'])>=6 and self['type'][:6]=='UVmass')
822
784
        else:
823
785
            return False
827
789
 
828
790
        # Precaution only useful because some tests have a predefined model
829
791
        # bypassing the default_setup and for which type was not defined.
830
 
        if 'type' in self.keys():
 
792
        if 'type' in list(self.keys()):
831
793
            return (len(self['type'])>=6 and self['type'][:6]=='UVloop')
832
794
        else:
833
795
            return False
837
799
 
838
800
        # Precaution only useful because some tests have a predefined model
839
801
        # bypassing the default_setup and for which type was not defined.
840
 
        if 'type' in self.keys():
 
802
        if 'type' in list(self.keys()):
841
803
            return (len(self['type'])>=6 and self['type'][:6]=='UVtree')
842
804
        else:
843
805
            return False
850
812
 
851
813
        # Precaution only useful because some tests have a predefined model
852
814
        # bypassing the default_setup and for which type was not defined.
853
 
        if 'UVCT_SPECIAL' in self['orders'].keys():
 
815
        if 'UVCT_SPECIAL' in list(self['orders'].keys()):
854
816
            return True
855
817
        else:
856
818
            return False
859
821
        """ Returns 0 if this interaction contributes to the finite part of the
860
822
        amplitude and 1 (2) is it contributes to its single (double) pole """
861
823
        
862
 
        if 'type' in self.keys():
 
824
        if 'type' in list(self.keys()):
863
825
            if '1eps' in self['type']:
864
826
                return 1
865
827
            elif '2eps' in self['type']:
877
839
        # We are interested in the unordered list, so use sorted()
878
840
 
879
841
        pdg_tuple = tuple(sorted([p.get_pdg_code() for p in self['particles']]))
880
 
        if pdg_tuple not in ref_dict_to0.keys():
 
842
        if pdg_tuple not in list(ref_dict_to0.keys()):
881
843
            ref_dict_to0[pdg_tuple] = [self['id']]
882
844
        else:
883
845
            ref_dict_to0[pdg_tuple].append(self['id'])
895
857
                                      enumerate(self['particles']) if \
896
858
                                      i != self['particles'].index(part)]))
897
859
            pdg_part = part.get_anti_pdg_code()
898
 
            if pdg_tuple in ref_dict_to1.keys():
 
860
            if pdg_tuple in list(ref_dict_to1.keys()):
899
861
                if (pdg_part, self['id']) not in  ref_dict_to1[pdg_tuple]:
900
862
                    ref_dict_to1[pdg_tuple].append((pdg_part, self['id']))
901
863
            else:
1071
1033
 
1072
1034
        if name in ['name']:
1073
1035
            if not isinstance(value, str):
1074
 
                raise self.PhysicsObjectError, \
1075
 
                    "Object of type %s is not a string" %type(value)
 
1036
                raise self.PhysicsObjectError("Object of type %s is not a string" %type(value))
1076
1037
 
1077
1038
        elif name == 'particles':
1078
1039
            if not isinstance(value, ParticleList):
1079
 
                raise self.PhysicsObjectError, \
1080
 
                    "Object of type %s is not a ParticleList object" % \
1081
 
                                                            type(value)
 
1040
                raise self.PhysicsObjectError("Object of type %s is not a ParticleList object" % \
 
1041
                                                            type(value))
1082
1042
        elif name == 'interactions':
1083
1043
            if not isinstance(value, InteractionList):
1084
 
                raise self.PhysicsObjectError, \
1085
 
                    "Object of type %s is not a InteractionList object" % \
1086
 
                                                            type(value)
 
1044
                raise self.PhysicsObjectError("Object of type %s is not a InteractionList object" % \
 
1045
                                                            type(value))
1087
1046
        elif name == 'particle_dict':
1088
1047
            if not isinstance(value, dict):
1089
 
                raise self.PhysicsObjectError, \
1090
 
                    "Object of type %s is not a dictionary" % \
1091
 
                                                        type(value)
 
1048
                raise self.PhysicsObjectError("Object of type %s is not a dictionary" % \
 
1049
                                                        type(value))
1092
1050
        elif name == 'interaction_dict':
1093
1051
            if not isinstance(value, dict):
1094
 
                raise self.PhysicsObjectError, \
1095
 
                    "Object of type %s is not a dictionary" % type(value)
 
1052
                raise self.PhysicsObjectError("Object of type %s is not a dictionary" % type(value))
1096
1053
 
1097
1054
        elif name == 'ref_dict_to0':
1098
1055
            if not isinstance(value, dict):
1099
 
                raise self.PhysicsObjectError, \
1100
 
                    "Object of type %s is not a dictionary" % type(value)
 
1056
                raise self.PhysicsObjectError("Object of type %s is not a dictionary" % type(value))
1101
1057
                    
1102
1058
        elif name == 'ref_dict_to1':
1103
1059
            if not isinstance(value, dict):
1104
 
                raise self.PhysicsObjectError, \
1105
 
                    "Object of type %s is not a dictionary" % type(value)
 
1060
                raise self.PhysicsObjectError("Object of type %s is not a dictionary" % type(value))
1106
1061
 
1107
1062
        elif name == 'got_majoranas':
1108
1063
            if not (isinstance(value, bool) or value == None):
1109
 
                raise self.PhysicsObjectError, \
1110
 
                    "Object of type %s is not a boolean" % type(value)
 
1064
                raise self.PhysicsObjectError("Object of type %s is not a boolean" % type(value))
1111
1065
 
1112
1066
        elif name == 'conserved_charge':
1113
1067
            if not (isinstance(value, set)):
1114
 
                raise self.PhysicsObjectError, \
1115
 
                    "Object of type %s is not a set" % type(value)
 
1068
                raise self.PhysicsObjectError("Object of type %s is not a set" % type(value))
1116
1069
 
1117
1070
        elif name == 'version_tag':
1118
1071
            if not (isinstance(value, str)):
1119
 
                raise self.PhysicsObjectError, \
1120
 
                    "Object of type %s is not a string" % type(value)
 
1072
                raise self.PhysicsObjectError("Object of type %s is not a string" % type(value))
1121
1073
 
1122
1074
        elif name == 'order_hierarchy':
1123
1075
            if not isinstance(value, dict):
1124
 
                raise self.PhysicsObjectError, \
1125
 
                    "Object of type %s is not a dictionary" % \
1126
 
                                                            type(value)
 
1076
                raise self.PhysicsObjectError("Object of type %s is not a dictionary" % \
 
1077
                                                            type(value))
1127
1078
            for key in value.keys():
1128
1079
                if not isinstance(value[key],int):
1129
 
                    raise self.PhysicsObjectError, \
1130
 
                        "Object of type %s is not an integer" % \
1131
 
                                                            type(value[key])
 
1080
                    raise self.PhysicsObjectError("Object of type %s is not an integer" % \
 
1081
                                                            type(value[key]))
1132
1082
        elif name == 'gauge':
1133
1083
            if not (isinstance(value, list)):
1134
 
                raise self.PhysicsObjectError, \
1135
 
                    "Object of type %s is not a list" % type(value)
 
1084
                raise self.PhysicsObjectError("Object of type %s is not a list" % type(value))
1136
1085
 
1137
1086
        elif name == 'case_sensitive':
1138
1087
            if not value in [True ,False]:
1139
 
                raise self.PhysicsObjectError, \
1140
 
                    "Object of type %s is not a boolean" % type(value)
 
1088
                raise self.PhysicsObjectError("Object of type %s is not a boolean" % type(value))
1141
1089
            
1142
1090
 
1143
1091
        return True
1165
1113
                modeldir = os.path.expanduser(modeldir)
1166
1114
                return modeldir
1167
1115
            else:
1168
 
                raise Exception, "path %s not valid anymore." % modeldir
 
1116
                raise Exception("path %s not valid anymore." % modeldir)
1169
1117
            #modeldir = os.path.join(os.path.dirname(modeldir),
1170
1118
            #                        os.path.basename(modeldir).rsplit("-",1)[0])
1171
1119
            #if os.path.exists(modeldir):
1175
1123
            modeldir = self.get('version_tag').rsplit('##',1)[0]
1176
1124
            modelname = self['name']            
1177
1125
            if not  os.path.exists(modeldir):
1178
 
                raise Exception, "path %s not valid anymore" % modeldir
 
1126
                raise Exception("path %s not valid anymore" % modeldir)
1179
1127
            modeldir = os.path.dirname(modeldir)
1180
1128
            modeldir = pjoin(modeldir, modelname)
1181
1129
            modeldir = os.path.expanduser(modeldir)
1275
1223
            if isinstance(id, int):
1276
1224
                try:
1277
1225
                    return self.get("particle_dict")[id]
1278
 
                except Exception, error:
 
1226
                except Exception as error:
1279
1227
                    return None
1280
1228
            else:
1281
1229
                if not hasattr(self, 'name2part'):
1339
1287
 
1340
1288
    def get_coupling_orders(self):
1341
1289
        """Determine the coupling orders of the model"""
1342
 
        return set(sum([i.get('orders').keys() for i in \
 
1290
        return set(sum([list(i.get('orders').keys()) for i in \
1343
1291
                        self.get('interactions')], []))
1344
1292
 
1345
1293
    def get_order_hierarchy(self):
1469
1417
                'to use the particles name defined in the model and not the ' + \
1470
1418
                'MadGraph5_aMC@NLO convention'
1471
1419
                
1472
 
                raise MadGraph5Error, error_text % \
1473
 
                                     (part.get_name(), part.get_pdg_code(), pdg)                
 
1420
                raise MadGraph5Error(error_text % \
 
1421
                                     (part.get_name(), part.get_pdg_code(), pdg))                
1474
1422
 
1475
1423
        default = self.load_default_name()
1476
1424
 
1507
1455
        
1508
1456
        lower_dict={}
1509
1457
        duplicate = set()
1510
 
        keys = self.get('parameters').keys()
 
1458
        keys = list(self.get('parameters').keys())
1511
1459
        for key in keys:
1512
1460
            for param in self['parameters'][key]:
1513
1461
                lower_name = param.name.lower()
1611
1559
    def get_first_non_pdg(self):
1612
1560
        """Return the first positive number that is not a valid PDG code"""
1613
1561
        return [c for c in range(1, len(self.get('particles')) + 1) if \
1614
 
                c not in self.get('particle_dict').keys()][0]
 
1562
                c not in list(self.get('particle_dict').keys())][0]
1615
1563
                
1616
1564
 
1617
1565
    def write_param_card(self, filepath=None):
1863
1811
        # So at this stage we still need to modify all parameters depending of
1864
1812
        # particle's mass. In addition all parameter (but mass/width/external 
1865
1813
        # parameter) should be pass in complex mode.
1866
 
        pat = '|'.join(to_change.keys())
 
1814
        pat = '|'.join(list(to_change.keys()))
1867
1815
        pat = r'(%s)\b' % pat
1868
1816
        pat = re.compile(pat)
1869
1817
        def replace(match):
1977
1925
 
1978
1926
        if name in ['id', 'number']:
1979
1927
            if not isinstance(value, int):
1980
 
                raise self.PhysicsObjectError, \
1981
 
                        "%s is not a valid integer for leg id" % str(value)
 
1928
                raise self.PhysicsObjectError("%s is not a valid integer for leg id" % str(value))
1982
1929
 
1983
 
        if name == 'state':
 
1930
        elif name == 'state':
1984
1931
            if not isinstance(value, bool):
1985
 
                raise self.PhysicsObjectError, \
1986
 
                        "%s is not a valid leg state (True|False)" % \
1987
 
                                                                    str(value)
1988
 
 
1989
 
        if name == 'from_group':
1990
 
            if not isinstance(value, bool) and value != None:
1991
 
                raise self.PhysicsObjectError, \
1992
 
                        "%s is not a valid boolean for leg flag from_group" % \
1993
 
                                                                    str(value)
1994
 
 
1995
 
        if name == 'loop_line':
1996
 
            if not isinstance(value, bool) and value != None:
1997
 
                raise self.PhysicsObjectError, \
1998
 
                    "%s is not a valid boolean for leg flag loop_line" % \
1999
 
                                                                    str(value)
2000
 
 
2001
 
        if name == 'onshell':
2002
 
            if not isinstance(value, bool) and value != None:
2003
 
                raise self.PhysicsObjectError, \
2004
 
                        "%s is not a valid boolean for leg flag onshell" % \
2005
 
                                                                    str(value)
2006
 
                                                                    
 
1932
                raise self.PhysicsObjectError("%s is not a valid leg state (True|False)" % \
 
1933
                                                                    str(value))
 
1934
 
 
1935
        elif name == 'from_group':
 
1936
            if not isinstance(value, bool) and value != None:
 
1937
                raise self.PhysicsObjectError("%s is not a valid boolean for leg flag from_group" % \
 
1938
                                                                    str(value))
 
1939
 
 
1940
        elif name == 'loop_line':
 
1941
            if not isinstance(value, bool) and value != None:
 
1942
                raise self.PhysicsObjectError("%s is not a valid boolean for leg flag loop_line" % \
 
1943
                                                                    str(value))
 
1944
 
 
1945
        elif name == 'onshell':
 
1946
            if not isinstance(value, bool) and value != None:
 
1947
                raise self.PhysicsObjectError("%s is not a valid boolean for leg flag onshell" % \
 
1948
                                                                    str(value))
2007
1949
        
2008
 
        if name == 'polarization':
 
1950
        elif name == 'polarization':
2009
1951
            if not isinstance(value, list):
2010
 
                raise self.PhysicsObjectError, \
2011
 
                        "%s is not a valid list" % str(value)
 
1952
                raise self.PhysicsObjectError( \
 
1953
                        "%s is not a valid list" % str(value))
2012
1954
            for i in value:
2013
1955
                if i not in [-1, 1, 2,-2, 3,-3, 0, 99]:
2014
 
                    raise self.PhysicsObjectError, \
2015
 
                          "%s is not a valid polarization" % str(value)
 
1956
                    raise self.PhysicsObjectError( \
 
1957
                          "%s is not a valid polarization" % str(value))
2016
1958
                                                                    
2017
 
        
2018
1959
        return True
2019
1960
 
2020
1961
    def get_sorted_keys(self):
2100
2041
    def from_group_elements(self):
2101
2042
        """Return all elements which have 'from_group' True"""
2102
2043
 
2103
 
        return filter(lambda leg: leg.get('from_group'), self)
 
2044
        return [leg for leg in self if leg.get('from_group')]
2104
2045
 
2105
2046
    def minimum_one_from_group(self):
2106
2047
        """Return True if at least one element has 'from_group' True"""
2116
2057
        """If has at least one 'from_group' True and in ref_dict_to1,
2117
2058
           return the return list from ref_dict_to1, otherwise return False"""
2118
2059
        if self.minimum_one_from_group():
2119
 
            return ref_dict_to1.has_key(tuple(sorted([leg.get('id') for leg in self])))
 
2060
            return tuple(sorted([leg.get('id') for leg in self])) in ref_dict_to1
2120
2061
        else:
2121
2062
            return False
2122
2063
 
2135
2076
            # unclustered, since we want this to stay until the very
2136
2077
            # end.
2137
2078
            return any(leg.get('from_group') == None for leg in self) and \
2138
 
                   ref_dict_to0.has_key(tuple(sorted([leg.get('id') \
2139
 
                                                      for leg in self])))
 
2079
                   tuple(sorted([leg.get('id') \
 
2080
                                                      for leg in self])) in ref_dict_to0
2140
2081
 
2141
2082
        if self.minimum_two_from_group():
2142
 
            return ref_dict_to0.has_key(tuple(sorted([leg.get('id') for leg in self])))
 
2083
            return tuple(sorted([leg.get('id') for leg in self])) in ref_dict_to0
2143
2084
        else:
2144
2085
            return False
2145
2086
 
2163
2104
    def sort(self,*args, **opts):
2164
2105
        """Match with FKSLegList"""
2165
2106
        Opts=copy.copy(opts)
2166
 
        if 'pert' in Opts.keys():
 
2107
        if 'pert' in list(Opts.keys()):
2167
2108
            del Opts['pert']
2168
2109
        return super(LegList,self).sort(*args, **Opts)
2169
2110
 
2187
2128
 
2188
2129
        if name == 'ids':
2189
2130
            if not isinstance(value, list):
2190
 
                raise self.PhysicsObjectError, \
2191
 
                        "%s is not a valid list" % str(value)
 
2131
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2192
2132
            for i in value:
2193
2133
                if not isinstance(i, int):
2194
 
                    raise self.PhysicsObjectError, \
2195
 
                          "%s is not a valid list of integers" % str(value)
 
2134
                    raise self.PhysicsObjectError("%s is not a valid list of integers" % str(value))
2196
2135
 
2197
2136
        if name == 'polarization':
2198
2137
            if not isinstance(value, list):
2199
 
                raise self.PhysicsObjectError, \
2200
 
                        "%s is not a valid list" % str(value)
 
2138
                raise self.PhysicsObjectError( \
 
2139
                        "%s is not a valid list" % str(value))
2201
2140
            for i in value:
2202
2141
                if i not in [-1, 1,  2, -2, 3, -3, 0, 99]:
2203
 
                    raise self.PhysicsObjectError, \
2204
 
                          "%s is not a valid polarization" % str(value)
 
2142
                    raise self.PhysicsObjectError( \
 
2143
                          "%s is not a valid polarization" % str(value))
2205
2144
 
2206
2145
        if name == 'state':
2207
2146
            if not isinstance(value, bool):
2208
 
                raise self.PhysicsObjectError, \
2209
 
                        "%s is not a valid leg state (initial|final)" % \
2210
 
                                                                    str(value)
 
2147
                raise self.PhysicsObjectError("%s is not a valid leg state (initial|final)" % \
 
2148
                                                                    str(value))
2211
2149
 
2212
2150
        return True
2213
2151
 
2256
2194
    # the list ID_to_veto_for_multichanneling then all loop are considered by 
2257
2195
    # default and the constraint below is not applied.
2258
2196
    max_n_loop_for_multichanneling = 4
 
2197
    max_tpropa = 99
2259
2198
    
2260
2199
    def default_setup(self):
2261
2200
        """Default values for all properties"""
2275
2214
 
2276
2215
        if name == 'id':
2277
2216
            if not isinstance(value, int):
2278
 
                raise self.PhysicsObjectError, \
2279
 
                        "%s is not a valid integer for vertex id" % str(value)
 
2217
                raise self.PhysicsObjectError("%s is not a valid integer for vertex id" % str(value))
2280
2218
 
2281
2219
        if name == 'legs':
2282
2220
            if not isinstance(value, LegList):
2283
 
                raise self.PhysicsObjectError, \
2284
 
                        "%s is not a valid LegList object" % str(value)
 
2221
                raise self.PhysicsObjectError("%s is not a valid LegList object" % str(value))
2285
2222
 
2286
2223
        return True
2287
2224
 
2398
2335
            if isinstance(value, list):
2399
2336
                for elem in value:
2400
2337
                    if not isinstance(elem,int):
2401
 
                        raise self.PhysicsObjectError, \
2402
 
                            "%s is not a valid integer for leg PDG" % str(elem)
 
2338
                        raise self.PhysicsObjectError("%s is not a valid integer for leg PDG" % str(elem))
2403
2339
            else:
2404
 
                raise self.PhysicsObjectError, \
2405
 
                  "%s is not a valid list for contracted vertex PDGs"%str(value)                
 
2340
                raise self.PhysicsObjectError("%s is not a valid list for contracted vertex PDGs"%str(value))                
2406
2341
        if name == 'loop_tag':
2407
2342
            if isinstance(value, tuple):
2408
2343
                for elem in value:
2409
2344
                    if not (isinstance(elem,int) or isinstance(elem,tuple)):
2410
 
                        raise self.PhysicsObjectError, \
2411
 
                          "%s is not a valid int or tuple for loop tag element"%str(elem)
 
2345
                        raise self.PhysicsObjectError("%s is not a valid int or tuple for loop tag element"%str(elem))
2412
2346
            else:
2413
 
                raise self.PhysicsObjectError, \
2414
 
                  "%s is not a valid tuple for a contracted vertex loop_tag."%str(value)
 
2347
                raise self.PhysicsObjectError("%s is not a valid tuple for a contracted vertex loop_tag."%str(value))
2415
2348
        if name == 'loop_orders':
2416
2349
            Interaction.filter(Interaction(), 'orders', value)
2417
2350
        else:
2442
2375
 
2443
2376
        if name == 'vertices':
2444
2377
            if not isinstance(value, VertexList):
2445
 
                raise self.PhysicsObjectError, \
2446
 
                        "%s is not a valid VertexList object" % str(value)
 
2378
                raise self.PhysicsObjectError("%s is not a valid VertexList object" % str(value))
2447
2379
 
2448
2380
        if name == 'orders':
2449
2381
            Interaction.filter(Interaction(), 'orders', value)
2490
2422
                                     for key in sorted(self['orders'].keys())]))
2491
2423
            
2492
2424
            if not pass_sanity:
2493
 
                raise Exception, "invalid diagram: %s. vert_id: %s" % (mystr, responsible) 
 
2425
                raise Exception("invalid diagram: %s. vert_id: %s" % (mystr, responsible)) 
2494
2426
                
2495
2427
            return mystr
2496
2428
        else:
2600
2532
        state_dict = {True:'T',False:'F'}
2601
2533
        return new_diag
2602
2534
 
 
2535
    def get_nb_t_channel(self):
 
2536
        """return number of t-channel propagator in this diagram 
 
2537
           This is used to filter multi-channel.
 
2538
        """
 
2539
        nb_t = 0
 
2540
        for v in self['vertices'][:-1]:
 
2541
            l = v.get('legs')[-1]
 
2542
            if not l.get('state'):
 
2543
                nb_t +=1
 
2544
        return nb_t
 
2545
 
 
2546
            
 
2547
            
 
2548
 
2603
2549
    def get_vertex_leg_numbers(self, 
2604
2550
                        veto_inter_id=Vertex.ID_to_veto_for_multichanneling,
2605
2551
                        max_n_loop=0):
2660
2606
            security =0
2661
2607
            while not vcurrent.is_external():
2662
2608
                if security > 1000:
2663
 
                    raise Exception, 'wrong diagram'
 
2609
                    raise Exception('wrong diagram')
2664
2610
                next_l = [l for l in vcurrent.lines if l is not l_last and l.is_fermion()][0]
2665
2611
                next_v = next_l.end
2666
2612
                if next_v == vcurrent:
2701
2647
        max_order=-1
2702
2648
 
2703
2649
        for diag in self:
2704
 
            if order in diag['orders'].keys():
 
2650
            if order in list(diag['orders'].keys()):
2705
2651
                if max_order==-1 or diag['orders'][order] > max_order:
2706
2652
                    max_order = diag['orders'][order]
2707
2653
 
2762
2708
        order for the coupling specified """
2763
2709
        min_order=-1
2764
2710
        for diag in self:
2765
 
            if order in diag['orders'].keys():
 
2711
            if order in list(diag['orders'].keys()):
2766
2712
                if min_order==-1 or diag['orders'][order] < min_order:
2767
2713
                    min_order = diag['orders'][order]
2768
2714
            else:
2776
2722
 
2777
2723
        values=set([])
2778
2724
        for diag in self:
2779
 
            if order in diag['orders'].keys():
 
2725
            if order in list(diag['orders'].keys()):
2780
2726
                values.add(diag['orders'][order])
2781
2727
            else:
2782
2728
                values.add(0)  
2851
2797
 
2852
2798
        if name in ['legs', 'legs_with_decays'] :
2853
2799
            if not isinstance(value, LegList):
2854
 
                raise self.PhysicsObjectError, \
2855
 
                        "%s is not a valid LegList object" % str(value)
 
2800
                raise self.PhysicsObjectError("%s is not a valid LegList object" % str(value))
2856
2801
 
2857
2802
        if name in ['orders', 'overall_orders','squared_orders']:
2858
2803
            Interaction.filter(Interaction(), 'orders', value)
2859
2804
 
2860
2805
        if name == 'constrained_orders':
2861
2806
            if not isinstance(value, dict):
2862
 
                raise self.PhysicsObjectError, \
2863
 
                        "%s is not a valid dictionary" % str(value)            
 
2807
                raise self.PhysicsObjectError("%s is not a valid dictionary" % str(value))            
2864
2808
 
2865
2809
        if name == 'sqorders_types':
2866
2810
            if not isinstance(value, dict):
2867
 
                raise self.PhysicsObjectError, \
2868
 
                        "%s is not a valid dictionary" % str(value)
2869
 
            for order in value.keys()+value.values():
 
2811
                raise self.PhysicsObjectError("%s is not a valid dictionary" % str(value))
 
2812
            for order in list(value.keys())+list(value.values()):
2870
2813
                if not isinstance(order, str):
2871
 
                    raise self.PhysicsObjectError, \
2872
 
                          "%s is not a valid string" % str(value)
 
2814
                    raise self.PhysicsObjectError("%s is not a valid string" % str(value))
2873
2815
 
2874
2816
        if name == 'split_orders':
2875
2817
            if not isinstance(value, list):
2876
 
                raise self.PhysicsObjectError, \
2877
 
                        "%s is not a valid list" % str(value)
 
2818
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2878
2819
            for order in value:
2879
2820
                if not isinstance(order, str):
2880
 
                    raise self.PhysicsObjectError, \
2881
 
                          "%s is not a valid string" % str(value)
 
2821
                    raise self.PhysicsObjectError("%s is not a valid string" % str(value))
2882
2822
 
2883
2823
        if name == 'model':
2884
2824
            if not isinstance(value, Model):
2885
 
                raise self.PhysicsObjectError, \
2886
 
                        "%s is not a valid Model object" % str(value)
 
2825
                raise self.PhysicsObjectError("%s is not a valid Model object" % str(value))
2887
2826
        if name in ['id', 'uid']:
2888
2827
            if not isinstance(value, int):
2889
 
                raise self.PhysicsObjectError, \
2890
 
                    "Process %s %s is not an integer" % (name, repr(value))
 
2828
                raise self.PhysicsObjectError("Process %s %s is not an integer" % (name, repr(value)))
2891
2829
 
2892
2830
        if name == 'required_s_channels':
2893
2831
            if not isinstance(value, list):
2894
 
                raise self.PhysicsObjectError, \
2895
 
                        "%s is not a valid list" % str(value)
 
2832
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2896
2833
            for l in value:
2897
2834
                if not isinstance(l, list):
2898
 
                    raise self.PhysicsObjectError, \
2899
 
                          "%s is not a valid list of lists" % str(value)
 
2835
                    raise self.PhysicsObjectError("%s is not a valid list of lists" % str(value))
2900
2836
                for i in l:
2901
2837
                    if not isinstance(i, int):
2902
 
                        raise self.PhysicsObjectError, \
2903
 
                              "%s is not a valid list of integers" % str(l)
 
2838
                        raise self.PhysicsObjectError("%s is not a valid list of integers" % str(l))
2904
2839
                    if i == 0:
2905
 
                        raise self.PhysicsObjectError, \
2906
 
                          "Not valid PDG code %d for s-channel particle" % i
 
2840
                        raise self.PhysicsObjectError("Not valid PDG code %d for s-channel particle" % i)
2907
2841
 
2908
2842
        if name in ['forbidden_onsh_s_channels', 'forbidden_s_channels']:
2909
2843
            if not isinstance(value, list):
2910
 
                raise self.PhysicsObjectError, \
2911
 
                        "%s is not a valid list" % str(value)
 
2844
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2912
2845
            for i in value:
2913
2846
                if not isinstance(i, int):
2914
 
                    raise self.PhysicsObjectError, \
2915
 
                          "%s is not a valid list of integers" % str(value)
 
2847
                    raise self.PhysicsObjectError("%s is not a valid list of integers" % str(value))
2916
2848
                if i == 0:
2917
 
                    raise self.PhysicsObjectError, \
2918
 
                      "Not valid PDG code %d for s-channel particle" % str(value)
 
2849
                    raise self.PhysicsObjectError("Not valid PDG code %d for s-channel particle" % str(value))
2919
2850
 
2920
2851
        if name == 'forbidden_particles':
2921
2852
            if not isinstance(value, list):
2922
 
                raise self.PhysicsObjectError, \
2923
 
                        "%s is not a valid list" % str(value)
 
2853
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2924
2854
            for i in value:
2925
2855
                if not isinstance(i, int):
2926
 
                    raise self.PhysicsObjectError, \
2927
 
                          "%s is not a valid list of integers" % str(value)
 
2856
                    raise self.PhysicsObjectError("%s is not a valid list of integers" % str(value))
2928
2857
                if i <= 0:
2929
 
                    raise self.PhysicsObjectError, \
2930
 
                      "Forbidden particles should have a positive PDG code" % str(value)
 
2858
                    raise self.PhysicsObjectError("Forbidden particles should have a positive PDG code" % str(value))
2931
2859
 
2932
2860
        if name == 'perturbation_couplings':
2933
2861
            if not isinstance(value, list):
2934
 
                raise self.PhysicsObjectError, \
2935
 
                        "%s is not a valid list" % str(value)
 
2862
                raise self.PhysicsObjectError("%s is not a valid list" % str(value))
2936
2863
            for order in value:
2937
2864
                if not isinstance(order, str):
2938
 
                    raise self.PhysicsObjectError, \
2939
 
                          "%s is not a valid string" % str(value)
 
2865
                    raise self.PhysicsObjectError("%s is not a valid string" % str(value))
2940
2866
 
2941
2867
        if name == 'is_decay_chain':
2942
2868
            if not isinstance(value, bool):
2943
 
                raise self.PhysicsObjectError, \
2944
 
                        "%s is not a valid bool" % str(value)
 
2869
                raise self.PhysicsObjectError("%s is not a valid bool" % str(value))
2945
2870
 
2946
2871
        if name == 'has_born':
2947
2872
            if not isinstance(value, bool):
2948
 
                raise self.PhysicsObjectError, \
2949
 
                        "%s is not a valid bool" % str(value)
 
2873
                raise self.PhysicsObjectError("%s is not a valid bool" % str(value))
2950
2874
 
2951
2875
        if name == 'decay_chains':
2952
2876
            if not isinstance(value, ProcessList):
2953
 
                raise self.PhysicsObjectError, \
2954
 
                        "%s is not a valid ProcessList" % str(value)
 
2877
                raise self.PhysicsObjectError("%s is not a valid ProcessList" % str(value))
2955
2878
 
2956
2879
        if name == 'NLO_mode':
2957
2880
            import madgraph.interface.madgraph_interface as mg
2958
2881
            if value not in mg.MadGraphCmd._valid_nlo_modes:
2959
 
                raise self.PhysicsObjectError, \
2960
 
                        "%s is not a valid NLO_mode" % str(value)
 
2882
                raise self.PhysicsObjectError("%s is not a valid NLO_mode" % str(value))
2961
2883
        return True
2962
2884
 
2963
2885
    def has_multiparticle_label(self):
2987
2909
        """ Return what kind of squared order constraint was specified for the
2988
2910
        order 'order'."""
2989
2911
 
2990
 
        if order in self['sqorders_types'].keys():
 
2912
        if order in list(self['sqorders_types'].keys()):
2991
2913
            return self['sqorders_types'][order]
2992
2914
        else:
2993
2915
            # Default behavior '=' is interpreted as upper bound '<='
3201
3123
            prevleg = leg
3202
3124
 
3203
3125
        if self['orders']:
 
3126
            keys = list(self['orders'].keys())
 
3127
            keys.sort(reverse=True)
3204
3128
            mystr = mystr + " ".join([key + '=' + repr(self['orders'][key]) \
3205
 
                       for key in self['orders']]) + ' '
 
3129
                       for key in keys]) + ' '
3206
3130
 
3207
3131
        # Add squared orders
3208
3132
        if self['squared_orders']:
3308
3232
        prevleg = None
3309
3233
        if pdg_order:
3310
3234
            legs = [l for l in self['legs'][1:]]
3311
 
            def order_leg(l1,l2):
3312
 
                id1 = l1.get('id')
3313
 
                id2 = l2.get('id')
3314
 
                return id2-id1
3315
 
            legs.sort(cmp=order_leg)
 
3235
            legs.sort(key=lambda x: x.get('id'))
3316
3236
            legs.insert(0, self['legs'][0])
3317
3237
        else:
3318
3238
            legs = self['legs']
3423
3343
        """ Check iteratively that no coupling order constraint include negative
3424
3344
        values."""
3425
3345
 
3426
 
        if any(val<0 for val in self.get('orders').values()+\
3427
 
                                           self.get('squared_orders').values()):
 
3346
        if any(val<0 for val in list(self.get('orders').values())+\
 
3347
                                           list(self.get('squared_orders').values())):
3428
3348
            return True
3429
3349
        
3430
3350
        for procdef in self['decay_chains']:
3452
3372
    def get_ninitial(self):
3453
3373
        """Gives number of initial state particles"""
3454
3374
 
3455
 
        return len(filter(lambda leg: leg.get('state') == False,
3456
 
                           self.get('legs')))
 
3375
        return len([leg for leg in self.get('legs') if leg.get('state') == False])
3457
3376
 
3458
3377
    def get_initial_ids(self):
3459
3378
        """Gives the pdg codes for initial state particles"""
3460
3379
 
3461
3380
        return [leg.get('id') for leg in \
3462
 
                filter(lambda leg: leg.get('state') == False,
3463
 
                       self.get('legs'))]
 
3381
                [leg for leg in self.get('legs') if leg.get('state') == False]]
3464
3382
 
3465
3383
    def get_initial_pdg(self, number):
3466
3384
        """Return the pdg codes for initial state particles for beam number"""
3467
3385
 
3468
 
        legs = filter(lambda leg: leg.get('state') == False and\
3469
 
                       leg.get('number') == number,
3470
 
                       self.get('legs'))
 
3386
        legs = [leg for leg in self.get('legs') if leg.get('state') == False and\
 
3387
                       leg.get('number') == number]
3471
3388
        if not legs:
3472
3389
            return None
3473
3390
        else:
3522
3439
    def get_final_legs(self):
3523
3440
        """Gives the final state legs"""
3524
3441
 
3525
 
        return filter(lambda leg: leg.get('state') == True,
3526
 
                       self.get('legs'))
 
3442
        return [leg for leg in self.get('legs') if leg.get('state') == True]
3527
3443
    
3528
3444
    def get_final_ids(self):
3529
3445
        """Gives the pdg codes for final state particles"""
3603
3519
            return 1
3604
3520
        if self.list_for_sort() < other.list_for_sort():
3605
3521
            return -1
 
3522
        assert self.list_for_sort() == other.list_for_sort()
3606
3523
        return 0
3607
3524
        
3608
3525
    def identical_particle_factor(self):
3609
3526
        """Calculate the denominator factor for identical final state particles
3610
3527
        """
3611
3528
 
3612
 
        
3613
 
        final_legs = filter(lambda leg: leg.get('state') == True, \
3614
 
                              self.get_legs_with_decays())
 
3529
        final_legs = [leg for leg in self.get_legs_with_decays() if leg.get('state') == True]
3615
3530
 
3616
3531
        identical_indices = collections.defaultdict(int)
3617
3532
        for leg in final_legs:
3635
3550
        for (k,v) in tmp:  
3636
3551
            if k in orders:
3637
3552
                if v < orders[k]:
3638
 
                    if k in sq_orders.keys() and \
 
3553
                    if k in list(sq_orders.keys()) and \
3639
3554
                                             (sq_orders[k]>v or sq_orders[k]<0):
3640
3555
                        logger.warning(
3641
3556
'''The process with the squared coupling order (%s^2%s%s) specified can potentially 
3659
3574
        if not isinstance(other, Process):
3660
3575
            return False
3661
3576
 
 
3577
        #misc.sprint("can we speed up this computation? Yes we can!")
3662
3578
        return self.compare_for_sort(other) == 0
 
3579
        return self.list_for_sort() == other.list_for_sort()
3663
3580
 
3664
3581
    def __ne__(self, other):
3665
3582
        return not self.__eq__(other)
3708
3625
 
3709
3626
        if name == 'legs':
3710
3627
            if not isinstance(value, MultiLegList):
3711
 
                raise self.PhysicsObjectError, \
3712
 
                        "%s is not a valid MultiLegList object" % str(value)
 
3628
                raise self.PhysicsObjectError("%s is not a valid MultiLegList object" % str(value))
3713
3629
        elif name == 'decay_chains':
3714
3630
            if not isinstance(value, ProcessDefinitionList):
3715
 
                raise self.PhysicsObjectError, \
3716
 
                        "%s is not a valid ProcessDefinitionList" % str(value)
 
3631
                raise self.PhysicsObjectError("%s is not a valid ProcessDefinitionList" % str(value))
3717
3632
 
3718
3633
        else:
3719
3634
            return super(ProcessDefinition, self).filter(name, value)