Class FeynmanDiagram

Store the information concerning this diagram. This routines didn't perform any action at all. diagram: The diagram object to draw model: The model associate to the diagram amplitude: tell if the diagram has already fixed the I/O state of the fermion opt: A DrawingOpt instance with all options for drawing the diagram.

Find the position of leg in self._treated_legs

if equal=0 returns the last position of number in the list otherwise check that leg is the item in self._treated_legs

the two methods provides the same result if they provide a result. But some times equal=0 mode provides result when equal=1 doesn't. To my understanding equal=1 is suppose to be sufficient in all cases but gg> 7x( g ) fails with using equal=1 only.

'end' removes the last 'end' element of the list, before looking at the id in the list. (the list is not modify)

Find the position of leg in self._treated_legs. Use object equality to find the position.

1) Extend the vertex to a VertexPoint. 
2) Add this vertex in vertexList of the diagram
3) Update vertex.lines list. (first update the leg into line if needed)
4) assign line.start[end] to this vertex. (in end if start is already
        assigned to another vertex). the start-end will be flip later
        if needed.
5) if the fermion flow is correctly set by the diagram (amplitude=True)
   Then change the particles/anti-particles states accordingly.

Extend the leg to Feynman line. Associate the line to the diagram.

The line of the last vertex breaks the rules that line before '>' exist previously and the one after don't. The last one can also already exist and for the one before the '>' sometimes they arrive with a second object which is equivalent to another one but not the same object. discover those case and treat this properly.

Assign to each vertex a level: the level correspond to the number of visible particles and S-channel needed in order to reach the initial particles vertex.

This is computing by search level by level starting at level 0.

Define level for adjacent vertex. If those vertex is already defined do nothing Otherwise define as level+1 (at level 1 if T-channel)

This routine defines also self.max_level.

This routine is foreseen for an auto-recursive mode. So as soon as a vertex have his level defined. We launch this routine for this vertex.

Returns the vertex (T-vertex authorize) associate to level 1. We start with the vertex associate to first entry of previous_level and then following the T-line.

Returns the next t_vertex. i.e. the vertex following t_vertex. t_line indicates the 'wrong' T-direction. This routines returns also the 'good' evolution direction (which will be the wrong one at the next step).

Find a position to each vertex. All the vertex with the same level will have the same x coordinate. All external particles will be on the border of the square.

Finds the vertex position for the particle at 'level' given the ordering at previous level given by the vertexlist. if auto equals True then pass in auto-recursive mode.

Assign the position to each vertex of vertex_at_level.

The x-coordinate will the ratio of the current level with the maximum
level of the diagram.

If the first_vertex of vertex_at_level is an outgoing particle. Put it 
at y=0 if possible (this could be prevented by min>0 or by drawing 
option). if you put it at y=0 delete the vertex of the list to avoid 
duplications.

Do the symmetric case for the last entry of vertex_at_level.

The y-value for the other point is computed such that the distance 
between two vertex of the list are the same. the distance between min 
(resp. max) and the first vertex is also equal but if min=0 (resp.
max=1) then this distance counts half.

the option self.opt.external is used
if    equals 0, the external lines are authorizes to end only 
           at the end of the diagram (in x=1 axis) so this will forbid
           to put any vertex at y=0-1 (except if x=1)
if bigger than 0, minimal distance in before putting a external line
          on the border of the diagram.


The computation of y is done in this way
first compute the distance [dist] between two vertex and assign the point.
begin_gap and end_gap are the ratio of the compute distance to put
between min and first vertex.

Define the position of the vertex considering the distance required in the Drawing Options. Update the option if needed.

Removes all T-channel in a diagram and convert those in S-channel. This occur for 1>X diagram where T-channel are wrongly define.

Computes the directions of the lines of the diagrams.
first use simple rules as particles move in time directions (to right).
- define_line_orientation -. Then flip T-channel particles to 
correct fermion flow in T-channel. Majorana case not deal correctly 
at this stage.

Modify the position of some particles in order to improve the final
diagram look. This routines use one option
1) max_size which forbids external particles to be longer than max_size.
    This is in level unit. If a line is too long we contract it to 
    max_size preserving the orientation.
2) external indicating the minimal x-gap for an external line. This 
    constraints is already take into account in previous stage. But that
    stage cann't do non integer gap. So this routines correct this.

Check if two diagrams are equivalent. (same structure-same particle)

This function is not used for the moment. The initial purpose was the avoid duplication of identical diagram in the output (these could happen if we contract non propagating line). But the number of such comparaison rise as the number of diagram square such that the total time needed for this feature was consider as too (time-)expansive.

fake_vertex

Value:

{ 'id': 0, 'legs': [] }