Package madgraph :: Package core :: Module helas_objects :: Class HelasWavefunction
[hide private]
[frames] | no frames]

Class HelasWavefunction

source code

            object --+        
                     |        
                  dict --+    
                         |    
base_objects.PhysicsObject --+
                             |
                            HelasWavefunction

HelasWavefunction object, has the information necessary for writing a call to a HELAS wavefunction routine: the PDG number, all relevant particle information, a list of mother wavefunctions, interaction id, all relevant interaction information, fermion flow state, wavefunction number

Nested Classes [hide private]

Inherited from base_objects.PhysicsObject: PhysicsObjectError

Instance Methods [hide private]
 
default_setup(self)
Default values for all properties
source code
new empty dictionary

__init__(self, *arguments)
Allow generating a HelasWavefunction from a Leg
source code
 
filter(self, name, value)
Filter for valid wavefunction property values.
source code
D[k] if k in D, else d
get(self, name)
When calling any property related to the particle, automatically call the corresponding property of the particle.
source code
 
set(self, *arguments)
When setting interaction_id, if model is given (in tuple), set all other interaction properties.
source code
 
get_sorted_keys(self)
Return particle property names as a nicely sorted list.
source code
 
flip_part_antipart(self)
Flip between particle and antiparticle.
source code
 
is_anticommutating_ghost(self)
Return True if the particle of this wavefunction is a ghost
source code
 
is_fermion(self) source code
 
is_boson(self) source code
 
is_majorana(self) source code
 
get_analytic_info(self, info, alohaModel=None)
Returns a given analytic information about this loop wavefunction or its characterizing interaction.
source code
 
compute_analytic_information(self, alohaModel)
Make sure that all analytic pieces of information about this wavefunction are computed so that they can be recycled later, typically without the need of specifying an alohaModel.
source code
 
to_array(self)
Generate an array with the information needed to uniquely determine if a wavefunction has been used before: interaction id and mother wavefunction numbers.
source code
 
get_pdg_code(self)
Generate the corresponding pdg_code for an outgoing particle, taking into account fermion flow, for mother wavefunctions
source code
 
get_anti_pdg_code(self)
Generate the corresponding pdg_code for an incoming particle, taking into account fermion flow, for mother wavefunctions
source code
 
set_scalar_coupling_sign(self, model)
Check if we need to add a minus sign due to non-identical bosons in HVS type couplings
source code
 
set_octet_majorana_coupling_sign(self)
For octet Majorana fermions, need an extra minus sign in the FVI (and FSI?) wavefunction in UFO models.
source code
 
set_state_and_particle(self, model)
Set incoming/outgoing state according to mother states and Lorentz structure of the interaction, and set PDG code according to the particles in the interaction
source code
 
check_and_fix_fermion_flow(self, wavefunctions, diagram_wavefunctions, external_wavefunctions, wf_number)
Check for clashing fermion flow (N(incoming) != N(outgoing)) in mothers.
source code
 
check_majorana_and_flip_flow(self, found_majorana, wavefunctions, diagram_wavefunctions, external_wavefunctions, wf_number, force_flip_flow=False, number_to_wavefunctions=[])
Recursive function.
source code
 
has_multifermion(self)
check the presence of 4 fermion vertex
source code
 
get_fermion_order(self)
Recursive function to get a list of fermion numbers corresponding to the order of fermions along fermion lines connected to this wavefunction, in the form [n1,n2,...] for a boson, and [N,[n1,n2,...]] for a fermion line
source code
 
needs_hermitian_conjugate(self)
Returns true if any of the mothers have negative fermionflow
source code
 
get_with_flow(self, name)
Generate the is_part and state needed for writing out wavefunctions, taking into account the fermion flow
source code
 
get_external_helas_call_dict(self)
Returns a dictionary for formatting this external wavefunction helas call
source code
 
get_helas_call_dict(self, index=1, OptimizedOutput=False, specifyHel=True, **opt)
return a dictionary to be used for formatting HELAS call.
source code
 
get_spin_state_number(self, flip=False)
Returns the number corresponding to the spin state, with a minus sign for incoming fermions.
source code
 
find_mother_fermion(self)
Return the fermion mother which is fermion flow connected to this fermion
source code
 
find_outgoing_number(self)
Return the position of the resulting particles in the interactions
source code
 
find_leg_index(self, pdg_code, spin_state)
Find the place in the interaction list of the given particle with pdg 'pdg_code' and spin 'spin_stat'.
source code
 
get_call_key(self)
Generate the (spin, number, C-state) tuple used as key for the helas call dictionaries in HelasModel
source code
 
get_base_vertices(self, wf_dict, vx_list=[], optimization=1)
Recursive method to get a base_objects.VertexList corresponding to this wavefunction and its mothers.
source code
 
get_base_vertex(self, wf_dict, vx_list=[], optimization=1)
Get a base_objects.Vertex corresponding to this wavefunction.
source code
 
get_color_indices(self)
Recursive method to get the color indices corresponding to this wavefunction and its mothers.
source code
 
get_aloha_info(self, optimized_output=True)
Returns the tuple (lorentz_name, tag, outgoing_number) providing the necessary information to compute_subset of create_aloha to write out the HELAS-like routines.
source code
 
get_lcutspinletter(self)
Returns S,V or F depending on the spin of the mother loop particle.
source code
 
get_s_and_t_channels(self, ninitial, mother_leg, reverse_t_ch=False)
Returns two lists of vertices corresponding to the s- and t-channels that can be traced from this wavefunction, ordered from the outermost s-channel and in/down towards the highest (if not reverse_t_ch) or lowest (if reverse_t_ch) number initial state leg.
source code
 
get_struct_external_leg_ids(self)
Return a set containing the ids of all the non-loop outter-most external legs attached to the loop at the interaction point of this loop wavefunction
source code
 
get_loop_index(self)
Return the index of the wavefunction in the mothers which is the loop one
source code
 
get_lcut_size(self)
Return the size (i.e number of elements) of the L-Cut wavefunction this loop wavefunction originates from.
source code
 
get_loop_mother(self)
Return the mother of type 'loop', if any.
source code
 
get_conjugate_index(self)
Return the index of the particle that should be conjugated.
source code
 
get_vertex_leg_numbers(self, veto_inter_id=[0, -1, -2], max_n_loop=0)
Get a list of the number of legs in vertices in this diagram
source code
 
__eq__(self, other)
Overloading the equality operator, to make comparison easy when checking if wavefunction is already written, or when checking for identical processes.
source code
 
__ne__(self, other)
Overloading the nonequality operator, to make comparison easy
source code
 
LEGACY_get_interaction_q_power(self)
Returns the power of the loop momentum q brought by the interaction and propagator from which this loop wavefunction originates.
source code

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

Inherited from dict: __cmp__, __contains__, __delitem__, __ge__, __getattribute__, __gt__, __iter__, __le__, __len__, __lt__, __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]
 
spin_to_size(spin)
Returns the size of a wavefunction (i.e.
source code
Class Variables [hide private]
  supported_analytical_info = ['wavefunction_rank', 'interaction...

Inherited from dict: __hash__

Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

spin_to_size(spin)
Static Method

source code 

Returns the size of a wavefunction (i.e. number of element) carrying a particle with spin 'spin'

default_setup(self)

source code 

Default values for all properties

Overrides: base_objects.PhysicsObject.default_setup

__init__(self, *arguments)
(Constructor)

source code 

Allow generating a HelasWavefunction from a Leg

Returns:
new empty dictionary

Overrides: object.__init__

filter(self, name, value)

source code 

Filter for valid wavefunction property values.

Overrides: base_objects.PhysicsObject.filter

get(self, name)

source code 

When calling any property related to the particle, automatically call the corresponding property of the particle.

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

set(self, *arguments)

source code 

When setting interaction_id, if model is given (in tuple), set all other interaction properties. When setting pdg_code, if model is given, set all other particle properties.

Overrides: base_objects.PhysicsObject.set

get_sorted_keys(self)

source code 

Return particle property names as a nicely sorted list.

Overrides: base_objects.PhysicsObject.get_sorted_keys

get_analytic_info(self, info, alohaModel=None)

source code 

Returns a given analytic information about this loop wavefunction or its characterizing interaction. The list of available information is in the HelasWavefunction class variable 'supported_analytical_info'. An example of analytic information is the 'interaction_rank', corresponding to the power of the loop momentum q brought by the interaction and propagator from which this loop wavefunction originates. This is done in a general way by having aloha analyzing the lorentz structure used. Notice that if one knows that this analytic information has already been computed before (for example because a call to compute_analytic_information has been performed before, then alohaModel is not required since the result can be recycled.

check_and_fix_fermion_flow(self, wavefunctions, diagram_wavefunctions, external_wavefunctions, wf_number)

source code 

Check for clashing fermion flow (N(incoming) != N(outgoing)) in mothers. This can happen when there is a Majorana particle in the diagram, which can flip the fermion flow. This is detected either by a wavefunctions or an amplitude, with 2 fermion mothers with same state.

In this case, we need to follow the fermion lines of the mother wavefunctions until we find the outermost Majorana fermion. For all fermions along the line up to (but not including) the Majorana fermion, we need to flip incoming <-> outgoing and particle id. For all fermions after the Majorana fermion, we need to flip the fermionflow property (1 <-> -1).

The reason for this is that in the Helas calls, we need to keep track of where the actual fermion flow clash happens (i.e., at the outermost Majorana), as well as having the correct fermion flow for all particles along the fermion line.

This is done by the mothers using HelasWavefunctionList.check_and_fix_fermion_flow, which in turn calls the recursive function check_majorana_and_flip_flow to trace the fermion lines.

check_majorana_and_flip_flow(self, found_majorana, wavefunctions, diagram_wavefunctions, external_wavefunctions, wf_number, force_flip_flow=False, number_to_wavefunctions=[])

source code 
Recursive function. Check for Majorana fermion. If found,
continue down to external leg, then flip all the fermion flows
on the way back up, in the correct way:
Only flip fermionflow after the last Majorana fermion; for
wavefunctions before the last Majorana fermion, instead flip
particle identities and state. Return the new (or old)
wavefunction, and the present wavefunction number.

Arguments:
  found_majorana: boolean
  wavefunctions: HelasWavefunctionList with previously
                 defined wavefunctions
  diagram_wavefunctions: HelasWavefunctionList with the wavefunctions
                 already defined in this diagram
  external_wavefunctions: dictionary from legnumber to external wf
  wf_number: The present wavefunction number

get_helas_call_dict(self, index=1, OptimizedOutput=False, specifyHel=True, **opt)

source code 

return a dictionary to be used for formatting HELAS call. The argument index sets the flipping while optimized output changes the wavefunction specification in the arguments.

get_spin_state_number(self, flip=False)

source code 

Returns the number corresponding to the spin state, with a minus sign for incoming fermions. For flip=True, this spin_state_number is suited for find the index in the interaction of a MOTHER wavefunction.

find_leg_index(self, pdg_code, spin_state)

source code 

Find the place in the interaction list of the given particle with pdg 'pdg_code' and spin 'spin_stat'. For interactions with several identical particles (or fermion pairs) the outgoing index is always the first occurence.

get_lcutspinletter(self)

source code 

Returns S,V or F depending on the spin of the mother loop particle. Return '' otherwise.

get_s_and_t_channels(self, ninitial, mother_leg, reverse_t_ch=False)

source code 

Returns two lists of vertices corresponding to the s- and t-channels that can be traced from this wavefunction, ordered from the outermost s-channel and in/down towards the highest (if not reverse_t_ch) or lowest (if reverse_t_ch) number initial state leg. mother_leg corresponds to self but with correct leg number = min(final state mothers).

__eq__(self, other)
(Equality operator)

source code 

Overloading the equality operator, to make comparison easy when checking if wavefunction is already written, or when checking for identical processes. Note that the number for this wavefunction, the pdg code, and the interaction id are irrelevant, while the numbers for the mothers are important.

Overrides: dict.__eq__

__ne__(self, other)

source code 

Overloading the nonequality operator, to make comparison easy

Overrides: dict.__ne__

LEGACY_get_interaction_q_power(self)

source code 

Returns the power of the loop momentum q brought by the interaction and propagator from which this loop wavefunction originates. This is done in a SM ad-hoc way, but it should be promoted to be general in the future, by reading the lorentz structure of the interaction. This function is now rendered obsolete by the use of the function get_analytical_info. It is however kept for legacy.


Class Variable Details [hide private]

supported_analytical_info

Value:
['wavefunction_rank', 'interaction_rank']