Package madgraph :: Package loop :: Module loop_base_objects :: Class LoopDiagram
[hide private]
[frames] | no frames]

Class LoopDiagram

source code

                 object --+            
                          |            
                       dict --+        
                              |        
core.base_objects.PhysicsObject --+    
                                  |    
          core.base_objects.Diagram --+
                                      |
                                     LoopDiagram

LoopDiagram: Contains an additional tag to uniquely identify the diagram if it contains a loop. Also has many additional functions useful only for loop computations.

Nested Classes [hide private]

Inherited from core.base_objects.PhysicsObject: PhysicsObjectError

Instance Methods [hide private]
 
default_setup(self)
Default values for all properties
source code
 
filter(self, name, value)
Filter for valid diagram property values.
source code
 
get_sorted_keys(self)
Return particle property names as a nicely sorted list.
source code
 
nice_string(self, struct_list=None)
Returns a nicely formatted string of the diagram content.
source code
 
get_contracted_loop_diagram_without_tag(self, struct_rep=None)
This is the old function used without tag which means that no canonical loop information can be produced.
source code
 
build_loop_tag_for_diagram_identification(self, model, FDStrut_rep, use_FDStructure_ID_for_tag=False)
This function returns what will be used as the 'loop_tag' attribute of the ContractedVertex instance in the function 'get_contracted_loop_diagram'.
source code
 
get_contracted_loop_diagram(self, model, struct_rep=None)
Returns a base_objects.Diagram which correspond to this loop diagram with the loop shrunk to a point.
source code
 
get_CT(self, model, string=None)
Returns the CounterTerms of the type passed in argument.
source code
 
is_fermion_loop(self, model)
Return none if there is no loop or if a tag has not yet been set and returns True if this graph contains a purely fermionic loop and False if not.
source code
 
is_tadpole(self)
Return None if there is no loop or if a tag has not yet been set and returns True if this graph contains a tadpole loop and False if not.
source code
 
is_vanishing_tadpole(self, model)
Return None if there is no loop or if a tag has not yet been set and returns True if this graph contains a vanishing tadpole loop and False if not.
source code
 
is_wf_correction(self, struct_rep, model)
Return None if there is no loop or if a tag has not yet been set and returns True if this graph contains a wave-function correction and False if not.
source code
 
get_nloopline(self)
Return the number of loop lines.
source code
 
tag(self, struct_rep, model, start_in=None, end_in=None, synchronize=True)
Construct the tag of the diagram providing the loop structure of it.
source code
 
process_next_loop_leg(self, structRep, fromVert, fromPos, currLeg, endLeg, loopVertexList, model, external_legs)
Finds a loop leg and what is the next one.
source code
 
synchronize_loop_vertices_with_tag(self, model, n_initial, struct_rep, lcut_part_number, lcut_antipart_number)
Construct the loop vertices from the tag of the loop diagram.
source code
 
construct_FDStructure(self, fromVert, fromPos, currLeg, FDStruct)
Construct iteratively a Feynman Diagram structure attached to a Loop, given at each step a vertex and the position of the leg this function is called from.
source code
 
get_starting_loop_line(self)
Return the starting loop line of this diagram, i.e.
source code
 
get_finishing_loop_line(self)
Return the finishing line of this diagram, i.e.
source code
 
get_loop_line_types(self)
Return a set with one occurence of each different PDG code of the particles running in the loop.
source code
 
get_loop_orders(self, model)
Return a dictionary with one entry per type of order appearing in the interactions building the loop flow.
source code
 
get_loop_lines_pdgs(self)
Returns the pdgs of the lines running in the loop while not differentiating the particles from the anti-particles
source code
 
get_pdgs_attached_to_loop(self, structs)
Returns the pdgs of the lines directly branching off the loop.
source code

Inherited from core.base_objects.Diagram: calculate_orders, get_external_legs, get_flow_charge_diff, get_num_configs, get_order, get_vertex_leg_numbers, pass_squared_order_constraints, renumber_legs

Inherited from core.base_objects.PhysicsObject: __getitem__, __init__, __repr__, __str__, get, is_valid_prop, set

Inherited from dict: __cmp__, __contains__, __delitem__, __eq__, __ge__, __getattribute__, __gt__, __iter__, __le__, __len__, __lt__, __ne__, __new__, __setitem__, __sizeof__, clear, copy, fromkeys, has_key, items, iteritems, iterkeys, itervalues, keys, pop, popitem, setdefault, update, values, viewitems, viewkeys, viewvalues

Inherited from object: __delattr__, __format__, __reduce__, __reduce_ex__, __setattr__, __subclasshook__

Class Methods [hide private]
 
compute_weight(cls, FD_ids_list, struct_rep, number_legs)
Computes the weighting function S for this structure 'i' such that S(i)>0 for each any i, S(i)!=S(j) if i['external_legs']!=j['external_legs'] and S(i+j)>max(S(i),S(j)).
source code
 
choose_optimal_lcut(cls, intag, struct_rep, model, external_legs)
This function chooses the place where to cut the loop in order to maximize the loop wavefunction recycling in the open loops method.
source code
 
choose_default_lcut(cls, tag, model)
This function chooses where to cut the loop.
source code
 
generate_loop_vertex(cls, myleglist, model, n_initial, vertID)
Generate a loop vertex from incoming legs myleglist and the interaction with id vertID of the model given in argument
source code
 
make_canonical_cyclic(cls, atag)
Perform cyclic permutations on the tag given in parameter such that the structure with the lowest ID appears first.
source code
 
mirrored_tag(cls, atag, model)
Performs a mirror operation on A COPY of the tag and returns it.
source code
Class Variables [hide private]
  cutting_method = 'optimal'

Inherited from dict: __hash__

Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

default_setup(self)

source code 

Default values for all properties

Overrides: core.base_objects.PhysicsObject.default_setup

filter(self, name, value)

source code 

Filter for valid diagram property values.

Overrides: core.base_objects.PhysicsObject.filter

get_sorted_keys(self)

source code 

Return particle property names as a nicely sorted list.

Overrides: core.base_objects.PhysicsObject.get_sorted_keys

nice_string(self, struct_list=None)

source code 

Returns a nicely formatted string of the diagram content.

Overrides: core.base_objects.Diagram.nice_string

get_contracted_loop_diagram_without_tag(self, struct_rep=None)

source code 

This is the old function used without tag which means that no canonical loop information can be produced. It will be used for unit test only and moved there when I'll implement them.

build_loop_tag_for_diagram_identification(self, model, FDStrut_rep, use_FDStructure_ID_for_tag=False)

source code 

This function returns what will be used as the 'loop_tag' attribute of the ContractedVertex instance in the function 'get_contracted_loop_diagram'. It is important since it is what is used by MG5_aMC to decide if two processes have *exactly* the same matrix element and can be identified. There is no need to characterize the details of the FDStructures attached to the loops because these are already compared using the rest of the DiagramTag structure. All we need is to identify a structure by its external leg numbers.

get_contracted_loop_diagram(self, model, struct_rep=None)

source code 

Returns a base_objects.Diagram which correspond to this loop diagram with the loop shrunk to a point. If struct_rep is no specified, then the tagging will proceed assuming no FDStructure has been identified yet. Otherwise, it will possible reuse them an update the repository.

Overrides: core.base_objects.Diagram.get_contracted_loop_diagram

get_CT(self, model, string=None)

source code 

Returns the CounterTerms of the type passed in argument. If None it returns all of them.

choose_optimal_lcut(cls, intag, struct_rep, model, external_legs)
Class Method

source code 

This function chooses the place where to cut the loop in order to maximize the loop wavefunction recycling in the open loops method. This amounts to cut just before the combined structure with smallest weight and then chose the direction to go towards the one with smallest weight.

choose_default_lcut(cls, tag, model)
Class Method

source code 

This function chooses where to cut the loop. It returns the canonical tag corresponding to this unambiguous choice.

process_next_loop_leg(self, structRep, fromVert, fromPos, currLeg, endLeg, loopVertexList, model, external_legs)

source code 

Finds a loop leg and what is the next one. Also identify and tag the FD structure attached in between these two loop legs. It adds the corresponding tuple to the diagram tag and calls iself again to treat the next loop leg. Return True when tag successfully computed.

construct_FDStructure(self, fromVert, fromPos, currLeg, FDStruct)

source code 
Construct iteratively a Feynman Diagram structure attached to a Loop, 
given at each step a vertex and the position of the leg this function is 
called from. At the same time, it constructs a canonical representation 
of the structure which is a tuple with each element corresponding to 
a 2-tuple ((external_parent_legs),vertex_ID). The external parent legs 
tuple is ordered as growing and the construction of the canonical 
representation is such that the 2-tuples appear in a fixed order.
This functions returns a tuple of 2-tuple like above for the vertex 
where currLeg was found or false if fails.

To illustrate this algorithm, we take a concrete example, 
the following structure:
                                                               
              4 5 6 7
           1 3 \/2 \/  <- Vertex ID, left=73 and right=99
           \ / | \ /   <- Vertex ID, left=34 and right=42 
            |  |4 | 
            1\ | /2
              \|/      <- Vertex ID=72
               |
               |1

For this structure with external legs (1,2,3,5,6,7) and current created 
1, the canonical tag will be
    
 (((1,2,3,4,5,6,7),72),((1,3),34),((2,6,7),42),((6,7),99),((4,5),73))

get_starting_loop_line(self)

source code 

Return the starting loop line of this diagram, i.e. lcut leg one.

get_finishing_loop_line(self)

source code 

Return the finishing line of this diagram, i.e. lcut leg two. Notice that this function is only available when the loop diagram is constructed with the special two-point vertex with id -1.

get_loop_line_types(self)

source code 

Return a set with one occurence of each different PDG code of the particles running in the loop. By convention, the PDF of the particle, not the antiparticle, is stored in this list. Using the tag would be quicker, but we want this function to be available before tagging as well

get_loop_orders(self, model)

source code 

Return a dictionary with one entry per type of order appearing in the interactions building the loop flow. The corresponding keys are the number of type this order appear in the diagram.