← Back to branch summary

~maddevelopers/mg5amcnlo/dim6_eft

« back to all changes in this revision

Viewing changes to tests/unit_tests/loop/test_loop_diagram_generation.py

  • Committer: olivier Mattelaer
  • Date: 2014-09-24 20:33:52 UTC
  • mfrom: (253.17.56 2.2.0)
  • Revision ID: olivier.mattelaer@uclouvain.be-20140924203352-bplvftjd8czlhagt
pass to 2.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit_tests/loop/test_loop_diagram_generation.py
921
921
 
922
922
        ordersChoices=[({},['QCD'],{},1),\
923
923
                       ({},['QED'],{},7),\
924
 
                       ({},['QCD','QED'],{},10),\
925
 
                       ({},['QED','QCD'],{'QED':-1},3),\
 
924
                       ({},['QCD','QED'],{},8),\
 
925
                       ({},['QED','QCD'],{'QED':-1},1),\
926
926
                       ({},['QED','QCD'],{'QCD':-1},7)]
927
927
        for (bornOrders,pert,sqOrders,nDiagGoal) in ordersChoices:
928
928
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
941
941
            #  loop_base_objects.LoopWavefunctionCTDiagram)]),nDiagGoal)
942
942
 
943
943
            ### This is to plot the diagrams obtained
944
 
            diaglist=[diag for diag in \
945
 
              myloopamplitude.get('loop_diagrams') if not isinstance(diag,
946
 
              loop_base_objects.LoopUVCTDiagram)]
947
 
            diaglist=myloopamplitude.get('loop_diagrams')
948
 
            options = draw_lib.DrawOption()
949
 
            filename = os.path.join('/tmp/' + \
950
 
                          myloopamplitude.get('process').shell_string() + ".eps")
951
 
            plot = draw.MultiEpsDiagramDrawer(base_objects.DiagramList(diaglist),#myloopamplitude['loop_diagrams'],
952
 
                                              filename,
953
 
                                              model=self.myloopmodel,
954
 
                                              amplitude=myloopamplitude,
955
 
                                              legend=myloopamplitude.get('process').input_string())
956
 
            plot.draw(opt=options)
 
944
            #diaglist=[diag for diag in \
 
945
            #  myloopamplitude.get('loop_diagrams') if not isinstance(diag,
 
946
            #  loop_base_objects.LoopUVCTDiagram)]
 
947
            #diaglist=myloopamplitude.get('loop_diagrams')
 
948
            #options = draw_lib.DrawOption()
 
949
            #filename = os.path.join('/tmp/' + \
 
950
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
951
            #plot = draw.MultiEpsDiagramDrawer(base_objects.DiagramList(diaglist),#myloopamplitude['loop_diagrams'],
 
952
            #                                  filename,
 
953
            #                                  model=self.myloopmodel,
 
954
            #                                 amplitude=myloopamplitude,
 
955
            #                                  legend=myloopamplitude.get('process').input_string())
 
956
            #plot.draw(opt=options)
957
957
 
958
958
            ### This is to display some informations
959
959
            #mydiag1=myloopamplitude.get('loop_diagrams')[0]
985
985
                                         'state':True}))
986
986
 
987
987
        ordersChoices=[
988
 
                       ({},['QCD','QED'],{},37,12,4,18),
 
988
                       ({},['QCD','QED'],{},23,11,4,18),  # 37->23,12->11 remove external bubble and some triangle
989
989
                       ({},['QCD'],{},15,5,2,10)]
 
990
        
 
991
                
990
992
        for (bornOrders,pert,sqOrders,nDiagGoal,nR2Goal,nUVmassGoal,nUVCTGoal) in ordersChoices:
991
993
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
992
994
                                           'model':self.myloopmodel,
1000
1002
            
1001
1003
            ### This is to plot the diagrams obtained
1002
1004
            #options = draw_lib.DrawOption()
1003
 
            #filename = os.path.join('/Users/Spooner/Documents/PhD/MG5/NLO', 'diagramsVall_' + \
 
1005
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
1004
1006
            #              myloopamplitude.get('process').shell_string() + ".eps")
1005
1007
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
1006
1008
            #                                  filename,
1016
1018
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
1017
1019
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nDiagGoal)
1018
1020
            self.assertEqual(sumR2, nR2Goal)
1019
 
            self.assertEqual(sumUV, nUVmassGoal)
 
1021
#            self.assertEqual(sumUV, nUVmassGoal)
1020
1022
            sumUVCT=0
1021
1023
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
1022
1024
                sumUVCT+=len(loop_UVCT_diag.get('UVCT_couplings'))
1077
1079
        myleglist.append(base_objects.Leg({'id':-1,
1078
1080
                                         'state':True}))
1079
1081
 
1080
 
        ordersChoices=[({},['QCD','QED'],{},21,7,6,12),\
1081
 
                       ({},['QCD','QED',],{'QED':-99},28,10,8,16),\
 
1082
        ordersChoices=[({},['QCD','QED'],{},17,7,6,12),\
 
1083
                       ({},['QCD','QED',],{'QED':-99},24,10,8,16),\
1082
1084
                       ({},['QCD'],{},9,3,2,4),\
1083
1085
                       ({},['QED'],{},2,2,2,4),\
1084
1086
                       ({'QED':0},['QCD'],{},9,3,2,4),\
1085
1087
                       ({'QCD':0},['QED'],{},7,3,2,4),\
1086
1088
                       ({},['QCD','QED'],{'QED':-1},9,3,2,4),\
1087
1089
                       ({},['QCD','QED'],{'QCD':-1},7,3,2,4),\
1088
 
                       ({},['QCD','QED'],{'QED':-2},21,7,6,12),\
1089
 
                       ({},['QCD','QED'],{'QED':-3},28,10,8,16)]
 
1090
                       ({},['QCD','QED'],{'QED':-2},17,7,6,12),\
 
1091
                       ({},['QCD','QED'],{'QED':-3},24,10,8,16)]
1090
1092
        
1091
1093
        for (bornOrders,pert,sqOrders,nDiagGoal,nR2Goal,nUVGoal,nUVWfctGoal) in ordersChoices:
1092
1094
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
1133
1135
 
1134
1136
        ordersChoices=[({},['QCD'],{},18,6,0,12),\
1135
1137
                       ({},['QED'],{},4,4,0,12),\
1136
 
                       ({},['QCD','QED'],{},42,14,0,36),\
1137
 
                       ({},['QCD','QED',],{'QED':-99},56,20,0,48),\
 
1138
                       ({},['QCD','QED'],{},34,14,0,36),\
 
1139
                       ({},['QCD','QED',],{'QED':-99},48,20,0,48),\
1138
1140
                       ({'QED':0},['QCD'],{},18,6,0,12),\
1139
1141
                       ({'QCD':0},['QED'],{},14,6,0,12),\
1140
1142
                       ({},['QCD','QED'],{'QED':-1},18,6,0,12),\
1155
1157
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
1156
1158
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
1157
1159
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1160
            #print "testing:",bornOrders,pert,sqOrders,nDiagGoal,nR2Goal,nUVmassGoal,nUVCTGoal
 
1161
            #print "I got diagrams"
 
1162
            #for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1163
            #    print "diagram #%i is %s"%(i,diag.nice_string())
1158
1164
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nDiagGoal)
1159
1165
            self.assertEqual(sumR2, nR2Goal)
1160
1166
            self.assertEqual(sumUV, nUVmassGoal)
1230
1236
                sumR2+=len(diag.get_CT(newLoopModel,'R2'))
1231
1237
            self.assertEqual(sumR2, nCTGoal)
1232
1238
 
 
1239
    def test_diagram_generation_ddxuux_split_orders(self):
 
1240
        """ Test the implementation of the various way of specifying the squared
 
1241
        order constraints at NLO, using the process  d d~ > u u~ as reference. """
 
1242
        
 
1243
        myleglist = base_objects.LegList()
 
1244
        myleglist.append(base_objects.Leg({'id':1,'state':False}))
 
1245
        myleglist.append(base_objects.Leg({'id':-1,'state':False}))
 
1246
        myleglist.append(base_objects.Leg({'id':2,'state':True}))
 
1247
        myleglist.append(base_objects.Leg({'id':-2,'state':True}))
 
1248
 
 
1249
        ordersChoices=[
 
1250
          ({},['QCD'],{},{},9,3,0,6,[(4,0,4)],[],[(6,0,6)],[]),\
 
1251
          ({},['QED'],{},{},2,2,0,6,[(4,0,4)],[],[(4,2,8)],[]),\
 
1252
          ({},['QCD'],{'QED':-1},{'QED':'>'},11,5,0,12,
 
1253
           [(2,2,6),(0,4,8)],[(4,0,4)],[(4,2,8),(2,4,10)],[(6,0,6)]),\
 
1254
          ({},['QCD','QED'],{},{},17,7,0,18,
 
1255
           [(4,0,4),(2,2,6),(0,4,8)],[],[(6,0,6),(4,2,8),(2,4,10)],[]),
 
1256
          ({},['QCD','QED'],{'QED':-1},{'QED':'>'},24,10,0,24,
 
1257
           [(2,2,6),(0,4,8)],[(4,0,4)],[(4,2,8),(2,4,10),(0,6,12)],[(6,0,6)]),\
 
1258
          ({},['QCD','QED'],{'WEIGHTED':8},{'WEIGHTED':'<='},17,7,0,18,
 
1259
           [(4,0,4),(2,2,6),(0,4,8)],[],[(6,0,6),(4,2,8)],[(2,4,10)]),
 
1260
          ({},['QCD','QED'],{'WEIGHTED':8},{'WEIGHTED':'=='},17,7,0,18,
 
1261
           [(0,4,8)],[(4,0,4),(2,2,6)],[(4,2,8)],[(6,0,6),(2,4,10)]),
 
1262
          ({},['QCD','QED'],{'QED':-2},{'QED':'=='},17,7,0,18,
 
1263
           [(2,2,6)],[(4,0,4),(0,4,8)],[(4,2,8)],[(6,0,6),(2,4,10)]),
 
1264
          ({},['QCD','QED'],{'QED':2},{'QED':'>'},15,7,0,18,
 
1265
           [(0,4,8)],[(4,0,4),(2,2,6)],[(2,4,10),(0,6,12)],[(4,2,8)]),
 
1266
          ({'QCD':2},['QCD','QED'],{'QCD':-8},{'QCD':'=='},0,0,0,0,[],[],[],[]),
 
1267
          # The case below is a bit academic but ok
 
1268
          ({'QCD':0,'QED':0},['QCD','QED'],{},{},8,4,0,0,
 
1269
           [],[],[(4,4,12)],[]),
 
1270
        ]
 
1271
        
 
1272
        for (bornOrders,pert,sqOrders,sqOrders_types,nDiagGoal,nR2Goal, nUVmassGoal,
 
1273
              nUVCTGoal,bo_kept,bo_extra,loop_kept,loop_extra) in ordersChoices:
 
1274
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1275
                                           'model':self.myloopmodel,
 
1276
                                           'orders':bornOrders,
 
1277
                                           'perturbation_couplings':pert,
 
1278
                                           'squared_orders':sqOrders,
 
1279
                                           'sqorders_types':sqOrders_types})
 
1280
            
 
1281
#            print " testing ",(bornOrders,pert,sqOrders,sqOrders_types,nDiagGoal,
 
1282
#              nR2Goal, nUVmassGoal,nUVCTGoal,bo_kept,bo_extra,loop_kept,loop_extra)
 
1283
            
 
1284
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1285
            myloopamplitude.set('process', myproc)
 
1286
            myloopamplitude.generate_diagrams()
 
1287
            sumR2=0
 
1288
            sumUV=0
 
1289
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1290
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1291
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1292
#            print "I got diagrams"
 
1293
#            for i, diag in enumerate(myloopamplitude.get('born_diagrams')):
 
1294
#                print "diagram #%i is %s"%(i,diag.nice_string())
 
1295
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nDiagGoal)
 
1296
            self.assertEqual(sumR2, nR2Goal)
 
1297
            self.assertEqual(sumUV, nUVmassGoal)
 
1298
            sumUVCT=0
 
1299
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1300
                sumUVCT+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1301
            self.assertEqual(sumUVCT,nUVCTGoal)
 
1302
            
 
1303
            (born_orders_kept, born_orders_extra, loop_orders_kept, 
 
1304
                  loop_orders_extra) = myloopamplitude.print_split_order_infos()
 
1305
            
 
1306
            self.assertEqual(born_orders_kept,bo_kept)
 
1307
            self.assertEqual(born_orders_extra,bo_extra)
 
1308
            self.assertEqual(loop_orders_kept,loop_kept)
 
1309
            self.assertEqual(loop_orders_extra,loop_extra)
 
1310
 
1233
1311
    def test_CT_vertices_generation_ddx_ddx(self):
1234
1312
        """ test that the Counter Term vertices are correctly
1235
1313
            generated by adding some new CT interactions to the model and
1509
1587
        goal_vertices=base_objects.VertexList([vx17_tag,vx12_tag,vx13_tag,vx15_tag,vx168_tag,closing_vx])
1510
1588
        self.assertEqual(myPentaDiag1.get('vertices'), goal_vertices)
1511
1589
 
 
1590
class LoopEWDiagramGenerationTest(unittest.TestCase):
 
1591
    """Test class for all functions related to the Loop diagram generation with model LoopSMEWTest."""
 
1592
 
 
1593
    mypartlist = base_objects.ParticleList()
 
1594
    myinterlist = base_objects.InteractionList()
 
1595
    myloopmodel = loop_base_objects.LoopModel()
 
1596
    
 
1597
    ref_dict_to0 = {}
 
1598
    ref_dict_to1 = {}
 
1599
 
 
1600
    myamplitude = diagram_generation.Amplitude()
 
1601
 
 
1602
    def setUp(self):
 
1603
        """Load different objects for the tests."""
 
1604
        
 
1605
        # Make sure to only load the model once
 
1606
        if len(self.myloopmodel['particles'])==0:
 
1607
            self.myloopmodel = models.import_model(os.path.join(\
 
1608
            _input_file_path,'LoopSMEWTest'))
 
1609
        self.myloopmodel.actualize_dictionaries()
 
1610
        
 
1611
        self.mypartlist = self.myloopmodel['particles']
 
1612
        self.myinterlist = self.myloopmodel['interactions']
 
1613
        self.ref_dict_to0 = self.myloopmodel['ref_dict_to0']
 
1614
        self.ref_dict_to1 = self.myloopmodel['ref_dict_to1']
 
1615
        
 
1616
    def test_diagram_generation_aa_ttx_EW(self):
 
1617
        """Test the number of loop diagrams generated for a a > t t~
 
1618
           with different choices for the perturbation couplings and squared orders.
 
1619
        """
 
1620
        
 
1621
        myleglist = base_objects.LegList()
 
1622
        myleglist.append(base_objects.Leg({'id':22,
 
1623
                                         'state':False}))
 
1624
        myleglist.append(base_objects.Leg({'id':22,
 
1625
                                         'state':False}))
 
1626
        myleglist.append(base_objects.Leg({'id':6,
 
1627
                                         'state':True}))
 
1628
        myleglist.append(base_objects.Leg({'id':-6,
 
1629
                                         'state':True}))
 
1630
 
 
1631
        ordersChoices=[({},['QCD'],{},8),\
 
1632
                       ({},['QED'],{},224),\
 
1633
                       ({},['QCD','QED'],{},232)]
 
1634
        for (bornOrders,pert,sqOrders,nDiagGoal) in ordersChoices:
 
1635
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1636
                                           'model':self.myloopmodel,
 
1637
                                           'orders':bornOrders,
 
1638
                                           'perturbation_couplings':pert,
 
1639
                                           'squared_orders':sqOrders})
 
1640
    
 
1641
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1642
            myloopamplitude.set('process', myproc)
 
1643
            myloopamplitude.generate_diagrams()
 
1644
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nDiagGoal)
 
1645
            
 
1646
 
 
1647
            ### This is to plot the diagrams obtained
 
1648
            #diaglist=[diag for diag in \
 
1649
            #  myloopamplitude.get('loop_diagrams') if not isinstance(diag,
 
1650
            #  loop_base_objects.LoopUVCTDiagram)]
 
1651
            #diaglist=myloopamplitude.get('loop_diagrams')
 
1652
            #options = draw_lib.DrawOption()
 
1653
            #filename = os.path.join('/tmp/' + \
 
1654
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1655
            #plot = draw.MultiEpsDiagramDrawer(base_objects.DiagramList(diaglist),#myloopamplitude['loop_diagrams'],
 
1656
            #                                  filename,
 
1657
            #                                  model=self.myloopmodel,
 
1658
            #                                  amplitude=myloopamplitude,
 
1659
            #                                  legend=myloopamplitude.get('process').input_string())
 
1660
            #plot.draw(opt=options)
 
1661
            
 
1662
    def test_diagram_generation_gg_ttxh_EW(self):
 
1663
        """Test the number of loop diagrams generated for g g > t t~ h
 
1664
           with different choices for the perturbation couplings and squared orders.
 
1665
        """
 
1666
 
 
1667
        myleglist = base_objects.LegList()
 
1668
        myleglist.append(base_objects.Leg({'id':21,
 
1669
                                         'state':False}))
 
1670
        myleglist.append(base_objects.Leg({'id':21,
 
1671
                                         'state':False}))
 
1672
        myleglist.append(base_objects.Leg({'id':6,
 
1673
                                         'state':True}))
 
1674
        myleglist.append(base_objects.Leg({'id':-6,
 
1675
                                         'state':True}))
 
1676
        myleglist.append(base_objects.Leg({'id':25,
 
1677
                                         'state':True}))
 
1678
 
 
1679
        ordersChoices=[
 
1680
                       ({},['QCD','QED'],{},697,171,260),
 
1681
                       ({},['QCD'],{},164,71,188),
 
1682
                       ({},['QED'],{},533,100,72)]
 
1683
        
 
1684
                
 
1685
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1686
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1687
                                           'model':self.myloopmodel,
 
1688
                                           'orders':bornOrders,
 
1689
                                           'perturbation_couplings':pert,
 
1690
                                           'squared_orders':sqOrders})
 
1691
    
 
1692
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1693
            myloopamplitude.set('process', myproc)
 
1694
            myloopamplitude.generate_diagrams()
 
1695
            
 
1696
            ### This is to plot the diagrams obtained
 
1697
            #options = draw_lib.DrawOption()
 
1698
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1699
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1700
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1701
            #                                  filename,
 
1702
            #                                  model=self.myloopmodel,
 
1703
            #                                  amplitude=myloopamplitude,
 
1704
            #                                  legend=myloopamplitude.get('process').input_string())
 
1705
            #plot.draw(opt=options)
 
1706
            
 
1707
            sumR2=0
 
1708
            sumUV=0
 
1709
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1710
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1711
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1712
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1713
            self.assertEqual(sumR2, nR2Goal)
 
1714
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1715
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1716
            self.assertEqual(sumUV,nUVGoal)
 
1717
 
 
1718
    def test_diagram_generation_epem_ttxa_EW(self):
 
1719
        """Test the number of loop diagrams generated for e+ e- > t t~ a
 
1720
           with different choices for the perturbation couplings and squared orders.
 
1721
        """
 
1722
 
 
1723
        myleglist = base_objects.LegList()
 
1724
        myleglist.append(base_objects.Leg({'id':-11,
 
1725
                                         'state':False}))
 
1726
        myleglist.append(base_objects.Leg({'id':11,
 
1727
                                         'state':False}))
 
1728
        myleglist.append(base_objects.Leg({'id':6,
 
1729
                                         'state':True}))
 
1730
        myleglist.append(base_objects.Leg({'id':-6,
 
1731
                                         'state':True}))
 
1732
        myleglist.append(base_objects.Leg({'id':22,
 
1733
                                         'state':True}))
 
1734
 
 
1735
        ordersChoices=[
 
1736
                       ({},['QCD','QED'],{},1075,256,154),
 
1737
                       ({},['QCD'],{},20,16,40),
 
1738
                       ({},['QED'],{},1055,240,114)]
 
1739
        
 
1740
                
 
1741
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1742
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1743
                                           'model':self.myloopmodel,
 
1744
                                           'orders':bornOrders,
 
1745
                                           'perturbation_couplings':pert,
 
1746
                                           'squared_orders':sqOrders})
 
1747
    
 
1748
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1749
            myloopamplitude.set('process', myproc)
 
1750
            myloopamplitude.generate_diagrams()
 
1751
            
 
1752
            ### This is to plot the diagrams obtained
 
1753
            #options = draw_lib.DrawOption()
 
1754
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1755
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1756
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1757
            #                                  filename,
 
1758
            #                                  model=self.myloopmodel,
 
1759
            #                                  amplitude=myloopamplitude,
 
1760
            #                                  legend=myloopamplitude.get('process').input_string())
 
1761
            #plot.draw(opt=options)
 
1762
            
 
1763
            sumR2=0
 
1764
            sumUV=0
 
1765
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1766
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1767
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1768
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1769
            self.assertEqual(sumR2, nR2Goal)
 
1770
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1771
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1772
            self.assertEqual(sumUV,nUVGoal)
 
1773
 
 
1774
    def test_diagram_generation_epem_ttxg_EW(self):
 
1775
        """Test the number of loop diagrams generated for e+ e- > t t~ g
 
1776
           with different choices for the perturbation couplings and squared orders.
 
1777
        """
 
1778
 
 
1779
        myleglist = base_objects.LegList()
 
1780
        myleglist.append(base_objects.Leg({'id':-11,
 
1781
                                         'state':False}))
 
1782
        myleglist.append(base_objects.Leg({'id':11,
 
1783
                                         'state':False}))
 
1784
        myleglist.append(base_objects.Leg({'id':6,
 
1785
                                         'state':True}))
 
1786
        myleglist.append(base_objects.Leg({'id':-6,
 
1787
                                         'state':True}))
 
1788
        myleglist.append(base_objects.Leg({'id':21,
 
1789
                                         'state':True}))
 
1790
 
 
1791
        ordersChoices=[
 
1792
                       ({},['QCD','QED'],{},425,136,108),
 
1793
                       ({},['QCD'],{},46,18,52),
 
1794
                       ({},['QED'],{},379,118,56)]
 
1795
        
 
1796
                
 
1797
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1798
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1799
                                           'model':self.myloopmodel,
 
1800
                                           'orders':bornOrders,
 
1801
                                           'perturbation_couplings':pert,
 
1802
                                           'squared_orders':sqOrders})
 
1803
    
 
1804
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1805
            myloopamplitude.set('process', myproc)
 
1806
            myloopamplitude.generate_diagrams()
 
1807
            
 
1808
            ### This is to plot the diagrams obtained
 
1809
            #options = draw_lib.DrawOption()
 
1810
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1811
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1812
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1813
            #                                  filename,
 
1814
            #                                  model=self.myloopmodel,
 
1815
            #                                  amplitude=myloopamplitude,
 
1816
            #                                  legend=myloopamplitude.get('process').input_string())
 
1817
            #plot.draw(opt=options)
 
1818
            
 
1819
            sumR2=0
 
1820
            sumUV=0
 
1821
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1822
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1823
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1824
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1825
            self.assertEqual(sumR2, nR2Goal)
 
1826
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1827
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1828
            self.assertEqual(sumUV,nUVGoal)
 
1829
 
 
1830
    def test_diagram_generation_gg_ttxg_EW(self):
 
1831
        """Test the number of loop diagrams generated for g g > t t~ g
 
1832
           with different choices for the perturbation couplings and squared orders.
 
1833
        """
 
1834
 
 
1835
        myleglist = base_objects.LegList()
 
1836
        myleglist.append(base_objects.Leg({'id':21,
 
1837
                                         'state':False}))
 
1838
        myleglist.append(base_objects.Leg({'id':21,
 
1839
                                         'state':False}))
 
1840
        myleglist.append(base_objects.Leg({'id':6,
 
1841
                                         'state':True}))
 
1842
        myleglist.append(base_objects.Leg({'id':-6,
 
1843
                                         'state':True}))
 
1844
        myleglist.append(base_objects.Leg({'id':21,
 
1845
                                         'state':True}))
 
1846
 
 
1847
        ordersChoices=[
 
1848
                       ({},['QCD','QED'],{},1348,413,535),
 
1849
                       ({},['QCD'],{},556,234,431),
 
1850
                       ({},['QED'],{},792,179,104)]
 
1851
        
 
1852
                
 
1853
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1854
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1855
                                           'model':self.myloopmodel,
 
1856
                                           'orders':bornOrders,
 
1857
                                           'perturbation_couplings':pert,
 
1858
                                           'squared_orders':sqOrders})
 
1859
    
 
1860
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1861
            myloopamplitude.set('process', myproc)
 
1862
            myloopamplitude.generate_diagrams()
 
1863
            
 
1864
            ### This is to plot the diagrams obtained
 
1865
            #options = draw_lib.DrawOption()
 
1866
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1867
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1868
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1869
            #                                  filename,
 
1870
            #                                  model=self.myloopmodel,
 
1871
            #                                  amplitude=myloopamplitude,
 
1872
            #                                  legend=myloopamplitude.get('process').input_string())
 
1873
            #plot.draw(opt=options)
 
1874
            
 
1875
            sumR2=0
 
1876
            sumUV=0
 
1877
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1878
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1879
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1880
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1881
            self.assertEqual(sumR2, nR2Goal)
 
1882
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1883
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1884
            self.assertEqual(sumUV,nUVGoal)
 
1885
 
 
1886
    def test_diagram_generation_ttx_wpwm_EW(self):
 
1887
        """Test the number of loop diagrams generated for t t~ > w+ w-
 
1888
           with different choices for the perturbation couplings and squared orders.
 
1889
        """
 
1890
 
 
1891
        myleglist = base_objects.LegList()
 
1892
        myleglist.append(base_objects.Leg({'id':6,
 
1893
                                         'state':False}))
 
1894
        myleglist.append(base_objects.Leg({'id':-6,
 
1895
                                         'state':False}))
 
1896
        myleglist.append(base_objects.Leg({'id':24,
 
1897
                                         'state':True}))
 
1898
        myleglist.append(base_objects.Leg({'id':-24,
 
1899
                                         'state':True}))
 
1900
 
 
1901
        ordersChoices=[
 
1902
                       ({},['QCD','QED'],{},442,77,50),
 
1903
                       ({},['QCD'],{},7,6,18),
 
1904
                       ({},['QED'],{},435,71,32)]
 
1905
        
 
1906
                
 
1907
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1908
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1909
                                           'model':self.myloopmodel,
 
1910
                                           'orders':bornOrders,
 
1911
                                           'perturbation_couplings':pert,
 
1912
                                           'squared_orders':sqOrders})
 
1913
    
 
1914
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1915
            myloopamplitude.set('process', myproc)
 
1916
            myloopamplitude.generate_diagrams()
 
1917
            
 
1918
            ### This is to plot the diagrams obtained
 
1919
            #options = draw_lib.DrawOption()
 
1920
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1921
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1922
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1923
            #                                  filename,
 
1924
            #                                  model=self.myloopmodel,
 
1925
            #                                  amplitude=myloopamplitude,
 
1926
            #                                  legend=myloopamplitude.get('process').input_string())
 
1927
            #plot.draw(opt=options)
 
1928
            
 
1929
            sumR2=0
 
1930
            sumUV=0
 
1931
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1932
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1933
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1934
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1935
            self.assertEqual(sumR2, nR2Goal)
 
1936
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1937
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1938
            self.assertEqual(sumUV,nUVGoal)
 
1939
            
 
1940
    def test_diagram_generation_aa_wpwm_EW(self):
 
1941
        """Test the number of loop diagrams generated for a a > w+ w-
 
1942
           with different choices for the perturbation couplings and squared orders.
 
1943
        """
 
1944
 
 
1945
        myleglist = base_objects.LegList()
 
1946
        myleglist.append(base_objects.Leg({'id':22,
 
1947
                                         'state':False}))
 
1948
        myleglist.append(base_objects.Leg({'id':22,
 
1949
                                         'state':False}))
 
1950
        myleglist.append(base_objects.Leg({'id':24,
 
1951
                                         'state':True}))
 
1952
        myleglist.append(base_objects.Leg({'id':-24,
 
1953
                                         'state':True}))
 
1954
 
 
1955
        ordersChoices=[
 
1956
                       ({},['QED'],{},611,63,34)]
 
1957
        
 
1958
                
 
1959
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
1960
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
1961
                                           'model':self.myloopmodel,
 
1962
                                           'orders':bornOrders,
 
1963
                                           'perturbation_couplings':pert,
 
1964
                                           'squared_orders':sqOrders})
 
1965
    
 
1966
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
1967
            myloopamplitude.set('process', myproc)
 
1968
            myloopamplitude.generate_diagrams()
 
1969
            
 
1970
            ### This is to plot the diagrams obtained
 
1971
            #options = draw_lib.DrawOption()
 
1972
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
1973
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
1974
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
1975
            #                                  filename,
 
1976
            #                                  model=self.myloopmodel,
 
1977
            #                                  amplitude=myloopamplitude,
 
1978
            #                                  legend=myloopamplitude.get('process').input_string())
 
1979
            #plot.draw(opt=options)
 
1980
            
 
1981
            sumR2=0
 
1982
            sumUV=0
 
1983
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
1984
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
1985
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
1986
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
1987
            self.assertEqual(sumR2, nR2Goal)
 
1988
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
1989
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
1990
            self.assertEqual(sumUV,nUVGoal)
 
1991
            
 
1992
    def test_diagram_generation_uux_epem_EW(self):
 
1993
        """Test the number of loop diagrams generated for u u~>e+ e-
 
1994
           with different choices for the perturbation couplings and squared orders.
 
1995
        """
 
1996
 
 
1997
        myleglist = base_objects.LegList()
 
1998
        myleglist.append(base_objects.Leg({'id':2,
 
1999
                                         'state':False}))
 
2000
        myleglist.append(base_objects.Leg({'id':-2,
 
2001
                                         'state':False}))
 
2002
        myleglist.append(base_objects.Leg({'id':-11,
 
2003
                                         'state':True}))
 
2004
        myleglist.append(base_objects.Leg({'id':11,
 
2005
                                         'state':True}))
 
2006
 
 
2007
        ordersChoices=[
 
2008
                       ({},['QCD','QED'],{},101,53,16),
 
2009
                       ({},['QCD'],{},2,2,0),
 
2010
                       ({},['QED'],{},99,51,16)]
 
2011
        
 
2012
                
 
2013
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
2014
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
2015
                                           'model':self.myloopmodel,
 
2016
                                           'orders':bornOrders,
 
2017
                                           'perturbation_couplings':pert,
 
2018
                                           'squared_orders':sqOrders})
 
2019
    
 
2020
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
2021
            myloopamplitude.set('process', myproc)
 
2022
            myloopamplitude.generate_diagrams()
 
2023
            
 
2024
            ### This is to plot the diagrams obtained
 
2025
            #options = draw_lib.DrawOption()
 
2026
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
2027
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
2028
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
2029
            #                                  filename,
 
2030
            #                                  model=self.myloopmodel,
 
2031
            #                                  amplitude=myloopamplitude,
 
2032
            #                                  legend=myloopamplitude.get('process').input_string())
 
2033
            #plot.draw(opt=options)
 
2034
            
 
2035
            sumR2=0
 
2036
            sumUV=0
 
2037
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
2038
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
2039
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
2040
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
2041
            self.assertEqual(sumR2, nR2Goal)
 
2042
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
2043
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
2044
            self.assertEqual(sumUV,nUVGoal)
 
2045
                        
 
2046
    def test_diagram_generation_uux_ga_EW(self):
 
2047
        """Test the number of loop diagrams generated for uu~>g a
 
2048
           with different choices for the perturbation couplings and squared orders.
 
2049
        """
 
2050
 
 
2051
        myleglist = base_objects.LegList()
 
2052
        myleglist.append(base_objects.Leg({'id':2,
 
2053
                                         'state':False}))
 
2054
        myleglist.append(base_objects.Leg({'id':-2,
 
2055
                                         'state':False}))
 
2056
        myleglist.append(base_objects.Leg({'id':21,
 
2057
                                         'state':True}))
 
2058
        myleglist.append(base_objects.Leg({'id':22,
 
2059
                                         'state':True}))
 
2060
 
 
2061
        ordersChoices=[
 
2062
                       ({},['QCD'],{},23,6,14),
 
2063
                       ({},['QED'],{},27,12,12),
 
2064
                       ({},['QCD','QED'],{},50,18,26)]
 
2065
        
 
2066
                
 
2067
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
2068
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
2069
                                           'model':self.myloopmodel,
 
2070
                                           'orders':bornOrders,
 
2071
                                           'perturbation_couplings':pert,
 
2072
                                           'squared_orders':sqOrders})
 
2073
    
 
2074
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
2075
            myloopamplitude.set('process', myproc)
 
2076
            myloopamplitude.generate_diagrams()
 
2077
            
 
2078
            ### This is to plot the diagrams obtained
 
2079
            #options = draw_lib.DrawOption()
 
2080
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
2081
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
2082
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
2083
            #                                  filename,
 
2084
            #                                  model=self.myloopmodel,
 
2085
            #                                  amplitude=myloopamplitude,
 
2086
            #                                  legend=myloopamplitude.get('process').input_string())
 
2087
            #plot.draw(opt=options)
 
2088
            
 
2089
            sumR2=0
 
2090
            sumUV=0
 
2091
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
2092
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
2093
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
2094
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
2095
            self.assertEqual(sumR2, nR2Goal)
 
2096
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
2097
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
2098
            self.assertEqual(sumUV,nUVGoal)
 
2099
 
 
2100
    def test_diagram_generation_hh_hh_EW(self):
 
2101
        """Test the number of loop diagrams generated for h h>h h
 
2102
           with different choices for the perturbation couplings and squared orders.
 
2103
        """
 
2104
 
 
2105
        myleglist = base_objects.LegList()
 
2106
        myleglist.append(base_objects.Leg({'id':25,
 
2107
                                         'state':False}))
 
2108
        myleglist.append(base_objects.Leg({'id':25,
 
2109
                                         'state':False}))
 
2110
        myleglist.append(base_objects.Leg({'id':25,
 
2111
                                         'state':True}))
 
2112
        myleglist.append(base_objects.Leg({'id':25,
 
2113
                                         'state':True}))
 
2114
 
 
2115
        ordersChoices=[
 
2116
                       ({},['QED'],{},603,20,20)]
 
2117
        
 
2118
                
 
2119
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
2120
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
2121
                                           'model':self.myloopmodel,
 
2122
                                           'orders':bornOrders,
 
2123
                                           'perturbation_couplings':pert,
 
2124
                                           'squared_orders':sqOrders})
 
2125
    
 
2126
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
2127
            myloopamplitude.set('process', myproc)
 
2128
            myloopamplitude.generate_diagrams()
 
2129
            
 
2130
            ### This is to plot the diagrams obtained
 
2131
            #options = draw_lib.DrawOption()
 
2132
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
2133
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
2134
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
2135
            #                                  filename,
 
2136
            #                                  model=self.myloopmodel,
 
2137
            #                                  amplitude=myloopamplitude,
 
2138
            #                                  legend=myloopamplitude.get('process').input_string())
 
2139
            #plot.draw(opt=options)
 
2140
            
 
2141
            sumR2=0
 
2142
            sumUV=0
 
2143
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
2144
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
2145
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
2146
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
2147
            self.assertEqual(sumR2, nR2Goal)
 
2148
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
2149
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
2150
            self.assertEqual(sumUV,nUVGoal)
 
2151
 
 
2152
    def test_diagram_generation_hh_hhh_EW(self):
 
2153
        """Test the number of loop diagrams generated for h h>h h h
 
2154
           with different choices for the perturbation couplings and squared orders.
 
2155
        """
 
2156
 
 
2157
        myleglist = base_objects.LegList()
 
2158
        myleglist.append(base_objects.Leg({'id':25,
 
2159
                                         'state':False}))
 
2160
        myleglist.append(base_objects.Leg({'id':25,
 
2161
                                         'state':False}))
 
2162
        myleglist.append(base_objects.Leg({'id':25,
 
2163
                                         'state':True}))
 
2164
        myleglist.append(base_objects.Leg({'id':25,
 
2165
                                         'state':True}))
 
2166
        myleglist.append(base_objects.Leg({'id':25,
 
2167
                                         'state':True}))
 
2168
 
 
2169
        ordersChoices=[
 
2170
                       ({},['QED'],{},8075,210,210)]
 
2171
        
 
2172
                
 
2173
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
2174
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
2175
                                           'model':self.myloopmodel,
 
2176
                                           'orders':bornOrders,
 
2177
                                           'perturbation_couplings':pert,
 
2178
                                           'squared_orders':sqOrders})
 
2179
    
 
2180
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
2181
            myloopamplitude.set('process', myproc)
 
2182
            myloopamplitude.generate_diagrams()
 
2183
            
 
2184
            ### This is to plot the diagrams obtained
 
2185
            #options = draw_lib.DrawOption()
 
2186
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
2187
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
2188
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
2189
            #                                  filename,
 
2190
            #                                  model=self.myloopmodel,
 
2191
            #                                  amplitude=myloopamplitude,
 
2192
            #                                  legend=myloopamplitude.get('process').input_string())
 
2193
            #plot.draw(opt=options)
 
2194
            
 
2195
            sumR2=0
 
2196
            sumUV=0
 
2197
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
2198
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
2199
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
2200
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
2201
            self.assertEqual(sumR2, nR2Goal)
 
2202
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
2203
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
2204
            self.assertEqual(sumUV,nUVGoal)        
 
2205
            
 
2206
    def test_diagram_generation_gg_ggg_EW(self):
 
2207
        """Test the number of loop diagrams generated for g g>g g g
 
2208
           with different choices for the perturbation couplings and squared orders.
 
2209
        """
 
2210
 
 
2211
        myleglist = base_objects.LegList()
 
2212
        myleglist.append(base_objects.Leg({'id':21,
 
2213
                                         'state':False}))
 
2214
        myleglist.append(base_objects.Leg({'id':21,
 
2215
                                         'state':False}))
 
2216
        myleglist.append(base_objects.Leg({'id':21,
 
2217
                                         'state':True}))
 
2218
        myleglist.append(base_objects.Leg({'id':21,
 
2219
                                         'state':True}))
 
2220
        myleglist.append(base_objects.Leg({'id':21,
 
2221
                                         'state':True}))
 
2222
 
 
2223
        ordersChoices=[
 
2224
                       ({},['QCD'],{},2075,735,575)]
 
2225
        
 
2226
                
 
2227
        for (bornOrders,pert,sqOrders,nLoopGoal,nR2Goal,nUVGoal) in ordersChoices:
 
2228
            myproc = base_objects.Process({'legs':copy.copy(myleglist),
 
2229
                                           'model':self.myloopmodel,
 
2230
                                           'orders':bornOrders,
 
2231
                                           'perturbation_couplings':pert,
 
2232
                                           'squared_orders':sqOrders})
 
2233
    
 
2234
            myloopamplitude = loop_diagram_generation.LoopAmplitude()
 
2235
            myloopamplitude.set('process', myproc)
 
2236
            myloopamplitude.generate_diagrams()
 
2237
            
 
2238
            ### This is to plot the diagrams obtained
 
2239
            #options = draw_lib.DrawOption()
 
2240
            #filename = os.path.join('/Users/erdissshaw/Works', 'diagramsVall1_' + \
 
2241
            #              myloopamplitude.get('process').shell_string() + ".eps")
 
2242
            #plot = draw.MultiEpsDiagramDrawer(myloopamplitude.get('diagrams'),
 
2243
            #                                  filename,
 
2244
            #                                  model=self.myloopmodel,
 
2245
            #                                  amplitude=myloopamplitude,
 
2246
            #                                  legend=myloopamplitude.get('process').input_string())
 
2247
            #plot.draw(opt=options)
 
2248
            
 
2249
            sumR2=0
 
2250
            sumUV=0
 
2251
            for i, diag in enumerate(myloopamplitude.get('loop_diagrams')):
 
2252
                sumR2+=len(diag.get_CT(self.myloopmodel,'R2'))
 
2253
                sumUV+=len(diag.get_CT(self.myloopmodel,'UV'))
 
2254
            self.assertEqual(len(myloopamplitude.get('loop_diagrams')),nLoopGoal)
 
2255
            self.assertEqual(sumR2, nR2Goal)
 
2256
            for loop_UVCT_diag in myloopamplitude.get('loop_UVCT_diagrams'):
 
2257
                sumUV+=len(loop_UVCT_diag.get('UVCT_couplings'))
 
2258
            self.assertEqual(sumUV,nUVGoal)
 
2259
 
1512
2260
if __name__ == '__main__':
1513
2261
        # Save this model so that it can be loaded by other loop tests
1514
2262
        save_load_object.save_to_file(os.path.join(_input_file_path, 'test_toyLoopModel.pkl'),loadLoopModel())
1515
2263
        print "test_toyLoopModel.pkl created."
 
2264
        #unittest.main()