{ "cells": [ { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import mcstasscript as ms" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "KVASIR = ms.McStas_instr(\"KVASIR\")\n", "#EXAMPLE: interated intensity on detector when running vanadium as sample: 0.0268478\n", "t = KVASIR.add_parameter(\"t\", value=0) # Wedge no. (330 total to cover 0-170deg)\n", "\n", "l_analyzers =[2.5035035035035036, 2.5105105105105103, 2.5175175175175175, 2.5245245245245247, 2.5305305305305303, 2.5375375375375375, 2.5435435435435436, 2.5505505505505504, 2.5565565565565564, 2.5625625625625625, 2.5695695695695697, 2.5755755755755754, 2.5815815815815815, 2.5875875875875876, 2.5925925925925926, 2.5985985985985987, 2.6046046046046047, 2.6096096096096097, 2.6156156156156154, 2.6206206206206204, 2.6266266266266265, 2.6316316316316315, 2.6366366366366365, 2.6416416416416415, 2.6466466466466465, 2.6516516516516515, 2.6566566566566565, 2.6616616616616615, 2.6656656656656654, 2.6706706706706704, 2.674674674674675, 2.67967967967968, 2.6836836836836837, 2.6886886886886887, 2.6926926926926926, 2.6966966966966965, 2.7007007007007005, 2.704704704704705, 2.7087087087087087, 2.7127127127127126, 2.7157157157157155, 2.71971971971972, 2.7237237237237237, 2.7267267267267266, 2.7307307307307305, 2.7337337337337337, 2.736736736736737, 2.7407407407407405, 2.7437437437437437, 2.746746746746747, 2.74974974974975, 2.7527527527527527, 2.754754754754755, 2.7577577577577577, 2.7607607607607605, 2.7637637637637638, 2.7657657657657655, 2.7687687687687688, 2.7707707707707705, 2.7727727727727727, 2.7757757757757755, 2.7777777777777777, 2.77977977977978, 2.781781781781782, 2.7837837837837838, 2.7857857857857855, 2.7877877877877877, 2.78978978978979, 2.7907907907907905, 2.7927927927927927, 2.793793793793794, 2.7957957957957955, 2.796796796796797, 2.798798798798799, 2.7997997997998, 2.8008008008008005, 2.801801801801802, 2.8028028028028027, 2.804804804804805, 2.804804804804805] #array containg nummerical solution for distance from sample to n'th analyzer in wedge\n", "\n", "N_analyzer =60 #1 total number of analyzers\n", "width = 0.0127 #m width of He3 tubes, height of analyzer crystals\n", "dt = 2*np.arcsin(width/(2*2.5))*180/np.pi #deg vertical angle between each analyzer crystal seen from sample position\n", "theta = np.linspace(-dt/2,-dt*N_analyzer-dt/2, N_analyzer) #deg array containg rotations" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# PARAMETERS\n", "width= KVASIR.add_declare_var(\"double\", \"width\", value=0.0127) #m width of He3 tubes, height of analyzer crystals\n", "d_PG= KVASIR.add_declare_var(\"double\", \"d_PG\", value=3.355) #Å lattice spacing og pyrolytic graphite\n", "u = KVASIR.add_declare_var(\"double\",\"u\", value=1e-5) #1 small number\n", "h_D = KVASIR.add_declare_var(\"double\", \"h_D\", value=0.4) #m heigt of detector \n", "\n", "Ef = KVASIR.add_declare_var(\"double\",\"Ef\", value=1.95) #meV focusing energy \n", "d_AD = KVASIR.add_declare_var(\"double\",\"d_AD\", value=1.25) #m distance from analyzer to detactor\n", "d_SA = KVASIR.add_declare_var(\"double\",\"d_SA\", value=2.5) #m distance from sample to central analyzer\n", "d_GS = KVASIR.add_declare_var(\"double\",\"d_GS\", value=0.58) #m distance from guide end to sample position\n", "\n", "lamda_f = KVASIR.add_declare_var(\"double\", \"lambda_f\") #Å final wavelenght\n", "KVASIR.append_initialize(\"lambda_f=1/(0.11056*sqrt(Ef));\")\n", "\n", "#ANALYZER CALCULATION\n", "tA = KVASIR.add_declare_var(\"double\", \"tA\") #deg Bragg angle of analyzer\n", "KVASIR.append_initialize(\"tA=asin(lambda_f/(2*d_PG))*RAD2DEG;\")\n", "\n", "dtS = KVASIR.add_declare_var(\"double\", \"dtS\", value=[*theta], array = len(theta)) #deg array containg rotations\n", "\n", "len = KVASIR.add_declare_var(\"double\", \"len\", value=l_analyzers, array = len(l_analyzers)) #array containg nummerical solution for distance from sample to n'th analyzer in wedge\n", "\n", "#DETECTOR CALCULATION\n", "d_SDz = KVASIR.add_declare_var(\"double\", \"d_SDz\") #m vetical distance from scattering plane to center of detector\n", "KVASIR.append_initialize(\"d_SDz=d_SA+d_AD*cos(2*tA*DEG2RAD);\")\n", "\n", "d_SDy = KVASIR.add_declare_var(\"double\", \"d_SDy\") #m distance from sample to detector in scattering plane\n", "KVASIR.append_initialize(\"d_SDy=d_AD*sin(2*tA*DEG2RAD);\")\n", "\n", "tDy= KVASIR.add_declare_var(\"double\", \"tDy\") #deg horizontal angle between wedges \n", "KVASIR.append_initialize(\"tDy=asin(width/(d_SDz))*RAD2DEG;\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "## SOURCE OPTION 1: DUMMY SOURCE OPTION\n", "# source = KVASIR.add_component(f\"source\", \"Source_Maxwell_3\", AT=[0,0,0], RELATIVE=\"ABSOLUTE\")\n", "# source.xwidth=0.01\n", "# source.yheight=0.01\n", "# source.Lmin= \"lambda_f-D_lambda/2\"\n", "# source.Lmax= \"lambda_f+D_lambda/2\"\n", "# source.dist= d_SA\n", "# source.focus_yh= f\"width*2*{N_analyzer}\"\n", "# source.focus_xw=f\"width*3\"\n", "# source.T1=300\n", "# source.T2=300\n", "# source.T3=300\n", "# source.I1=1E15\n", "# source.I2=1E15\n", "# source.I3=1E15\n", "\n", "## SOURCE OPTION 2: IMPORT MCPL FILE FROM PRIMARY SPECTROMETER\n", "source = KVASIR.add_component(f\"source\", \"MCPL_input\", AT=[0,0,0], RELATIVE=\"ABSOLUTE\")\n", "source.filename= '\"Virtual_output_example.mcpl.gz\"' #EXAMPLE MCPL: BIFROST GUIDE, 100mus PSC opening time, wavelength band is centered at 1.95meV and narrowed to speed up simulations\n", "source.pos_smear = 0.005\n", "source.dir_smear = 0.05\n", "\n", "#ARM DEFINES SAMPLE POSITION (0.58m is distance from BIFROST guide opening to sample position)\n", "Arm_sample = KVASIR.add_component(f\"Arm_sample\", \"Arm\", AT=[0,0,d_GS], ROTATED = [0,f\"tDy*t\",0], RELATIVE=\"ABSOLUTE\")\n", "\n", "## SAMPLE OPTION 1: VANADIUM\n", "sample = KVASIR.add_component(f\"sample\", \"Incoherent\", AT=[0,0,0], RELATIVE=\"Arm_sample\")\n", "sample.radius=0.005\n", "sample.yheight=0.01\n", "sample.thickness=0.001\n", "sample.target_index = 2\n", "sample.focus_ah =0.5\n", "sample.focus_aw = 20 \n", "\n", "## SAMPLE OPTION 1: POWDER SAMPLE\n", "# sample = KVASIR.add_component(f\"sample\", \"PowderN\", AT=[0,0,0], RELATIVE=\"Arm_sample\")\n", "# sample.radius=0.005\n", "# sample.yheight=0.01\n", "# sample.thickness=0.001\n", "# sample.reflections=\"Na2Ca3Al2F14.laz\"" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "for n in range(0,N_analyzer,2): #loops placing analyzers (every second analyzer is placed to avoid shading)\n", "\n", " az = KVASIR.add_declare_var(\"double\", f\"az_{n}\") #m z-component of n'th analyzer relative to sample position\n", " KVASIR.append_initialize(f\"az_{n} = len[{n}]*cos(dtS[{n}]*DEG2RAD)-d_SDz;\")\n", " \n", " ay = KVASIR.add_declare_var(\"double\", f\"ay_{n}\") #m y-component of n'th analyzer relative to sample position\n", " KVASIR.append_initialize(f\"ay_{n} = len[{n}]*sin(dtS[{n}]*DEG2RAD)-d_SDy;\")\n", "\n", " bz = KVASIR.add_declare_var(\"double\", f\"bz_{n}\") #m z-component of detector relative to n'th analyzer\n", " KVASIR.append_initialize(f\"bz_{n} = len[{n}]*cos(dtS[{n}]*DEG2RAD);\") \n", " \n", " by = KVASIR.add_declare_var(\"double\", f\"by_{n}\") #m y-component of detector relative to n'th analyzer\n", " KVASIR.append_initialize(f\"by_{n} = len[{n}]*sin(dtS[{n}]*DEG2RAD);\")\n", " \n", " dtA = KVASIR.add_declare_var(\"double\", f\"dtA_{n}\") #deg scattering angle of n'th analyzer\n", " KVASIR.append_initialize(f\"dtA_{n} = acos( (az_{n}*bz_{n} + ay_{n}*by_{n}) / (len[{n}]* sqrt(az_{n}*az_{n} + ay_{n}*ay_{n}) ) )*RAD2DEG;\")\n", "\n", " # GENERARING UPPER ANALYZER WEDGE\n", " Arm = KVASIR.add_component(f\"Arm_{n}\", \"Arm\", AT=[0,0,0], ROTATED=[f\"-dtS[{n}]\",0,0], RELATIVE=\"Arm_sample\") \n", " Analyser = KVASIR.add_component(f\"Analyzer_{n}\",\"Monochromator_flat\", AT = [0,0,f\"len[{n}]\"], ROTATED=[f\"dtA_{n}/2\",90,0], RELATIVE=f\"Arm_{n}\")\n", " Analyser.zwidth = f\"2*len[{n}]*sin(tDy/2*DEG2RAD)\"\n", " Analyser.yheight = width\n", " Analyser.mosaich = 90\n", " Analyser.mosaicv = 90\n", " Analyser.Q = 1.87278\n", " Analyser.r0 = 0.8\n", "\n", " ## GENERARING LOWER ANALYZER WEDGE\n", " # Arm = KVASIR.add_component(f\"Armm_{n}\", \"Arm\", AT=[0,0,0], ROTATED=[f\"dtS[{n}]\",0,0], RELATIVE=\"Arm_sample\")\n", " # Analyser = KVASIR.add_component(f\"Analyzerm_{n}\",\"Monochromator_flat\", AT = [0,0,f\"len[{n}]\"], ROTATED=[f\"-dtA_{n}/2\",90,0], RELATIVE=f\"Armm_{n}\" )\n", " # Analyser.zwidth = f\"2*len[{n}]*sin(tDy/2*DEG2RAD)\"\n", " # Analyser.yheight = width\n", " # Analyser.mosaich = 90\n", " # Analyser.mosaicv = 90\n", " # Analyser.Q = 1.87278\n", " # Analyser.r0 = 0.8" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "N_detectors = 1#24#230 #Number of detectors, centered around wedge (24 is recomended for single wedge to capture mosaic spread)\n", "\n", "for n in range(N_detectors):\n", " ## UPPER ToF MONITOR SECTION\n", " KVASIR.add_component(f\"arm_detector_{n}\", \"Arm\", AT = [0,0,0], RELATIVE=\"Arm_sample\", ROTATED=[0,f\"tDy*{n}-tDy*{N_detectors/2}\",0])\n", " det_He3 = KVASIR.add_component(f\"det_He3_{n}_ToF\", \"Monitor_nD\", AT = [0,\"d_SDy\", d_SDz], AT_RELATIVE=\"PREVIOUS\", ROTATED=[0,f\"tDy*{n}-tDy*{N_detectors/2}\",0], ROTATED_RELATIVE=\"Arm_sample\")\n", " det_He3.options = '\"cylinder, y, limits=[-0.2,0.2], bins=80, t, limits = [0.26,0.28], bins=500\"' # t, limits = [0.0069,0.00695] energy, limits = [1.82,1.84]\n", " det_He3.xwidth = width\n", " det_He3.yheight = \"h_D\"\n", " det_He3.filename = f'\"Detector_{n}_ToF.dat\"'\n", "\n", " ## UPPER ENERGY MONITOR SECTION\n", " # det_He3 = KVASIR.add_component(f\"det_He3_{n}\", \"Monitor_nD\", AT = [0,0, \"-u\"], AT_RELATIVE=\"PREVIOUS\")\n", " # det_He3.options = '\"cylinder, y, limits=[-0.2,0.2], bins=80, energy, limits = [1.9,2.1], bins=500\"' # t, limits = [0.0069,0.00695] energy, limits = [1.82,1.84]\n", " # det_He3.xwidth = width\n", " # det_He3.yheight = \"h_D\"\n", " # det_He3.filename = f'\"Detector_{n}.dat\"'\n", " # # det_He3.set_WHEN(\"wedge == 1\")\n", "\n", "\n", "\n", " ## LOWER ToF MONITOR SECTION\n", " # KVASIR.add_component(f\"arm_detector_{n}_lower\", \"Arm\", AT = [0,0,0], RELATIVE=\"Arm_sample\", ROTATED=[0,f\"tDy*{n}\",0])\n", " # det_He3 = KVASIR.add_component(f\"det_He3_{n}_lower\", \"Monitor_nD\", AT = [0,\"-d_SDy\", d_SDz], AT_RELATIVE=\"PREVIOUS\", ROTATED=[0,f\"tDy*{n}\",0], ROTATED_RELATIVE=\"Arm_sample\")\n", " # det_He3.options = '\"cylinder, y, limits=[-0.2,0.2], bins=300, t, limits = [0.27,0.278], bins=500\"' # t, limits = [0.0069,0.00695] energy, limits = [1.82,1.84]\n", " # det_He3.xwidth = width\n", " # det_He3.yheight = \"h_D\"\n", " # det_He3.filename = f'\"Detector_{n}_ToF_lower.dat\"'\n", "\n", " ## LOWER ENERGY MONITOR SECTION\n", " # det_He3 = KVASIR.add_component(f\"det_He3_{n}_ToF_lower\", \"Monitor_nD\", AT = [0,0, \"-u\"], AT_RELATIVE=\"PREVIOUS\")\n", " # det_He3.options = '\"cylinder, y, limits=[-0.2,0.2], bins=300, energy, limits = [1.9,2.1], bins=500\"' # t, limits = [0.0069,0.00695] energy, limits = [1.82,1.84]\n", " # det_He3.xwidth = width\n", " # det_He3.yheight = \"h_D\"\n", " # det_He3.filename = f'\"Detector_{n}_lower.dat\"'\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "source MCPL_input AT (0, 0, 0) ABSOLUTE \n", "Arm_sample Arm AT (0, 0, d_GS) ABSOLUTE \n", " ROTATED (0, tDy*t, 0) ABSOLUTE\n", "sample Incoherent AT (0, 0, 0) RELATIVE Arm_sample\n", "Arm_0 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[0], 0, 0) RELATIVE Arm_sample\n", "Analyzer_0 Monochromator_flat AT (0, 0, len[0]) RELATIVE Arm_0 \n", " ROTATED (dtA_0/2, 90, 0) RELATIVE Arm_0\n", "Arm_2 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[2], 0, 0) RELATIVE Arm_sample\n", "Analyzer_2 Monochromator_flat AT (0, 0, len[2]) RELATIVE Arm_2 \n", " ROTATED (dtA_2/2, 90, 0) RELATIVE Arm_2\n", "Arm_4 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[4], 0, 0) RELATIVE Arm_sample\n", "Analyzer_4 Monochromator_flat AT (0, 0, len[4]) RELATIVE Arm_4 \n", " ROTATED (dtA_4/2, 90, 0) RELATIVE Arm_4\n", "Arm_6 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[6], 0, 0) RELATIVE Arm_sample\n", "Analyzer_6 Monochromator_flat AT (0, 0, len[6]) RELATIVE Arm_6 \n", " ROTATED (dtA_6/2, 90, 0) RELATIVE Arm_6\n", "Arm_8 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[8], 0, 0) RELATIVE Arm_sample\n", "Analyzer_8 Monochromator_flat AT (0, 0, len[8]) RELATIVE Arm_8 \n", " ROTATED (dtA_8/2, 90, 0) RELATIVE Arm_8\n", "Arm_10 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[10], 0, 0) RELATIVE Arm_sample\n", "Analyzer_10 Monochromator_flat AT (0, 0, len[10]) RELATIVE Arm_10 \n", " ROTATED (dtA_10/2, 90, 0) RELATIVE Arm_10\n", "Arm_12 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[12], 0, 0) RELATIVE Arm_sample\n", "Analyzer_12 Monochromator_flat AT (0, 0, len[12]) RELATIVE Arm_12 \n", " ROTATED (dtA_12/2, 90, 0) RELATIVE Arm_12\n", "Arm_14 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[14], 0, 0) RELATIVE Arm_sample\n", "Analyzer_14 Monochromator_flat AT (0, 0, len[14]) RELATIVE Arm_14 \n", " ROTATED (dtA_14/2, 90, 0) RELATIVE Arm_14\n", "Arm_16 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[16], 0, 0) RELATIVE Arm_sample\n", "Analyzer_16 Monochromator_flat AT (0, 0, len[16]) RELATIVE Arm_16 \n", " ROTATED (dtA_16/2, 90, 0) RELATIVE Arm_16\n", "Arm_18 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[18], 0, 0) RELATIVE Arm_sample\n", "Analyzer_18 Monochromator_flat AT (0, 0, len[18]) RELATIVE Arm_18 \n", " ROTATED (dtA_18/2, 90, 0) RELATIVE Arm_18\n", "Arm_20 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[20], 0, 0) RELATIVE Arm_sample\n", "Analyzer_20 Monochromator_flat AT (0, 0, len[20]) RELATIVE Arm_20 \n", " ROTATED (dtA_20/2, 90, 0) RELATIVE Arm_20\n", "Arm_22 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[22], 0, 0) RELATIVE Arm_sample\n", "Analyzer_22 Monochromator_flat AT (0, 0, len[22]) RELATIVE Arm_22 \n", " ROTATED (dtA_22/2, 90, 0) RELATIVE Arm_22\n", "Arm_24 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[24], 0, 0) RELATIVE Arm_sample\n", "Analyzer_24 Monochromator_flat AT (0, 0, len[24]) RELATIVE Arm_24 \n", " ROTATED (dtA_24/2, 90, 0) RELATIVE Arm_24\n", "Arm_26 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[26], 0, 0) RELATIVE Arm_sample\n", "Analyzer_26 Monochromator_flat AT (0, 0, len[26]) RELATIVE Arm_26 \n", " ROTATED (dtA_26/2, 90, 0) RELATIVE Arm_26\n", "Arm_28 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[28], 0, 0) RELATIVE Arm_sample\n", "Analyzer_28 Monochromator_flat AT (0, 0, len[28]) RELATIVE Arm_28 \n", " ROTATED (dtA_28/2, 90, 0) RELATIVE Arm_28\n", "Arm_30 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[30], 0, 0) RELATIVE Arm_sample\n", "Analyzer_30 Monochromator_flat AT (0, 0, len[30]) RELATIVE Arm_30 \n", " ROTATED (dtA_30/2, 90, 0) RELATIVE Arm_30\n", "Arm_32 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[32], 0, 0) RELATIVE Arm_sample\n", "Analyzer_32 Monochromator_flat AT (0, 0, len[32]) RELATIVE Arm_32 \n", " ROTATED (dtA_32/2, 90, 0) RELATIVE Arm_32\n", "Arm_34 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[34], 0, 0) RELATIVE Arm_sample\n", "Analyzer_34 Monochromator_flat AT (0, 0, len[34]) RELATIVE Arm_34 \n", " ROTATED (dtA_34/2, 90, 0) RELATIVE Arm_34\n", "Arm_36 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[36], 0, 0) RELATIVE Arm_sample\n", "Analyzer_36 Monochromator_flat AT (0, 0, len[36]) RELATIVE Arm_36 \n", " ROTATED (dtA_36/2, 90, 0) RELATIVE Arm_36\n", "Arm_38 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[38], 0, 0) RELATIVE Arm_sample\n", "Analyzer_38 Monochromator_flat AT (0, 0, len[38]) RELATIVE Arm_38 \n", " ROTATED (dtA_38/2, 90, 0) RELATIVE Arm_38\n", "Arm_40 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[40], 0, 0) RELATIVE Arm_sample\n", "Analyzer_40 Monochromator_flat AT (0, 0, len[40]) RELATIVE Arm_40 \n", " ROTATED (dtA_40/2, 90, 0) RELATIVE Arm_40\n", "Arm_42 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[42], 0, 0) RELATIVE Arm_sample\n", "Analyzer_42 Monochromator_flat AT (0, 0, len[42]) RELATIVE Arm_42 \n", " ROTATED (dtA_42/2, 90, 0) RELATIVE Arm_42\n", "Arm_44 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[44], 0, 0) RELATIVE Arm_sample\n", "Analyzer_44 Monochromator_flat AT (0, 0, len[44]) RELATIVE Arm_44 \n", " ROTATED (dtA_44/2, 90, 0) RELATIVE Arm_44\n", "Arm_46 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[46], 0, 0) RELATIVE Arm_sample\n", "Analyzer_46 Monochromator_flat AT (0, 0, len[46]) RELATIVE Arm_46 \n", " ROTATED (dtA_46/2, 90, 0) RELATIVE Arm_46\n", "Arm_48 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[48], 0, 0) RELATIVE Arm_sample\n", "Analyzer_48 Monochromator_flat AT (0, 0, len[48]) RELATIVE Arm_48 \n", " ROTATED (dtA_48/2, 90, 0) RELATIVE Arm_48\n", "Arm_50 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[50], 0, 0) RELATIVE Arm_sample\n", "Analyzer_50 Monochromator_flat AT (0, 0, len[50]) RELATIVE Arm_50 \n", " ROTATED (dtA_50/2, 90, 0) RELATIVE Arm_50\n", "Arm_52 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[52], 0, 0) RELATIVE Arm_sample\n", "Analyzer_52 Monochromator_flat AT (0, 0, len[52]) RELATIVE Arm_52 \n", " ROTATED (dtA_52/2, 90, 0) RELATIVE Arm_52\n", "Arm_54 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[54], 0, 0) RELATIVE Arm_sample\n", "Analyzer_54 Monochromator_flat AT (0, 0, len[54]) RELATIVE Arm_54 \n", " ROTATED (dtA_54/2, 90, 0) RELATIVE Arm_54\n", "Arm_56 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[56], 0, 0) RELATIVE Arm_sample\n", "Analyzer_56 Monochromator_flat AT (0, 0, len[56]) RELATIVE Arm_56 \n", " ROTATED (dtA_56/2, 90, 0) RELATIVE Arm_56\n", "Arm_58 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (-dtS[58], 0, 0) RELATIVE Arm_sample\n", "Analyzer_58 Monochromator_flat AT (0, 0, len[58]) RELATIVE Arm_58 \n", " ROTATED (dtA_58/2, 90, 0) RELATIVE Arm_58\n", "arm_detector_0 Arm AT (0, 0, 0) RELATIVE Arm_sample \n", " ROTATED (0, tDy*0-tDy*0.5, 0) RELATIVE Arm_sample\n", "det_He3_0_ToF Monitor_nD AT (0, d_SDy, d_SDz) RELATIVE PREVIOUS \n", " ROTATED (0, tDy*0-tDy*0.5, 0) RELATIVE Arm_sample\n" ] } ], "source": [ "KVASIR.show_components()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Generate a classic McStas instr file\n", "KVASIR.write_full_instrument()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "INFO: Using directory: \"/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/KVASIR_0\"\n", "INFO: Regenerating c-file: KVASIR.c\n", "CFLAGS= @MCPLFLAGS@\n", " \n", "-----------------------------------------------------------\n", "\n", "Generating single GPU kernel or single CPU section layout: \n", "\n", "-----------------------------------------------------------\n", "\n", "Generating GPU/CPU -DFUNNEL layout:\n", "\n", "-----------------------------------------------------------\n", "INFO: Recompiling: ./KVASIR.out\n", "ld: warning: duplicate -rpath '/Users/peterwillendrup/micromamba/envs/mcstas-dev/lib' ignored\n", "ld: warning: duplicate -rpath '/Users/peterwillendrup/micromamba/envs/mcstas-dev/lib' ignored\n", "ld: warning: duplicate -rpath '/Users/peterwillendrup/micromamba/envs/mcstas-dev/lib' ignored\n", "INFO: ===\n", "Simulation 'KVASIR' (KVASIR.instr): running on 6 nodes (master is 'CIN-969631', MPI version 3.1).\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) produced with McStas 3.2 EGCESE.\n", "Message(source): MCPL file (/Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/Virtual_output_example.mcpl.gz) contains 211762 particles.\n", "\n", "\n", " Warning: You are using MCPL_input with a repeat_count of 1:\n", " - Minimum neutron count requested is 211762 x 1 <= 211762 x 6 MPI nodes = 1270572 neutrons total\n", "MCPL_input verbose mode - outputting data on the 10 first read neutrons in MCPL units:\n", "Incoherent: sample: Vc=13.827 [Angs] sigma_abs=5.08 [barn] sigma_inc=5.08 [barn]\n", "*** TRACE end *** \n", "Detector: det_He3_0_ToF_I=0.034336 det_He3_0_ToF_ERR=0.00402658 det_He3_0_ToF_N=125 \"Detector_0_ToF.dat\"\n", "INFO: Placing instr file copy KVASIR.instr in dataset /Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/KVASIR_0\n", "INFO: Placing generated c-code copy KVASIR.c in dataset /Users/peterwillendrup/Projects/McCode/mcstas-comps/examples/ESS/KVASIR/KVASIR_0\n", "\n" ] } ], "source": [ "KVASIR.set_parameters(t=50)\n", "KVASIR.settings(ncount=1e6, mpi=6)\n", "data = KVASIR.backengine()\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ms.make_sub_plot(data, log=1)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "#KVASIR.show_instrument(format=\"window\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "mcstas-dev", "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.13.11" } }, "nbformat": 4, "nbformat_minor": 2 }