Package madgraph :: Package madweight :: Module blob_solution :: Class Blob_solution
[hide private]
[frames] | no frames]

Class Blob_solution

source code

Level_generation --+
                   |
                  Blob_solution

store the information of how to generate a blob

Instance Methods [hide private]
 
__init__(self, blob_sec, solution='')
initialize how_gen: dict: Particle-> related block...
source code
 
copy_solution(self, solution)
duplicate solution (no alias use) in order to modify it later
source code
 
find_all_solutions(self, blob_sec)
(blob)->None : complete blob_sec.sol
source code
 
find_beta_solution(self, blob_sec)
find a first solution to resolve the blob.
source code
 
resolve_piece(self, blob_sec, in_part)
find the 'first' solution for this piece
source code
 
treat_conflicting_block(self, block)
if a 'C' block is block by a 'A' block it's sometimes more powerful to degrade the 'A' in 'B' if the 'C' can be upgrated to 'A'
source code
 
pass_in_solution(self, tag)
tag -> upgrate solution in order to fullfill taged criteria upgrate 'beta' solution following some criteria(tagged with tag)
source code
 
convert_DE_in_1(self)
convert all 'E*' and all 'D' in '1' block
source code
 
convert_E_in_D(self)
convert all 'E*' in 'D'
source code
 
extend_block(self, chgt_var)
put the A/D/E propagator in place to minize problem with thin transfer function
source code
 
del_ext1_in(self, particle_list)
delete blok '1' but only if the particle is an external one!
source code
 
debug(self)
function for debugging: print how_gen
source code
 
__str__(self) source code

Inherited from Level_generation: define_fuse_region, order_block

Method Details [hide private]

__init__(self, blob_sec, solution='')
(Constructor)

source code 
initialize how_gen: dict: Particle-> related block
           step: list of all needed block in the correct order
update link with the related blob

Overrides: Level_generation.__init__

find_all_solutions(self, blob_sec)

source code 
(blob)->None : complete blob_sec.sol

* find tree solutions:
    1) this solutions maximize the number of propagator generated following BW
    2) this solutions maximize the number of external particle generated following tf (i.e. all execpt neutrino)
    3) this solutions try to be an intermediate solution between the two
* In practise, we start to construct a 'beta' solution, which one will identify globaly the structure of the solution
    The beta try to made the more local change, and don't consider E case (but have E* tag for an D which can pass in E)
* Secondly we will apply modification to this beta, to pass in each solution case
    The first solution will be the first one with improvment in 'A' case and will restore 'E'(and extend E) case
    the second one will change all 'D','E' in '1', with little modification in 'A' case
    The third solution will be essentially the beta without 'E' (only D for visible case)

find_beta_solution(self, blob_sec)

source code 

find a first solution to resolve the blob. The idea is to take the more local possibility in all case this is perhaps not the best solution but it's only the beginning of the resolution Secondly we will not defined 'final' block but some more generic one (like E*: restriction at one level of E)