Class Amplitude

Default values for all properties

Overrides: base_objects.PhysicsObject.default_setup

Allow initialization with Process

Returns:

new empty dictionary

Overrides: object.__init__

Filter for valid amplitude property values.

Overrides: base_objects.PhysicsObject.filter

Get the value of the property name.

Returns: D[k] if k in D, else d

Overrides: dict.get

Return diagram property names as a nicely sorted list.

Overrides: base_objects.PhysicsObject.get_sorted_keys

Return an AmplitudeList with just this amplitude. Needed for DecayChainAmplitude.

Generate diagrams. Algorithm:

1. Define interaction dictionaries:
  * 2->0 (identity), 3->0, 4->0, ... , maxlegs->0
  * 2 -> 1, 3 -> 1, ..., maxlegs-1 -> 1 

2. Set flag from_group=true for all external particles.
   Flip particle/anti particle for incoming particles.

3. If there is a dictionary n->0 with n=number of external
   particles, create if possible the combination [(1,2,3,4,...)] 
   with *at least two* from_group==true. This will give a
   finished (set of) diagram(s) (done by reduce_leglist)

4. Create all allowed groupings of particles with at least one
   from_group==true (according to dictionaries n->1):
   [(1,2),3,4...],[1,(2,3),4,...],...,
                  [(1,2),(3,4),...],...,[(1,2,3),4,...],... 
   (done by combine_legs)

5. Replace each group with a (list of) new particle(s) with number 
   n = min(group numbers). Set from_group true for these
   particles and false for all other particles. Store vertex info.
   (done by merge_comb_legs)

6. Stop algorithm when at most 2 particles remain.
   Return all diagrams (lists of vertices).

7. Repeat from 3 (recursion done by reduce_leglist)

8. Replace final p=p vertex

Be aware that the resulting vertices have all particles outgoing,
so need to flip for incoming particles when used.

SPECIAL CASE: For A>BC... processes which are legs in decay
chains, we need to ensure that BC... combine first, giving A=A
as a final vertex. This case is defined by the Process
property is_decay_chain = True.

Return False if the coupling orders for any coupling is < 0, otherwise return the new coupling orders with the vertex orders subtracted. If coupling_orders is not given, return None (which counts as success). WEIGHTED is a special order, which corresponds to the sum of order hierarchys for the couplings.

Recursive function. Take a list of legs as an input, with
the reference dictionary n-1->1, and output a list of list of
tuples of Legs (allowed combinations) and Legs (rest). Algorithm:

1. Get all n-combinations from list [123456]: [12],..,[23],..,[123],..

2. For each combination, say [34]. Check if combination is valid.
   If so:

   a. Append [12[34]56] to result array

   b. Split [123456] at index(first element in combination+1),
      i.e. [12],[456] and subtract combination from second half,
      i.e.: [456]-[34]=[56]. Repeat from 1. with this array

3. Take result array from call to 1. (here, [[56]]) and append
   (first half in step b - combination) + combination + (result
   from 1.) = [12[34][56]] to result array

4. After appending results from all n-combinations, return
   resulting array. Example, if [13] and [45] are valid
   combinations:
    [[[13]2456],[[13]2[45]6],[123[45]6]] 

Takes a list of allowed leg combinations as an input and returns a set of lists where combinations have been properly replaced (one list per element in the ref_dict, so that all possible intermediate particles are included). For each list, give the list of vertices corresponding to the executed merging, group the two as a tuple.

Create a set of new legs from the info given. This can be overloaded by daughter classes.

Allow for selection of vertex ids. This can be overloaded by daughter classes.