← Back to branch summary

~maddevelopers/mg5amcnlo/2.9.4

« back to all changes in this revision

Viewing changes to tests/unit_tests/core/test_drawing.py

pass to v2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit_tests/core/test_drawing.py
1
1
################################################################################
2
2
#
3
 
# Copyright (c) 2009 The MadGraph Development team and Contributors
 
3
# Copyright (c) 2009 The MadGraph5_aMC@NLO Development team and Contributors
4
4
#
5
 
# This file is a part of the MadGraph 5 project, an application which 
 
5
# This file is a part of the MadGraph5_aMC@NLO project, an application which 
6
6
# automatically generates Feynman diagrams and matrix elements for arbitrary
7
7
# high-energy processes in the Standard Model and beyond.
8
8
#
9
 
# It is subject to the MadGraph license which should accompany this 
 
9
# It is subject to the MadGraph5_aMC@NLO license which should accompany this 
10
10
# distribution.
11
11
#
12
 
# For more information, please visit: http://madgraph.phys.ucl.ac.be
 
12
# For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch
13
13
#
14
14
################################################################################
15
15
"""Unit test library for the routine creating the points position for the 
34
34
import tests.unit_tests as unittest
35
35
_file_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
36
36
 
37
 
# First define a valid model for Standard Model
38
 
_model = base_objects.Model()
39
 
# Import Particles information
40
 
_input_path = os.path.join(_file_path, '../input_files/v4_sm_particles.dat')
41
 
_model.set('particles', files.read_from_file(_input_path,
42
 
                                            import_v4.read_particles_v4))
43
 
# Import Interaction information
44
 
_input_path = os.path.join(_file_path , '../input_files/v4_sm_interactions.dat')
45
 
_model.set('interactions', files.read_from_file(_input_path, \
46
 
                                               import_v4.read_interactions_v4, \
47
 
                                               _model.get('particles')))
 
37
 
 
38
def define_model():
 
39
    global _model
 
40
    
 
41
    # First define a valid model for Standard Model
 
42
    _model = base_objects.Model()
 
43
    # Import Particles information
 
44
    _input_path = os.path.join(_file_path, '../input_files/v4_sm_particles.dat')
 
45
    _model.set('particles', files.read_from_file(_input_path,
 
46
                                                import_v4.read_particles_v4))
 
47
    # Import Interaction information
 
48
    _input_path = os.path.join(_file_path , '../input_files/v4_sm_interactions.dat')
 
49
    _model.set('interactions', files.read_from_file(_input_path, \
 
50
                                                   import_v4.read_interactions_v4, \
 
51
                                                   _model.get('particles')))
 
52
 
48
53
 
49
54
 
50
55
#===============================================================================
56
61
    def setUp(self):
57
62
        """ basic building of the class to test """
58
63
 
59
 
        self.my_line = drawing.FeynmanLine(11)
 
64
        self.my_line = drawing.FeynmanLine({'id':11})
60
65
        myleglist = base_objects.LegList([base_objects.Leg({'id':3,
61
66
                                      'number':5,
62
67
                                      'state':True,
79
84
                      'legs':myleglist}
80
85
        vertex = base_objects.Vertex(mydict)
81
86
 
82
 
        my_line = drawing.FeynmanLine(id)
 
87
        my_line = drawing.FeynmanLine({'id':id})
83
88
        my_vertex = drawing.VertexPoint(vertex)
84
89
        my_vertex.def_position(begin[0], begin[1])
85
90
        my_line.def_begin_point(my_vertex)
96
101
        leg = base_objects.Leg({'id': id, 'number': 1, 'state':False,
97
102
                            'from_group':False})
98
103
        #extend the leg to FeynmanLine Object
99
 
        my_line = drawing.FeynmanLine(leg.get('id'), base_objects.Leg(leg))
 
104
        my_line = drawing.FeynmanLine(base_objects.Leg(leg))
100
105
        my_line.def_model(_model)
101
106
 
102
107
        return my_line
105
110
        """Fast way to define a complete line"""
106
111
        my_line = self.def_model_line(id)
107
112
        temp_line = self.def_line(begin, end)
108
 
        my_line.def_begin_point(temp_line.start)
 
113
        my_line.def_begin_point(temp_line.begin)
109
114
        my_line.def_end_point(temp_line.end)
110
115
 
111
116
        return my_line
115
120
 
116
121
        #test begin point 
117
122
        self.my_line.def_begin_point(self.my_vertex)
118
 
        self.assertTrue(self.my_line.start is self.my_vertex)
 
123
        self.assertTrue(self.my_line.begin is self.my_vertex)
119
124
        self.my_line.def_begin_point(self.my_vertex2)
120
 
        self.assertTrue(self.my_line.start is self.my_vertex2)
 
125
        self.assertTrue(self.my_line.begin is self.my_vertex2)
121
126
 
122
127
        #test end point
123
 
        self.my_line.def_end_point(self.my_vertex2)
124
 
        self.assertTrue(self.my_line.end is self.my_vertex2)
125
128
        self.my_line.def_end_point(self.my_vertex)
126
129
        self.assertTrue(self.my_line.end is self.my_vertex)
 
130
        self.assertRaises(AssertionError,self.my_line.def_end_point, self.my_vertex2)
 
131
        self.assertTrue(self.my_line.end is self.my_vertex)
127
132
 
128
133
        #test if the vertex references the line correctly
129
134
        self.assertTrue(self.my_line in self.my_vertex.lines)
131
136
 
132
137
        #check that the swithching method runs fine.
133
138
        self.my_line.inverse_begin_end()
134
 
        self.assertTrue(self.my_line.start is self.my_vertex)
 
139
        self.assertTrue(self.my_line.begin is self.my_vertex)
135
140
        self.assertTrue(self.my_line.end is self.my_vertex2)
136
141
 
137
142
    def test_begin_end_wrong_input(self):
147
152
 
148
153
        #need to load SM?
149
154
        for id in [1, 2, 3, 4, 5, 6, 11, 12, 13, 14, 15]:
150
 
            my_line = drawing.FeynmanLine(id)
 
155
            my_line = drawing.FeynmanLine({'id':id})
151
156
            my_line.def_model(_model)
152
157
            self.assertEquals(my_line.get_info('line'), 'straight')
153
158
 
154
159
        for id in [25]:
155
 
            my_line = drawing.FeynmanLine(id)
 
160
            my_line = drawing.FeynmanLine({'id':id})
156
161
            my_line.def_model(_model)
157
162
            self.assertEquals(my_line.get_info('line'), 'dashed')
158
163
 
159
164
        for id in [22, 23, 24, -23, -24]:
160
 
            my_line = drawing.FeynmanLine(id)
 
165
            my_line = drawing.FeynmanLine({'id':id})
161
166
            my_line.def_model(_model)
162
167
            self.assertEquals(my_line.get_info('line'), 'wavy')
163
168
 
164
169
        for id in [21]:
165
 
            my_line = drawing.FeynmanLine(id)
 
170
            my_line = drawing.FeynmanLine({'id':id})
166
171
            my_line.def_model(_model)
167
172
            self.assertEquals(my_line.get_info('line'), 'curly')
168
173
 
169
174
        id = [21, 22, 23, 24, -23, -24]
170
 
        solution = ['g', 'a', 'z', 'w+', 'z', 'w-']
 
175
        solution = ['g', 'a', 'z', 'w-', 'z', 'w+']
171
176
        for i in range(0, len(id)):
172
 
            my_line = drawing.FeynmanLine(id[i])
 
177
            my_line = drawing.FeynmanLine({'id':id[i]})
173
178
            my_line.def_model(_model)
174
179
            self.assertEquals(my_line.get_name('name'), solution[i])
175
180
 
178
183
        """Test define correct flow for S-channel"""
179
184
 
180
185
        line = self.def_line(id= -22)
181
 
        line.start.def_level(0)
 
186
        line.begin.def_level(0)
182
187
        line.end.def_level(1)
183
188
 
184
189
        line.define_line_orientation()
185
 
        self.assertEqual(line.start.pos_x, 1)
186
 
        self.assertEqual(line.start.pos_y, 1)
 
190
        self.assertEqual(line.begin.pos_x, 1)
 
191
        self.assertEqual(line.begin.pos_y, 1)
187
192
        self.assertEqual(line.end.pos_x, 0)
188
193
        self.assertEqual(line.end.pos_y, 0)
189
194
 
190
195
 
191
196
        line.inverse_part_antipart()
192
197
        line.define_line_orientation()
193
 
        self.assertEqual(line.start.pos_x, 1)
194
 
        self.assertEqual(line.start.pos_y, 1)
 
198
        self.assertEqual(line.begin.pos_x, 1)
 
199
        self.assertEqual(line.begin.pos_y, 1)
195
200
        self.assertEqual(line.end.pos_x, 0)
196
201
        self.assertEqual(line.end.pos_y, 0)
197
202
 
201
206
        line = self.def_line([0, 0], [0, 0])
202
207
 
203
208
        line.inverse_part_antipart()
204
 
        self.assertEquals(line.pid, -11)
 
209
        self.assertEquals(line.id, -11)
205
210
        line.inverse_part_antipart()
206
 
        self.assertEquals(line.pid, 11)
 
211
        self.assertEquals(line.id, 11)
207
212
 
208
213
    def test_inverse_pid_for_type(self):
209
214
        """Test change particle in anti-particle for drawing type"""
218
223
        line3.inverse_pid_for_type('wavy')
219
224
        line4.inverse_pid_for_type('wavy')
220
225
 
221
 
        self.assertEquals(line1.pid, -24)
222
 
        self.assertEquals(line2.pid, 24)
223
 
        self.assertEquals(line3.pid, -22)
224
 
        self.assertEquals(line4.pid, 1)
 
226
        self.assertEquals(line1.id, -24)
 
227
        self.assertEquals(line2.id, 24)
 
228
        self.assertEquals(line3.id, -22)
 
229
        self.assertEquals(line4.id, 1)
225
230
 
226
231
        line1.inverse_pid_for_type()
227
232
        line2.inverse_pid_for_type()
228
233
        line3.inverse_pid_for_type()
229
234
        line4.inverse_pid_for_type()
230
235
 
231
 
        self.assertEquals(line1.pid, -24)
232
 
        self.assertEquals(line2.pid, 24)
233
 
        self.assertEquals(line3.pid, -22)
234
 
        self.assertEquals(line4.pid, -1)
 
236
        self.assertEquals(line1.id, -24)
 
237
        self.assertEquals(line2.id, 24)
 
238
        self.assertEquals(line3.id, -22)
 
239
        self.assertEquals(line4.id, -1)
235
240
 
236
241
    def test_domain_intersection(self):
237
242
        """ Test domain intersection between two FeynmanLine """
506
511
    def setUp(self):
507
512
        """basic building of the class to test"""
508
513
 
509
 
        self.line1 = drawing.FeynmanLine(11)
510
 
        self.line2 = drawing.FeynmanLine(11)
511
 
        self.line3 = drawing.FeynmanLine(11)
512
 
        self.line4 = drawing.FeynmanLine(11)
 
514
        self.line1 = drawing.FeynmanLine({'id':11})
 
515
        self.line2 = drawing.FeynmanLine({'id':11})
 
516
        self.line3 = drawing.FeynmanLine({'id':11})
 
517
        self.line4 = drawing.FeynmanLine({'id':11})
513
518
        self.myleglist = base_objects.LegList([base_objects.Leg({'id':3,
514
519
                                      'number':5,
515
520
                                      'state':True,
643
648
        vertexpoint = drawing.VertexPoint(vertex)
644
649
        leg1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
645
650
                            'from_group':False})
646
 
        line1 = drawing.FeynmanLine(22, leg1)
 
651
        line1 = drawing.FeynmanLine(leg1)
647
652
        line1.def_begin_point(vertexpoint)
648
653
 
649
654
        self.assertTrue(vertexpoint.is_external())
674
679
        #pass in Drawing object
675
680
        vertex1 = drawing.VertexPoint(vertex1)
676
681
        vertex2 = drawing.VertexPoint(vertex2)
677
 
        line1 = drawing.FeynmanLine(22, leg1)
678
 
        line2 = drawing.FeynmanLine(22, leg2)
679
 
        line3 = drawing.FeynmanLine(22, leg3)
680
 
        line4 = drawing.FeynmanLine(22, leg4)
681
 
        line_s = drawing.FeynmanLine(22, leg_s)
 
682
        line1 = drawing.FeynmanLine(leg1)
 
683
        line2 = drawing.FeynmanLine(leg2)
 
684
        line3 = drawing.FeynmanLine(leg3)
 
685
        line4 = drawing.FeynmanLine(leg4)
 
686
        line_s = drawing.FeynmanLine(leg_s)
682
687
 
683
688
        #link object
684
689
        line1.def_end_point(vertex1)
700
705
        self.assertEqual(len([l for l in vertex1.lines if l is line_s]), 0)
701
706
 
702
707
        #check that line3-line4 begin vertex are correctly modify
703
 
        self.assertTrue(vertex1 is line3.start)
704
 
        self.assertTrue(vertex1 is line4.start)
 
708
        self.assertTrue(vertex1 is line3.begin)
 
709
        self.assertTrue(vertex1 is line4.begin)
705
710
        self.assertTrue(vertex1 is line1.end)
706
711
        self.assertTrue(vertex1 is line2.end)
707
712
 
713
718
    """Test the object which compute the position of the vertex/line 
714
719
        for a given Diagram object
715
720
    """
716
 
 
717
 
    #test diagram gg>gg via a T-channel
718
 
    leg1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
719
 
                            'from_group':False})
720
 
    leg2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
721
 
                            'from_group':False})
722
 
    leg3 = base_objects.Leg({'id':22, 'number':3, 'state':True,
723
 
                            'from_group':False})
724
 
    leg4 = base_objects.Leg({'id':22, 'number':4, 'state':True,
725
 
                            'from_group':False})
726
 
 
727
 
    #intermediate particle +vertex associate
728
 
    leg_t1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
729
 
                        'from_group':True})
730
 
    vertex1 = base_objects.Vertex({'id':1, \
731
 
                        'legs':base_objects.LegList([leg1, leg3, leg_t1])})
732
 
 
733
 
    leg_t2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
734
 
                        'from_group':True})
735
 
    vertex2 = base_objects.Vertex({'id':2, \
736
 
                        'legs':base_objects.LegList([leg2, leg4, leg_t2])})
737
 
 
738
 
    vertex3 = base_objects.Vertex({'id':0, \
739
 
                        'legs':base_objects.LegList([leg_t1, leg_t2])})
740
 
 
741
 
    vertexlist = base_objects.VertexList([vertex1, vertex2, vertex3])
742
 
    t_diagram_dict = {'vertices':vertexlist}
743
 
 
744
 
    #test diagram gg>gg via a S-channel
745
 
    leg1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
746
 
                            'from_group':False})
747
 
    leg2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
748
 
                            'from_group':False})
749
 
    leg3 = base_objects.Leg({'id':22, 'number':3, 'state':True,
750
 
                            'from_group':False})
751
 
    leg4 = base_objects.Leg({'id':22, 'number':4, 'state':True,
752
 
                            'from_group':False})
753
 
 
754
 
    #intermediate particle +vertex associate
755
 
    leg_s = base_objects.Leg({'id':22, 'number':1, 'state':True,
756
 
                        'from_group':True})
757
 
    vertex1 = base_objects.Vertex({'id':1, \
758
 
                        'legs':base_objects.LegList([leg1, leg2, leg_s])})
759
 
 
760
 
    leg_temp = base_objects.Leg({'id':22, 'number':1, 'state':True,
761
 
                            'from_group':False})
762
 
 
763
 
    vertex2 = base_objects.Vertex({'id':2, \
764
 
                        'legs':base_objects.LegList([leg_s, leg3, leg_temp])})
765
 
 
766
 
    vertex3 = base_objects.Vertex({'id':0, \
767
 
                        'legs':base_objects.LegList([leg_temp, leg4])})
768
 
 
769
 
    vertexlist = base_objects.VertexList([vertex1, vertex2, vertex3])
770
 
    s_diagram_dict = {'vertices':vertexlist}
771
 
 
772
 
 
773
 
    # Recover some diagram causing crashes or having some interesting feature
774
 
    #in order to ensure that those problem will not appear again. 
775
 
    #Those diagrams were keep in a pickle format"""
776
 
    filehandler = open(os.path.join(_file_path, \
777
 
                                    '../input_files/test_draw.obj'), 'r')
778
 
    store_diagram = pickle.load(filehandler)
779
 
 
780
 
 
 
721
    
 
722
    @classmethod
 
723
    def class_init(cls):
 
724
        try:
 
725
            _model
 
726
        except:
 
727
            define_model()
 
728
        
 
729
        
 
730
        #test diagram gg>gg via a T-channel
 
731
        leg1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
 
732
                                'from_group':False})
 
733
        leg2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
 
734
                                'from_group':False})
 
735
        leg3 = base_objects.Leg({'id':22, 'number':3, 'state':True,
 
736
                                'from_group':False})
 
737
        leg4 = base_objects.Leg({'id':22, 'number':4, 'state':True,
 
738
                                'from_group':False})
 
739
    
 
740
        #intermediate particle +vertex associate
 
741
        leg_t1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
 
742
                            'from_group':True})
 
743
        vertex1 = base_objects.Vertex({'id':1, \
 
744
                            'legs':base_objects.LegList([leg1, leg3, leg_t1])})
 
745
    
 
746
        leg_t2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
 
747
                            'from_group':True})
 
748
        vertex2 = base_objects.Vertex({'id':2, \
 
749
                            'legs':base_objects.LegList([leg2, leg4, leg_t2])})
 
750
    
 
751
        vertex3 = base_objects.Vertex({'id':0, \
 
752
                            'legs':base_objects.LegList([leg_t1, leg_t2])})
 
753
    
 
754
        vertexlist = base_objects.VertexList([vertex1, vertex2, vertex3])
 
755
        cls.t_diagram_dict = {'vertices':vertexlist}
 
756
    
 
757
        #test diagram gg>gg via a S-channel
 
758
        leg1 = base_objects.Leg({'id':22, 'number':1, 'state':False,
 
759
                                'from_group':False})
 
760
        leg2 = base_objects.Leg({'id':22, 'number':2, 'state':False,
 
761
                                'from_group':False})
 
762
        leg3 = base_objects.Leg({'id':22, 'number':3, 'state':True,
 
763
                                'from_group':False})
 
764
        leg4 = base_objects.Leg({'id':22, 'number':4, 'state':True,
 
765
                                'from_group':False})
 
766
    
 
767
        #intermediate particle +vertex associate
 
768
        leg_s = base_objects.Leg({'id':22, 'number':1, 'state':True,
 
769
                            'from_group':True})
 
770
        vertex1 = base_objects.Vertex({'id':1, \
 
771
                            'legs':base_objects.LegList([leg1, leg2, leg_s])})
 
772
    
 
773
        leg_temp = base_objects.Leg({'id':22, 'number':1, 'state':True,
 
774
                                'from_group':False})
 
775
    
 
776
        vertex2 = base_objects.Vertex({'id':2, \
 
777
                            'legs':base_objects.LegList([leg_s, leg3, leg_temp])})
 
778
    
 
779
        vertex3 = base_objects.Vertex({'id':0, \
 
780
                            'legs':base_objects.LegList([leg_temp, leg4])})
 
781
    
 
782
        vertexlist = base_objects.VertexList([vertex1, vertex2, vertex3])
 
783
        cls.s_diagram_dict = {'vertices':vertexlist}
 
784
        # Recover some diagram causing crashes or having some interesting feature
 
785
        #in order to ensure that those problem will not appear again. 
 
786
        #Those diagrams were keep in a pickle format"""
 
787
        filehandler = open(os.path.join(_file_path, \
 
788
                                '../input_files/test_draw.obj'), 'r')
 
789
        cls.store_diagram = pickle.load(filehandler)
781
790
 
782
791
    def setUp(self):
783
792
        """Basic building of the object needed to build the test"""
784
 
 
 
793
        
 
794
        if not hasattr(self, 'store_diagram'):
 
795
            self.class_init()
 
796
        
 
797
            
 
798
            
785
799
        opt = drawing.DrawOption({'external':1, 'horizontal':1, 'max_size':0})
786
800
        # gg>g(g>uux)g (via a T channel)  
787
801
        mix_diagram = self.store_diagram['g g > g g u u~'][18]
852
866
        begin_tag = [1, 131, 131, 2, 242, 521, 565, 565, 521]
853
867
        end_tag = [131, 3, 521, 242, 4, 242, 5, 6, 565]
854
868
        for i, line in enumerate(self.mix_drawing.lineList):
855
 
            self.assertEquals(self.vertex_identification(line.start), \
 
869
            self.assertEquals(self.vertex_identification(line.begin), \
856
870
                                                                   begin_tag[i])
857
871
            self.assertEquals(self.vertex_identification(line.end), \
858
872
                                                                   end_tag[i])
866
880
        tag = [(1, 131), (131, 3), (131, 151), (2, 242), (242, 4), (162, 242), (151, 5),
867
881
             (151, 162), (162, 6)]
868
882
        for i, line in enumerate(diagram.lineList):
869
 
            self.assertEquals(self.vertex_identification(line.start), \
 
883
            self.assertEquals(self.vertex_identification(line.begin), \
870
884
                                                                   tag[i][0])
871
885
            self.assertEquals(self.vertex_identification(line.end), \
872
886
                                                                   tag[i][1])
947
961
            self.assertAlmostEquals(vertex.pos_x, sol[i][0])
948
962
            self.assertAlmostEquals(vertex.pos_y, sol[i][1])
949
963
 
950
 
        vertexlist_l2 = self.mix_drawing.find_vertex_at_level(vertexlist_l1)
 
964
        vertexlist_l2 = self.mix_drawing.find_vertex_at_level(vertexlist_l1,
 
965
                                                     vertexlist_l1[0].level + 1)
951
966
        self.assertEquals(len(vertexlist_l2), 3)
952
967
 
953
968
        #ask to update of level 2 +check that wa can assign position
954
 
        self.mix_drawing.find_vertex_position_at_level(vertexlist_l1, 2, auto=0)
 
969
        self.mix_drawing.find_vertex_position_at_level(vertexlist_l1, 2, 
 
970
                                                                    direction=0)
955
971
 
956
972
        #check position
957
973
        vertexlist = [vertex for vertex in self.mix_drawing.vertexList if\
1037
1053
            self.assertAlmostEquals(diagram.vertexList[i].pos_y, \
1038
1054
                              y_position[i])
1039
1055
        for line in diagram.lineList:
1040
 
            self.assertNotEquals(line.start, None)
 
1056
            self.assertNotEquals(line.begin, None)
1041
1057
            self.assertNotEquals(line.end, None)
1042
1058
 
1043
1059
 
1075
1091
            self.assertAlmostEquals(diagram.vertexList[i].pos_y, \
1076
1092
                              y_position[i])
1077
1093
        for line in diagram.lineList:
1078
 
            self.assertNotEquals(line.start, None)
 
1094
            self.assertNotEquals(line.begin, None)
1079
1095
            self.assertNotEquals(line.end, None)
1080
1096
        
1081
1097
 
1180
1196
            self.assertAlmostEquals(diagram.vertexList[i].pos_y, \
1181
1197
                              y_position[i])
1182
1198
        for line in diagram.lineList:
1183
 
            self.assertNotEquals(line.start, None)
 
1199
            self.assertNotEquals(line.begin, None)
1184
1200
            self.assertNotEquals(line.end, None)
1185
1201
 
1186
1202
        #test the T-channel
1206
1222
            self.assertAlmostEquals(diagram.vertexList[i].pos_y, \
1207
1223
                              y_position[i])
1208
1224
        for line in diagram.lineList:
1209
 
            self.assertNotEquals(line.start, None)
 
1225
            self.assertNotEquals(line.begin, None)
1210
1226
            self.assertNotEquals(line.end, None)
1211
1227
 
1212
1228
    def test_fermion_flow(self):
1216
1232
        diagram = self.store_diagram['mu+ mu- > w+ w- a'][7]
1217
1233
        diagram = drawing.FeynmanDiagramHorizontal(diagram, _model)
1218
1234
        diagram.main()
1219
 
        t_lines = [line for line in diagram.lineList if line.start.level == 1
 
1235
        t_lines = [line for line in diagram.lineList if line.begin.level == 1
1220
1236
                                                and line.end.level == 1]
1221
1237
 
1222
1238
        for line in t_lines:
1223
1239
            if line.is_fermion():
1224
 
                self.assertTrue(line.start.pos_y > line.end.pos_y)
 
1240
                self.assertTrue(line.begin.pos_y > line.end.pos_y)
1225
1241
 
1226
1242
        # Load diagram with two fermion flow
1227
1243
        diagram = self.store_diagram['mu+ mu- > w+ w- a'][6]
1228
1244
        diagram = drawing.FeynmanDiagramHorizontal(diagram, _model)
1229
1245
        diagram.main()
1230
 
        t_lines = [line for line in diagram.lineList if line.start.level == 1
 
1246
        t_lines = [line for line in diagram.lineList if line.begin.level == 1
1231
1247
                                                and line.end.level == 1]
1232
1248
 
1233
1249
        for line in t_lines:
1234
1250
            if line.is_fermion():
1235
 
                self.assertTrue(line.start.pos_y > line.end.pos_y)
 
1251
                self.assertTrue(line.begin.pos_y > line.end.pos_y)
1236
1252
 
1237
1253
        # One fermion flow but in opposite direction
1238
1254
        diagram = self.store_diagram['g g > g g u u~'][100]
1239
1255
        diagram = drawing.FeynmanDiagramHorizontal(diagram, _model)
1240
1256
        diagram.main()
1241
 
        t_lines = [line for line in diagram.lineList if line.start.level == 1
 
1257
        t_lines = [line for line in diagram.lineList if line.begin.level == 1
1242
1258
                                                and line.end.level == 1]
1243
1259
 
1244
1260
        for line in t_lines:
1245
1261
            if line.is_fermion():
1246
 
                self.assertTrue(line.start.pos_y > line.end.pos_y)
 
1262
                self.assertTrue(line.begin.pos_y > line.end.pos_y)
1247
1263
                
1248
1264
        # Two fermion in opposite direction
1249
1265
        diagram = self.store_diagram['u u > z u u g'][26]
1250
1266
        diagram = drawing.FeynmanDiagramHorizontal(diagram, _model)
1251
1267
        diagram.main()
1252
 
        t_lines = [line for line in diagram.lineList if line.start.level == 1
 
1268
        t_lines = [line for line in diagram.lineList if line.begin.level == 1
1253
1269
                                                and line.end.level == 1]
1254
1270
        
1255
1271
        for line in t_lines:
1256
1272
            if line.is_fermion():
1257
 
                self.assertTrue(line.start.pos_y > line.end.pos_y)
 
1273
                self.assertTrue(line.begin.pos_y > line.end.pos_y)
1258
1274
                
1259
1275
        
1260
1276
        # Two fermion in opposite direction
1261
1277
        diagram = self.store_diagram['u~ u~ > z u~ u~ g'][26]
1262
1278
        diagram = drawing.FeynmanDiagramHorizontal(diagram, _model)
1263
1279
        diagram.main()
1264
 
        t_lines = [line for line in diagram.lineList if line.start.level == 1
 
1280
        t_lines = [line for line in diagram.lineList if line.begin.level == 1
1265
1281
                                                and line.end.level == 1]
1266
1282
        
1267
1283
        for line in t_lines:
1268
1284
            if line.is_fermion():
1269
 
                self.assertTrue(line.start.pos_y < line.end.pos_y)           
 
1285
                self.assertTrue(line.begin.pos_y < line.end.pos_y)           
1270
1286
 
1271
1287
    def test_part_antipart_after_output(self):
1272
1288
        """Check that the fermion flow is correct before and after output command
1278
1294
        diagram.main()
1279
1295
        
1280
1296
        #select the s-channel lepton
1281
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1297
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1282
1298
                                                and line.end.level in [2,3]][0]
1283
 
        
1284
 
        self.assertEqual(line.pid, 11)
1285
 
        self.assertEqual(line.start.level, 2)
 
1299
 
 
1300
        self.assertEqual(line.id, 11)
 
1301
        self.assertEqual(line.begin.level, 2)
1286
1302
        self.assertEqual(line.end.level, 3)
1287
1303
        
1288
1304
        # Do the same for after the output command:
1292
1308
        diagram.main()
1293
1309
        
1294
1310
        #select the s-channel lepton
1295
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1311
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1296
1312
                                                and line.end.level in [2,3]][0]
1297
1313
        
1298
 
        self.assertEqual(line.pid, 11)
1299
 
        self.assertEqual(line.start.level, 2)
 
1314
        self.assertEqual(line.id, 11)
 
1315
        self.assertEqual(line.begin.level, 2)
1300
1316
        self.assertEqual(line.end.level, 3)      
1301
1317
 
1302
1318
 
1314
1330
        diagram.main()
1315
1331
        
1316
1332
        #select the s-channel W
1317
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1333
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1318
1334
                                                and line.end.level in [2,3]][0]        
1319
1335
        
1320
 
        self.assertEqual(line.pid, 24)
1321
 
        self.assertEqual(line.start.level, 2)
 
1336
        self.assertEqual(line.id, 24)
 
1337
        self.assertEqual(line.begin.level, 2)
1322
1338
        self.assertEqual(line.end.level, 3)
1323
1339
        
1324
1340
        # Do the same for after the output command:
1332
1348
        diagram.main()
1333
1349
        
1334
1350
        #select the s-channel lepton
1335
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1351
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1336
1352
                                                and line.end.level in [2,3]][0]
1337
1353
        
1338
 
        self.assertEqual(line.pid, 24)
1339
 
        self.assertEqual(line.start.level, 2)
 
1354
        self.assertEqual(line.id, 24)
 
1355
        self.assertEqual(line.begin.level, 2)
1340
1356
        self.assertEqual(line.end.level, 3)  
1341
1357
 
1342
1358
        #
1353
1369
        diagram.main()
1354
1370
        
1355
1371
        #select the s-channel W
1356
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1372
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1357
1373
                                                and line.end.level in [2,3]][0]        
1358
1374
        
1359
 
        self.assertEqual(line.pid, 24)
1360
 
        self.assertEqual(line.start.level, 2)
 
1375
        self.assertEqual(line.id, 24)
 
1376
        self.assertEqual(line.begin.level, 2)
1361
1377
        self.assertEqual(line.end.level, 3)
1362
1378
        
1363
1379
        # Do the same for after the output command:
1371
1387
        diagram.main()
1372
1388
        
1373
1389
        #select the s-channel lepton
1374
 
        line = [line for line in diagram.lineList if line.start.level in [2,3]
 
1390
        line = [line for line in diagram.lineList if line.begin.level in [2,3]
1375
1391
                                                and line.end.level in [2,3]][0]
1376
1392
        
1377
 
        self.assertEqual(line.pid, 24)
1378
 
        self.assertEqual(line.start.level, 2)
 
1393
        self.assertEqual(line.id, 24)
 
1394
        self.assertEqual(line.begin.level, 2)
1379
1395
        self.assertEqual(line.end.level, 3) 
1380
1396
 
1381
1397
        #
1389
1405
        #print diagram._debug_level()        
1390
1406
        diagram.main()
1391
1407
        #select the s-channel W
1392
 
        line1 = [line for line in diagram.lineList if line.start.level in [2,3]
 
1408
        line1 = [line for line in diagram.lineList if line.begin.level in [2,3]
1393
1409
                                                and line.end.level in [2,3]][0]        
1394
 
        line2 = [line for line in diagram.lineList if line.start.level in [3,4]
 
1410
        line2 = [line for line in diagram.lineList if line.begin.level in [3,4]
1395
1411
                                                and line.end.level in [4,3]][0] 
1396
 
        line3 = [line for line in diagram.lineList if line.start.level in [2,5]
 
1412
        line3 = [line for line in diagram.lineList if line.begin.level in [2,5]
1397
1413
                                                and line.end.level in [2,5]][0] 
1398
 
        self.assertEqual(line3.pid, -24)
 
1414
        self.assertEqual(line3.id, -24)
1399
1415
        
1400
 
        self.assertEqual(line1.pid, line2.pid)
1401
 
        self.assertEqual(line1.pid, 24)
1402
 
        self.assertEqual(line1.start.level, 2)
 
1416
        self.assertEqual(line1.id, line2.id)
 
1417
        self.assertEqual(line1.id, 24)
 
1418
        self.assertEqual(line1.begin.level, 2)
1403
1419
        self.assertEqual(line1.end.level, 3)
1404
 
        self.assertEqual(line2.start.level, 3)
 
1420
        self.assertEqual(line2.begin.level, 3)
1405
1421
        self.assertEqual(line2.end.level, 4)        
1406
1422
        # Do the same for after the output command:
1407
1423
        # Load diagram with one fermion flow 
1411
1427
        diagram.main()
1412
1428
        
1413
1429
        #select the s-channel W
1414
 
        line1 = [line for line in diagram.lineList if line.start.level in [2,3]
 
1430
        line1 = [line for line in diagram.lineList if line.begin.level in [2,3]
1415
1431
                                                and line.end.level in [2,3]][0]        
1416
 
        line2 = [line for line in diagram.lineList if line.start.level in [3,4]
 
1432
        line2 = [line for line in diagram.lineList if line.begin.level in [3,4]
1417
1433
                                                and line.end.level in [4,3]][0] 
1418
1434
        
1419
 
        self.assertEqual(line1.pid, line2.pid)
1420
 
        self.assertEqual(line1.pid, 24)
1421
 
        self.assertEqual(line1.start.level, 2)
 
1435
        self.assertEqual(line1.id, line2.id)
 
1436
        self.assertEqual(line1.id, 24)
 
1437
        self.assertEqual(line1.begin.level, 2)
1422
1438
        self.assertEqual(line1.end.level, 3)
1423
 
        self.assertEqual(line2.start.level, 3)
 
1439
        self.assertEqual(line2.begin.level, 3)
1424
1440
        self.assertEqual(line2.end.level, 4)    
1425
1441
 
1426
1442
 
1564
1580
        diagram.adjust_position()
1565
1581
        for line in diagram.lineList:
1566
1582
            if line.is_external() and line.number in [5, 7]:
1567
 
                dist = (line.end.pos_x - line.start.pos_x) * diagram.max_level
 
1583
                dist = (line.end.pos_x - line.begin.pos_x) * diagram.max_level
1568
1584
                self.assertEquals(dist, 1.5)
1569
1585
        
1570
1586