Package madgraph :: Package madweight :: Module diagram_class :: Class MG_diagram
[hide private]
[frames] | no frames]

Class MG_diagram

source code

substructure_class.diagram --+
                             |
                            MG_diagram
Known Subclasses:

Instance Methods [hide private]
 
__init__(self, dir_file, config, opt='default') source code
 
__str__(self) source code
 
check_decay(self, particle_list, decay_list)
check if the Particle_list is equivalent to the Decay_list if not return the list of correct Particle
source code
 
clear_solution(self)
supress all data from the solution in order to restart a new solution possibility
source code
 
define_Constraint_sector(self)
define the constraint sector and the different blob
source code
 
define_ECS_as_solution(self, ECS_list)
define ECS for a new (or a list) of new solution(s) for the ECS change of variable
source code
 
define_neutrino_stuff(self)
put all neutrino dependent variable
source code
 
define_parameter(self, param_card)
define mass+width of all particle
source code
 
define_tf_width(self, file)
assign width of the TF function for all external particle
source code
 
define_twin(self)
not use anymore: define the twin for all particle in the diagram
source code
 
detect_invisible_propa(self)
detect propagator decaying in fully invisible particle and treat this case
source code
 
detect_non_resonant_area(self)
detect the non resonant part of the diagram
source code
 
find_ECS_0neut(self, force=0)
find ECS containing no neutrino
source code
 
find_ECS_1neut(self)
find the lowest(s) neutrino and define ECS
source code
 
find_ECS_2neut(self)
return best 2 neutrino ECS...
source code
 
find_lowest_particle(self, neutrino=1, lowest_level=0, out_num=2)
find the one/two lowest (lower level) neutrino/particle, if the are ambiguity return more than two
source code
 
find_num_neut_decay(self)
find the number of neutrino in the decay chain for each propa
source code
 
identify_production_area(self, proc_decay)
identify (and tag) production part from the information decay of the proc_card
source code
 
import_ext_part(self, dir_file)
read leshouches.inc information
source code
 
import_process(self, dir_file, config)
definis le diagramme soit via un fichier, soit via un autre diagram
source code
 
organize_particle_content(self, param_card, tf_file)
define production area and organize all the needed information
source code
 
output_type_info(self)
return output containing the number of muon/electron/jet/bjet/invisible_part
source code
 
select_ECS(self, ECS_list, define_solution=1)
select the best(s) ECS (minimizing unfactorized propagator define solution if define==1
source code
 
set_option(self, info='default')
store the different option linked to the generation of this MG_diagram
source code
 
solve_blob_sector(self)
resolve the change of variable for blob
source code
 
tag_unaligned(self, unaligned)
store information that this propagator cann't be generated following BW restore the other propagator
source code

Inherited from substructure_class.diagram: add_content, contains_particle, define_level, define_neut_content, order_in_level

Method Details [hide private]

__init__(self, dir_file, config, opt='default')
(Constructor)

source code 
Overrides: substructure_class.diagram.__init__

check_decay(self, particle_list, decay_list)

source code 
check if the Particle_list is equivalent to the Decay_list if not return the list of correct Particle

Step 1) check if we have correct number of particle ->if not decay one or the other and restart
     2) check if we have correct pid
     3) check for decay in each case

find_ECS_2neut(self)

source code 
return best 2 neutrino ECS
The way to solve this problem is globally the following:
- A: find the two lowest neutrino
- B: if both are at level 1 -> return F/G depending on TF on x1,x2
- C: check if both have two propagator free before them -> return D
- D: check if they are linked by a S-channel -> return E
- E: else return nothing (always best in one neutrino)

identify_production_area(self, proc_decay)

source code 
identify (and tag) production part from the information decay of the proc_card

Step:  1) -> find initial particle in this process (no mother or S channel with T channel mother)
       2) -> launch (self-iterative) check for the decay
       3) -> tag particle