Package madgraph :: Package loop :: Module loop_diagram_generation :: Class LoopAmplitude
[hide private]
[frames] | no frames]

Class LoopAmplitude

source code

                 object --+            
                          |            
                       dict --+        
                              |        
core.base_objects.PhysicsObject --+    
                                  |    
  core.diagram_generation.Amplitude --+
                                      |
                                     LoopAmplitude

NLOAmplitude: process + list of diagrams (ordered) Initialize with a process, then call generate_diagrams() to generate the diagrams for the amplitude

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
new empty dictionary

__init__(self, argument=None, loop_filter=None)
Allow initialization with Process.
source code
 
get_sorted_keys(self)
Return diagram property names as a nicely sorted list.
source code
 
filter(self, name, value)
Filter for valid amplitude property values.
source code
 
set(self, name, value)
Redefine set for the particular case of diagrams
source code
D[k] if k in D, else d
get(self, name)
Redefine get for the particular case of '*_diagrams' property
source code
 
choose_order_config(self)
Choose the configuration of non-perturbed coupling orders to be retained for all diagrams.
source code
 
guess_loop_orders_from_squared(self)
If squared orders (other than WEIGHTED) are defined, then they can be used for determining what is the expected upper bound for the order restricting loop diagram generation.
source code
 
guess_loop_orders(self, user_orders)
Guess the upper bound for the orders for loop diagram generation based on either no squared orders or simply 'Weighted'
source code
 
filter_from_order_config(self, diags, config, discarded_configurations)
Filter diags to select only the diagram with the non perturbed orders configuration config and update discarded_configurations.Diags is the name of the key attribute of this class containing the diagrams to filter.
source code
 
remove_Furry_loops(self, model, structs)
Remove the loops which are zero because of Furry theorem.
source code
 
user_filter(self, model, structs, filter=None)
User-defined user-filter.
source code
 
filter_loop_for_perturbative_orders(self)
Filter the loop diagrams to make sure they belong to the class of coupling orders perturbed.
source code
 
check_factorization(self, user_orders)
Makes sure that all non perturbed orders factorize the born diagrams
source code
 
get_non_pert_order_config(self, diagram)
Return a dictionary of all the coupling orders of this diagram which are not the perturbed ones.
source code
 
print_config(self, config)
Return a string describing the coupling order configuration
source code
 
generate_diagrams(self, loop_filter=None, diagram_filter=None)
Generates all diagrams relevant to this Loop Process
source code
 
identify_loop_diagrams(self)
Uses a loop_tag characterizing the loop with only physical information about it (mass, coupling, width, color, etc...) so as to recognize numerically equivalent diagrams and group them together, such as massless quark loops in pure QCD gluon loop amplitudes.
source code
 
print_split_order_infos(self)
This function is solely for monitoring purposes.
source code
 
generate_born_diagrams(self)
Generates all born diagrams relevant to this NLO Process
source code
 
generate_loop_diagrams(self)
Generates all loop diagrams relevant to this NLO Process
source code
 
set_Born_CT(self)
Scan all born diagrams and add for each all the corresponding UV counterterms.
source code
 
set_LoopCT_vertices(self)
Scan each loop diagram and recognizes what are the R2/UVmass CounterTerms associated to them
source code
 
create_diagram(self, vertexlist)
Return a LoopDiagram created.
source code
 
copy_leglist(self, leglist)
Returns a DGLoopLeg list instead of the default copy_leglist defined in base_objects.Amplitude
source code
 
convert_dgleg_to_leg(self, vertexdoublelist)
Overloaded here to convert back all DGLoopLegs into Legs.
source code
 
get_combined_legs(self, legs, leg_vert_ids, number, state)
Create a set of new legs from the info given.
source code
 
get_combined_vertices(self, legs, vert_ids)
Allow for selection of vertex ids.
source code
 
check_squared_orders(self, sq_order_constrains, user_squared_orders=None)
Filters the diagrams according to the constraints on the squared orders in argument and wether the process has a born or not.
source code
 
order_diagram_set(self, diag_set, split_orders)
This is a helper function for order_diagrams_according_to_split_orders and intended to be used from LoopHelasAmplitude only
source code
 
order_diagrams_according_to_split_orders(self, split_orders)
Reorder the loop and Born diagrams (if any) in group of diagrams sharing the same coupling orders are put together and these groups are order in decreasing WEIGHTED orders.
source code

Inherited from core.diagram_generation.Amplitude: apply_squared_order_constraints, apply_user_filter, combine_legs, get_amplitudes, get_ninitial, get_number_of_diagrams, has_loop_process, merge_comb_legs, nice_string, nice_string_processes, reduce_leglist, reduce_orders, trim_diagrams

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

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__

Static Methods [hide private]
 
get_loop_filter(filterdef)
Returns a function which applies the filter corresponding to the conditional expression encoded in filterdef.
source code
Class Variables [hide private]

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

__init__(self, argument=None, loop_filter=None)
(Constructor)

source code 

Allow initialization with Process. If loop_filter is not None, then it will be applied to all subsequent diagram generation from this LoopAmplitude.

Returns:
new empty dictionary

Overrides: object.__init__

get_sorted_keys(self)

source code 

Return diagram property names as a nicely sorted list.

Overrides: core.base_objects.PhysicsObject.get_sorted_keys

filter(self, name, value)

source code 

Filter for valid amplitude property values.

Overrides: core.base_objects.PhysicsObject.filter

set(self, name, value)

source code 

Redefine set for the particular case of diagrams

Overrides: core.base_objects.PhysicsObject.set

get(self, name)

source code 

Redefine get for the particular case of '*_diagrams' property

Returns: D[k] if k in D, else d
Overrides: dict.get

choose_order_config(self)

source code 

Choose the configuration of non-perturbed coupling orders to be retained for all diagrams. This is used when the user did not specify any order.

remove_Furry_loops(self, model, structs)

source code 

Remove the loops which are zero because of Furry theorem. So as to limit any possible mistake in case of BSM model, I limit myself here to removing SM-quark loops with external legs with an odd number of photons, possibly including exactly two gluons.

user_filter(self, model, structs, filter=None)

source code 

User-defined user-filter. By default it is not called, but the expert user can turn it on and code here is own filter. Some default examples are provided here. The tagging of the loop diagrams must be performed before using this user loop filter

generate_diagrams(self, loop_filter=None, diagram_filter=None)

source code 

Generates all diagrams relevant to this Loop Process

Overrides: core.diagram_generation.Amplitude.generate_diagrams

print_split_order_infos(self)

source code 

This function is solely for monitoring purposes. It reports what are the coupling order combination which are obtained with the diagram genarated and among those which ones correspond to those selected by the process definition and which ones are the extra combinations which comes as a byproduct of the computation of the desired one. The typical example is that if you ask for d d~ > u u~ QCD^2==2 [virt=QCD, QED], you will not only get (QCD,QED)=(2,2);(2,4) which are the desired ones but the code output will in principle also be able to return (QCD,QED)=(4,0);(4,2);(0,4);(0,6) because they involve the same amplitudes

set_Born_CT(self)

source code 

Scan all born diagrams and add for each all the corresponding UV counterterms. It creates one LoopUVCTDiagram per born diagram and set of possible coupling_order (so that QCD and QED wavefunction corrections are not in the same LoopUVCTDiagram for example). Notice that this takes care only of the UV counterterm which factorize with the born and the other contributions like the UV mass renormalization are added in the function setLoopCTVertices

create_diagram(self, vertexlist)

source code 

Return a LoopDiagram created.

Overrides: core.diagram_generation.Amplitude.create_diagram

copy_leglist(self, leglist)

source code 

Returns a DGLoopLeg list instead of the default copy_leglist defined in base_objects.Amplitude

Overrides: core.diagram_generation.Amplitude.copy_leglist

convert_dgleg_to_leg(self, vertexdoublelist)

source code 

Overloaded here to convert back all DGLoopLegs into Legs.

Overrides: core.diagram_generation.Amplitude.convert_dgleg_to_leg

get_combined_legs(self, legs, leg_vert_ids, number, state)

source code 

Create a set of new legs from the info given.

Overrides: core.diagram_generation.Amplitude.get_combined_legs

get_combined_vertices(self, legs, vert_ids)

source code 

Allow for selection of vertex ids.

Overrides: core.diagram_generation.Amplitude.get_combined_vertices

order_diagrams_according_to_split_orders(self, split_orders)

source code 

Reorder the loop and Born diagrams (if any) in group of diagrams sharing the same coupling orders are put together and these groups are order in decreasing WEIGHTED orders. Notice that this function is only called for now by the LoopHelasMatrixElement instances at the output stage.