From 941c9da59b2cd5ca7aaf9c434e915d6e9bb835bb Mon Sep 17 00:00:00 2001 From: Alexander Puck Neuwirth Date: Wed, 31 Jan 2024 22:32:30 +0100 Subject: [PATCH] Add Zj hvq dis --- debug/dis_hvq_Zj.ipynb | 321 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 debug/dis_hvq_Zj.ipynb diff --git a/debug/dis_hvq_Zj.ipynb b/debug/dis_hvq_Zj.ipynb new file mode 100644 index 000000000..e984a2add --- /dev/null +++ b/debug/dis_hvq_Zj.ipynb @@ -0,0 +1,321 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "4526ae87-9b7e-4cab-be7c-62c4b10d7c99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tPlease cite the following papers if you use this code:\n", + "\n", + " [1] Automatic Feynman graph generation J. Comput. Phys. 105 (1993) 279--289 https://doi.org/10.1006/jcph.1993.1074\n", + "\n", + " [2] Abusing Qgraf Nucl. Instrum. Methods Phys. Res. A 559 (2006) 220--223 https://doi.org/10.1016/j.nima.2005.11.151\n", + "\n", + " [3] Feynman graph generation and propagator mixing, I Comput. Phys. Commun. 269 (2021) 108103 https://doi.org/10.1016/j.cpc.2021.108103\n", + "\n", + "\t\n" + ] + } + ], + "source": [ + "import pyfeyn2\n", + "from feynml import *\n", + "# import renders\n", + "from pyfeyn2.render.latex.tikzfeynman import TikzFeynmanRender\n", + "from pyfeyn2.render.all import AllRender\n", + "from pyfeyn2.render.text.ascii import ASCIIRender\n", + "from pyfeyn2.render.text.unicode import UnicodeRender\n", + "# auto\n", + "from pyfeyn2.auto.position import auto_align_legs, scale_positions\n", + "from pyfeyn2.auto.position import feynman_adjust_points\n", + "from pyfeyn2.auto.label import auto_label\n", + "from pyfeyn2.auto.position import auto_align_legs,auto_grid\n", + "from pyfeyn2.auto.position import auto_vdw,auto_grid\n", + "from pyfeyn2.auto.bend import auto_bend\n", + "# util\n", + "import numpy as np\n", + "from xsdata.formats.dataclass.parsers import XmlParser\n", + "from pyqgraf import qgraf, model\n", + "from feynml.interface.qgraf import style" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "f4126da1-c09a-45e9-860f-342c333ec9af", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid 2, which is fermion. Using remnant now.\n", + " warnings.warn(\n", + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid -2, which is anti fermion. Using remnant now.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fd = FeynmanDiagram().add(\n", + " v1 := Vertex().with_xy(7,0),\n", + " v2 := Vertex().with_xy(10,0),\n", + " v3 := Vertex().with_xy(5,+5).with_shape('blob'),\n", + " v4 := Vertex().with_xy(5,-5).with_shape('blob'),\n", + " Propagator(pdgid=21).connect(v1,v2).with_color('red'),\n", + " Propagator(pdgid=-2).connect(v3,v1).with_color('red'),\n", + " Propagator(pdgid=2).connect(v4,v1).with_color('red'),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v3,sense='incoming').with_xy(0,5),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v4).with_incoming().with_xy(0,-5).with_style(\"label-side: right\"),\n", + " v5 := Vertex().with_xy(12,2),\n", + " v6 := Vertex().with_xy(15,4),\n", + " Propagator(pdgid=-4).connect(v2,v5).with_color('red'),\n", + " Propagator(pdgid=-24).connect(v5,v6),\n", + " Leg(pdgid=11,sense='outgoing').with_target(v6).with_xy(20,5).with_color('blue'),\n", + " Leg(pdgid=-12,sense='outgoing').with_target(v6).with_xy(20,3),\n", + " Leg(pdgid=-3,sense='outgoing').with_target(v5).with_xy(20,1),\n", + "\n", + " v7 := Vertex().with_xy(12,-2),\n", + " v8 := Vertex().with_xy(15,-4),\n", + " Propagator(pdgid=4).connect(v2,v7).with_color('red'),\n", + " Propagator(pdgid=24).connect(v7,v8),\n", + " Leg(pdgid=-11,sense='outgoing').with_target(v8).with_xy(20,-5).with_color('blue'),\n", + " Leg(pdgid=12,sense='outgoing').with_target(v8).with_xy(20,-3),\n", + " Leg(pdgid=3,sense='outgoing').with_target(v7).with_xy(20,-1),\n", + " \n", + " Leg(pdgid=2,type=\"remnant\",label=\"$X$\",sense='outgoing').with_target(v3).with_xy(10,+7),\n", + " Leg(pdgid=-2,type=\"remnant\",label=\"$X$\").with_target(v4).with_outgoing().with_xy(10,-7),\n", + ")\n", + "scale_positions(fd,0.5)\n", + "fd.render(auto_position=False,render=\"tikz\",file=\"hvq\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4aa7709f-b9aa-4723-a6fa-faf25de62455", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid 2, which is fermion. Using remnant now.\n", + " warnings.warn(\n", + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid -2, which is anti fermion. Using remnant now.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASoAAAEZCAMAAAAXCpgeAAAAIGNIUk0AAHomAACAhAAA+gAAAIDoAAB1MAAA6mAAADqYAAAXcJy6UTwAAAG8UExURf///wAAAAAAAAAAAEtLSwAAABsbG4qKiktLS2pqaq+vr46OjgAAAAAAAAAAAAAAAD09PQAAAAAAAAAAAGpqagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyMjAAAAAAAAAAAAAAAAAAAAK6urpKSknd3d2dnZwAAAAAAAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAP8AAAAA/wAA/wAA/wAA/wAA/wAA/wAA/wAA/wAA//8AAAAA/wAA/wAA/wAA//8AAAAA/wAA/wAA/wAA/wAA/wAA//8AAP8AABwAagAA/9IAHgAA/wAA/wAA//8AAP8AAP8AAP8AAP8AAEdHR1VVVRMTEx4eHkFBQTo6OrKysnl5ec/Pz4ODg01NTY2NjWdnZ3d3d93d3f///5mZmaqqqiIiImZmZlVVVYiIiO7u7ru7u8zMzAAAAERERDIyMhkZGXBwcK+vryAgICgoKF9fXxERESQkJBsbG1JSUv8AAAAA/zMzMwwMDFdXV6KioggICDg4OGdnZ0Bn/HoAAABydFJOUwAAEXetRKA/5tr+mSHHdqPW9dbj9TP6tmb+XI4/7feIVd/vmMfO1qiqmapEVZndEYh3uzMiZszu6+i00rCY2Y/45N8iVardiJlEdxFwZjPuu8ZdkP2S8+Yx4enPYKCt8VzbuO/3es3y69fa9I/+Iexc0nG6YLsAAAABYktHRACIBR1IAAAACXBIWXMAAABkAAAAZAAPlsXdAAAAB3RJTUUH6AEeDRUYl2TXQgAAERNJREFUeNrtnYl727YZxoN0ybpNomq5lRrLWXe03cr71u52cxvHzuJ02X1v3X1vidK0Tcp2W3equ//h4QMpW5JFEpQI4IOb93ms6JFpkfrpxQvgI8icO3eOaK/zD71Lwl7O6Y/qwsVbtyfvFr8f3VGdf+jhO5PJ5OX3iN+V3qiYoSa3b9195b3id6YxqpmhXr372r3J5H3C94cMVafb7RrE6HZ7dVueGOr+ZHLvziMXhB8bMlSEbPXpw7ZRvdGioV5/9OJjEo4MHaregJBhp3KTZUM9fl7KkaFDRS71ulWklBiKCR+q7mCn/JeKDMWED1UvK0OlzlBM6FCNdrb7K3+h0lBM2FAZI2JcOp1Vig3FhAzVzog+DIZLryo3FBMqVEY/owOq0dagO/ciBkMxoUK1QjgMxYQaFRpDMSFGhchQTFhR4TIUE05U2AzFhBAVQkMxoUOF0lBMuFBhNRRTM1S7Qo8Fr6GYmqGajaIvt38gqA3F1AhVp5jzD7O2DwO5oZgaoerllaTOMOvw/1G98BuKqRGqmalIZvD/UVao7Pc6GIoTVWe4bYy64KfdvDhiGOQSL6qCUZY/Pf17TQzFiapHtnaJsU2fDfMOkAK7XHuabkZqxon9LLPSxlCcqDqdAeUFfV7e/kY9w9jq1r5xAWqJ1RwsnQzFiYqMKKI+tdIOs1IHWmGXD9WKn5n0MhQvqu6QdAa0y8tPz7G86nIMrLLVrOBHO0PxotoaGn1IdXCS0R8Y0BwH9bYq4ZTpaChOVJ2tfD4zGjV646yU1fv1MxQnqlFhIK54miNV8kMR6mcoPlRGv88GUZ2GqMpY0d/oZyg+VDPtNqsqlLY/YKWdoZi4UT3xgSZvm1X8kEw7QzFRVBee4NEHsw91P8y1JSiryCqSaWeoGaonJzx6A6ZzkMZcqmp/p+Y3moiieuo+j97M6wO//8MfebbOqtqfvqievsWjt4payp/+zLN1dVap/tBro2rQAP8C42yuBliZVao/9NqoPvIaj/6aZX/7O9eWoDOaVXwbfvSZJh38Gc0qEW+bZWcyq4S8b9UcUPVnXlPCUJ259ifuRHxlH6ilxKEqr+1pKnHLO7Kz5SmhK2GyM+UpsYuGsrPkKcHrq7LlU6Y6kxK9FG2eld6gJKzay45lWqo/7GaSuMDRdlR/2M0kcy2o66n+tBtJJio/UP1p11EQRvkTmahi9/ip5edCHV9JmNBH1yoOW+pi7JNgj61csWocq2WlPn10Y5ceX0gcdtiJVFQaBHvsmh58p6ZNSMoiwyW59125S/xPgt0LnIjEYWvvbPu2n2z0Dl6aUg/5CeAJ6ftRVB48mgkLq8SRi+ok2BOwdeK39cYWhQ5GWE/hmPom8W2THqEF359jWfDccRKGEHYwjuWiij82e+Z5LilCoA2ZyXpjEX9M/zAyI3owvk/GtL8LqKWIbbJv0aQvkChNU99PI9nX2Hz8E7NncCzuJm+1oGlM4rTRXwRjCE7Xo4Atn4QeBGkIWQXeIg59Q5oPqev7rkXixPakX470yeks2emXSK2+dptZEviBtzXbbko/+NiDCAohsynkkPrbteGrS6b0mDwzdR3ftYln28delYwqnM5YWY4VhEFb4/ckSdJ67LELvb8ZQwcwzX3tQfcWJgApGgf00Xfd0HfpM8teGsnIRzVj5cU0sFp869Kogk/suZDcfpLQnYceZHYY03ZHkxu85aXQ6AIIJRhQRauHewpQTdsfXfk2gY+/LDYjSd0EZgdRCt0bxJGfRPQxSaErICZrdK7pOiEdUHlWVL4TyajcqRBWgW0vtmXWtdLPDw0d+lrqoJR1JSF0aT7EmjOmf2FRSGYYwrOobieSUTFSU7f2sNZXBMh8NhZyCR1UWg7Mp6iPQmiGAXgvmUYAzHFDM4VnnEejANWn2ur2liFBwtgsuUMPkjuFhkmBwfCNRjVsMg1odqVO6IZ0DEDiRl+ZbFSu/+mg9XdlHzlKIblDCzq2EFoc9RQA8x0IfA8ao2eaJoUEo4E1fC0ZlbVQitlcHoSS56aAxIZkN/OJiQ2obDarIyaNIs+H9gZjALJ241dwRXw7NXbPglCiYyDIbEhu6iA2EPVCKKKw7s0ZRzBQosnlQpBvWPFRgGrjUgwbG4ZOymbJxcQEujpARRsaUAmm9PsIXN90Xb+twZuK+yysX2NPoPXQzx9DZjusY4OJiQuoSGrCd2BNEzqfc2lCpWa7tXwVqNapsdvQbSas3wph+k87tuB4YuKzgaQ39unYACa4aSiiuqoCVbNgtyB1rBSmeL5l5xMTqLhZMJBMUjePrIiNLFM3FDdkU3KjE85gj2AEHrsmzNXseG5iAsVJawzNkDgw/Q/NxBynok9pKEFVG+yxDxho1zWbktAm50LR1mMlJSiZ0J4t8TwztJ1xulmlGDWqimBn2QNjaw9CyYygY6PJQ/MbKpIpjA3oxCSI6dzFpoOAQOJBq0G1MtghrIkDpVkyJcXEBCpuHlTinBScGE2diI4B7CBMWyvLI0e1FOysgBk4oQ1OyivJbGISAarEhZGANzZt+jRJzNBRdD5f0f2rZsFuw+e2Qhg2+lYEE5MITr44CQCLxmwMEKZJbLmJzSpKCqUIVRHssRuErMyeT0xCMBj8Kq/sknAcRFbqR35oCizbIEdVBDt0bx6cnoSKWwgTXS91Wfc2piYLnSgw8azKUoUqD3basVEUngvTXTpEgk4/mDq2ZZpx4qx/ClSMVKEqgt2NoMNLxnn3FgaWn8a2b8oZKDWUstsSfuZZeIxY9xbR+b/luxFtb4FqIOVShip4DpLaS8e+HbgWbW+tnRMUJXU3u/zs5+iQgE5ObL+1ipJYqUPl02DykS5FWyl1qFqtscuQwrvN4hkx8UkhKg2WOy5I5T2MNVvHrhKVZuvYVaLSK9j3lN5EXKNgf/6FK0pRzQV7hHnN/97+lasHim9NfxLsCd4rSaihDq8R1Xfxxx/suaGY1KI6Cfa2r45oRzNDMSn+vyGOg73lqyPa0JyhmBSjsmc+avnqiM21YCgm1f/jyPTzxZN2r45YqcN90AHHlsuGYlKOaloUh9u9OmIjnTYUk3pUBat2r45Y0rX96wfX+TZdaSgmBKgKVm1fHTGvFyinQ54NSwzFhAHVVPQJmqMbBwelBE5UbigmFKhEszp4kWOjKkMx4UA1FVu5OgJUlT1fjaGYMKByhZ+N2H/+4PpR+a9rDcWkHpX5BQkDz71yEjyGYlKNKojV1tj5DMWkGhVIdo396KDQzS9yGooJAyrZpZjDtwt96cuchmLCgEp2jf1aQeorR43+DAMq7hp7Wx3lVUbqRjNSOFBVBrudV5LhaTvlrL39r65DCgeqymAPE494bBW/10ZXybq8K2uQQoKqIthjgJSvUk82Xjs7G0MdrkEKCaqKYIcYc3I7bWqqkzHUtTVIIUFVHexOfguFOKAP/nQcEW+NCiD3oLxUSFBVBXuS5klGB/YksSCxmhciGgzKS4UEVUWwM1KQUmwVMoHrcRuaanNDMWFBVRrs1hhuj0ThRMdearZ2tA1DMWFBVRbskTsz1AmgBsOrlgzFhAVVSbDHY5MOP12G6vg17vbXmqGY0KCqK8XYx4ASvvlNm4ZiQoOqrhTjr3hWoXYNxYQHVXUpxjsBFJA6tW4oJjyoqksxMX9VQYChmPCgame5oxhDMSFC1UKNXZShmBChgmBPivNcsV90eEmxjMEqlj567Lp59kK+pXd8P16BhkKHyg8cM2AXLUdukt9nwnF8NgO0ixe81HfYkqwkDdjgFO4Jx9wo1FDoUH3t63BPXIrGoxQ8dhMYSgFujxdRgPAigUvnoSRj0a0iGF4AQDMg8Te+eVP04WFCla9v9EOLGSh27YDda9dxbHbpd+TaeeEq9G3mqCS14H4xlGqQfuvwygvPv3NQpXn62MX13ZFTTPuCom+MzHxw5flOVGwZ5C/AHazJwdUr+3vvDFTRxuuLrwm1FiJUThtLh9a21n7tFnhQeS2dOF3TWjqhanHR+jrW0glV2uYiq2bW2tvf339xf79mYS0aVJuH+pIaWksjV7US6ovisdbxMm19ULUV6kuqtdbxMm19UAm7EqnaWpzLtJmwoGo11JdUYS2uZdqFkKBqPdQXVWqt+mXaJ0KCSkCoL6nEWjXLtOeFA5WgUF/UamvtcRe5cKCSdXkptda3b87WFzctBOJAJTLUF3XtO7PlxW9riUpwqC/qekHqatM/RIFKfKjPq2DV+IwFBlRSQn1OjNV3GxcfMKCSfs8AYHXYuK6FAZW8UJ/p4AYL9WbFBwSopIZ6oaNidtzEWghQyQ31U+K2lnpUskP9tDitpR4VihvB8FhLPSr5ob5S9dZSjkpFqJeoxlrKUSkO9UVVWks1KvWhvqRya6lGhSLUF1VmLdmolm8UhyTUl7TSWrJRLd0oDlGoL2qFtaS7avFGcahCfUnL1pKeVQs3ikMX6otatJZ0VAs3ikMY6kuas5Z0VAs3isMZ6os6tpb8wcLcjeK+933VHPiUW0vluCp67iXVEHgF1lKIKvrBFH1UzelIHapoPNUKlboGCKQeoOIRI/UAFYdyUg9QccgOGSqsM8CVUpZV8Us/fICKU2mchA9Q8YiVX7T675GUocJcflktVaiQl19WSRUq/OWXU1KFSofyy5JUDUG16vtyKUKlX6irQqVhqKtCpWGoq0KlYagrQqVjqCtCpWOoq0GlZairQaVlqKtBpWWoK0GlZ6grQaVnqCs5Ea9nqKtApWmoq0ClaagrQKVrqCtApWuoK1gLqmuoK1hhrGuoy0elbahLR6VvqEtHpW+oy0alcajLRqVxqMtGpXGoS0alc6hLRqVzqMtFpXWoy0WldajLRaV1qEtFpXeoy0CVzaR3qAtHRQmRDP5lz1V/2M0kFtUcJ5Jz01giUWULnMiMnK4S7arTP9pKHKpsFSedfSUQ1UpPaZxXwlBlJT/62koUquzssRKHqpTVA1SLKuWUacuKG9UzD51v8LaV7U9fVD/6MY9+kmU//RnXlqCsKtf1RfXkhEdvwIz3H3fucW08qcwpfVE9dZ9Hb+blgX/+6988W2dnM6uevsWjt3JU//nv/3i2PqNZJagBnsWs4o/1nzeJ9bOYVXwbNhwsVGbVw43eC4uaDUF3ubfMqrJqcvvWxQuqP3ljNUPVLf69XLtlVa6/+jJNszvaWasRqk4//3dYnzZVc8D7r9y9dXuinbUaoert5MSGWWdtVln2i8nk3mt39bNWI1QzU5HMqEeVlbW/xx+BIUcTa3W63a5BjG63hxtVZ7htjLrgp90he8EwyKV6VGXtD/557OKjrzez1hZ8S9sce1WKqke2domxTZ8N8w6QArvM8/VW1arON7RWb0D3W9/qFaPqdOhh9qDPy9vfqGcYW93aNyYr2+Bcf9DMWpd6XcWkeLJqRBH1qZV2mJU60Aq7XKjqTpk2sVZ3sKOYFA+q7pB0BvQrzb9Wllfd+oFVwWpuKLpq7sdtrV6mA6qtodGH4wQnGf2BAc1xwGkrMre8Y/Wv+aw12tnu40fV2crnM6ORqGOot5YxIsYl/Fk1KgzE76PmqrHWDnxLg6FKToQDldHvs+FMRyQqUmUtow8j3tFWg0avBtVMu/xVhTXVdKwlW6r/c5ZFNR/GSxQuVKithQ0VwWsthKiwWgslKoLSWlhRIbQWXlQEm7VQo8JlLeSoCCJr4UeFxlo6oCI4rKUJKgzW0gYVUW4tnVAptpZeqIhKa2mHSp21NERFFFlLT1QrrPWY8F3qioosW+uXwvenMaoFa/3q18L3pjUqcmKt34jfle6oZtb6rfgd6Y+KgLV+J2Ev/wdNm5TrFpZbwAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAyNC0wMS0zMFQxMzoyMToyNCswMDowMPVEUgcAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMjQtMDEtMzBUMTM6MjE6MjQrMDA6MDCEGeq7AAAAKHRFWHRkYXRlOnRpbWVzdGFtcAAyMDI0LTAxLTMwVDEzOjIxOjI0KzAwOjAw0wzLZAAAABN0RVh0cGRmOlZlcnNpb24AUERGLTEuNVM2WsEAAABKdEVYdHNpZ25hdHVyZQA3Y2FhMjJhNjExMGE2NDBkYzkwYzA5OTkxYTZhZTUyMzFkYWVlZDdjMzYxMDcwYzAyNzc0NjJlYmI1MjQ5NWQ0yGoRtwAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fd = FeynmanDiagram().add(\n", + " v1 := Vertex().with_xy(7,0),\n", + " vh := Vertex().with_xy(6,2.5),\n", + " v2 := Vertex().with_xy(10,0),\n", + " v3 := Vertex().with_xy(5,+5).with_shape('blob'),\n", + " v4 := Vertex().with_xy(5,-5).with_shape('blob'),\n", + " Propagator(pdgid=22,label=\"$Z/\\\\gamma$\").connect(v1,v2).with_color('red'),\n", + " Propagator(pdgid=-2).connect(vh,v1).with_color('red'),\n", + " Propagator(pdgid=-2).connect(v3,vh).with_color('red'),\n", + " Propagator(pdgid=2).connect(v4,v1).with_color('red'),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v3,sense='incoming').with_xy(0,5),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v4).with_incoming().with_xy(0,-5).with_style(\"label-side: right\"),\n", + "\n", + " \n", + " Leg(pdgid=21,target=vh,sense='outgoing').with_xy(15,4).with_color('red'),\n", + " Leg(pdgid=2,type=\"remnant\",label=\"$X$\",sense='outgoing').with_target(v3).with_xy(10,+7),\n", + " Leg(pdgid=-2,type=\"remnant\",label=\"$X$\").with_target(v4).with_outgoing().with_xy(10,-7),\n", + " Leg(pdgid=11,sense='outgoing').with_target(v2).with_xy(15,2).with_color('blue'),\n", + " Leg(pdgid=-11).with_target(v2).with_outgoing().with_xy(15,-2).with_color('blue'),\n", + ")\n", + "scale_positions(fd,0.5)\n", + "fd.render(auto_position=False,render=\"tikz\",file=\"Zj\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1a7fde5f-544c-4a8b-9f90-5d43c781a3c2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid -2, which is anti fermion. Using remnant now.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fd = FeynmanDiagram().add(\n", + " v1 := Vertex().with_xy(7,0),\n", + " v2 := Vertex().with_xy(10,0),\n", + " v3 := Vertex().with_xy(5,+5),\n", + " v4 := Vertex().with_xy(5,-5).with_shape('blob'),\n", + " #Propagator(pdgid=2).connect(v1,v2).with_color('red'),\n", + " Propagator(pdgid=22,label=\"$Z/\\\\gamma$\").connect(v3,v1).with_color('red').with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec q$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Propagator(pdgid=2).connect(v4,v1).with_color('red').with_momentum(Momentum(name=\"$\\\\vec p_i$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=11,target=v3,sense='incoming').with_xy(0,5).with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec k_i$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v4).with_incoming().with_xy(0,-5).with_style(\"label-side: right\").with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec P$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + "\n", + " Leg(pdgid=11,sense='outgoing').with_target(v3).with_xy(10,+7).with_style(\"label-side: right\").with_momentum(Momentum(name=\"$\\\\vec k_f$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=-2,type=\"remnant\",label=\"$X$\").with_target(v4).with_outgoing().with_xy(10,-7),\n", + " Leg(pdgid=2,sense='outgoing').with_target(v1).with_xy(15,0).with_color('red').with_momentum(Momentum(name=\"$\\\\vec p_f$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " #Leg(pdgid=-11).with_target(v2).with_outgoing().with_xy(15,-2).with_color('blue'),\n", + ")\n", + "scale_positions(fd,0.5)\n", + "fd.render(auto_position=False,render=\"tikz\",file=\"DISNC\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "667e3870-42c0-4a77-955a-4f5c14fe1e8c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apn/.cache/pypoetry/virtualenvs/pyfeyn2-rvdu2REa-py3.11/lib/python3.11/site-packages/feynml/pdgid.py:111: UserWarning: Type remnant is not consistent with pdgid -2, which is anti fermion. Using remnant now.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fd = FeynmanDiagram().add(\n", + " v1 := Vertex().with_xy(7,0),\n", + " v2 := Vertex().with_xy(10,0),\n", + " v3 := Vertex().with_xy(5,+5),\n", + " v4 := Vertex().with_xy(5,-5).with_shape('blob'),\n", + " #Propagator(pdgid=2).connect(v1,v2).with_color('red'),\n", + " Propagator(pdgid=-24).connect(v3,v1).with_color('red').with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec q$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Propagator(pdgid=2).connect(v4,v1).with_color('red').with_momentum(Momentum(name=\"$\\\\vec p_i$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=11,target=v3,sense='incoming').with_xy(0,5).with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec k_i$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=2212,label=\"$p/A$\",target=v4).with_incoming().with_xy(0,-5).with_style(\"label-side: right\").with_style(\"label-side: left\").with_momentum(Momentum(name=\"$\\\\vec P$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + "\n", + " Leg(pdgid=12,sense='outgoing').with_target(v3).with_xy(10,+7).with_style(\"label-side: right\").with_momentum(Momentum(name=\"$\\\\vec k_f$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " Leg(pdgid=-2,type=\"remnant\",label=\"$X$\").with_target(v4).with_outgoing().with_xy(10,-7),\n", + " Leg(pdgid=1,sense='outgoing').with_target(v1).with_xy(15,0).with_color('red').with_momentum(Momentum(name=\"$\\\\vec p_f$\")).with_style(\"momentum-arrow : true; momentum-arrow-sense : -1\"),\n", + " #Leg(pdgid=-11).with_target(v2).with_outgoing().with_xy(15,-2).with_color('blue'),\n", + ")\n", + "scale_positions(fd,0.5)\n", + "fd.render(auto_position=False,render=\"tikz\",file=\"DISCC\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "27b1d0cd-dc52-4d75-970e-336e95c41e32", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fd = FeynmanDiagram().add(\n", + " v1 := Vertex().with_xy(5,0),\n", + " v2 := Vertex().with_xy(10,0),\n", + " v3 := Vertex().with_xy(5,+5).with_shape('blob'),\n", + " v4 := Vertex().with_xy(5,-5).with_shape('blob'),\n", + " Propagator(pdgid=23).connect(v1,v2),\n", + " Propagator(pdgid=-2).connect(v1,v3),\n", + " Propagator(pdgid=2).connect(v1,v4),\n", + " Leg(pdgid=111,target=v3,sense='incoming').with_xy(0,5),\n", + " Leg(pdgid=111,target=v4).with_incoming().with_xy(0,-5),\n", + " Leg(pdgid=11,sense='outgoing').with_target(v2).with_xy(15,1),\n", + " Leg(pdgid=-11).with_target(v2).with_outgoing().with_xy(15,-1).with_color('green'),\n", + " Leg(pdgid=2,sense='outgoing').with_target(v3).with_xy(15,+5).with_color('blue'),\n", + " Leg(pdgid=2,sense='outgoing').with_target(v3).with_xy(15,+3).with_color('blue'),\n", + " Leg(pdgid=-2).with_target(v4).with_outgoing().with_xy(15,-5).with_color('red'),\n", + " Leg(pdgid=1).with_target(v4).with_outgoing().with_xy(15,-3).with_color('red'),\n", + ")\n", + "fd.render(auto_position=False,render=\"tikz\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4113eeca-e058-4499-bb47-557ebd364f22", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}