detectors/slsDetectorPackage
24
1
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2026-01-19 06:52:20 +01:00
Code Issues Actions Packages Releases Activity

9.0.0.rc (#1058)

Browse Source 
* dev: update 2d gain plot color map (if no x and ymin/max changes or window resizing): setFixedWidth was updating for window resize, updated virtual servers for g2 and jungfrau to keep changing gain and data for every frame. the data value (#819)

* Dev/jf/fix pedestal (#821)

* jf pedestal fix: touch enable bit last

* dev: jf sync: stopping master gives idle (#824)

* jf sync mode master could return idle when stopped and so not all modules return the same value and must check for 'stopped or idle', Also must throw if any of the module gives an error

* added contains_only to sls::Result (#827)

* added variadic template for checking if a result contains only specified values

* fix for gcc4.8

* renamed to Result::contains_only

* updated condition in Detector.cpp

* stop on only the positions

---------

Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com>

* dev jf: change status reg bits  (#829)

* jf: rewrite of status reg bits, waiting state includes both wati for trigger and start frame, blocking trigger only waits if its not in waiting for trigger and run busy enabled, error state connected in firmware

* dev jf: reconfigure chip when touching electron collection mode bit (#831)

* jf: if bit 14 in reg 0x5d (electron mode collection bit) is changed, configure chip if v1.1 and powered on. so touch writeregister (setbit/clearbit also calls write register in the end). replace when electroncollectionmode command introduced

* eiger required fw version to 32: fix for blocking trigger in quad (#834)

* fix warning for prev_val (variable size array) in tests (#838)

* Dev: : gui acq finished callback for different status (#850)

* fix acquisition finished status to have different status for different modules, but does not have to be error. for eg. jf sync fw (2.4.1 gives idle for master and stopped for slaves when stopping acquiistion)

* handling inconsistent fnums to be -1 in gui, so when one sets 0 (change of value) will also give an exception (#854)

* Dev: fix py virtual test  (#846)

* draft to fix virtual test when it fails

* catching errors in tests and removing sigchild ignore so servers (process in background) executing commands will not fail (pclose no child processes, if sigchld is ignored) fixed

* uncommented python loading config

* somehow killal slsReciever in second detector test fails even though no receiver running

* fixing script for virtual simlator test:fixed issue with check if process running, fixed moench tests

* formatting

* tests for jf (#835)

* execute command inside server fixed (from fix simulator tests and exec command PR) (#857)

* dev: fix server logic in checking detector idle  (#861)

* fix buggy logic in checking detector idle and an argument check

* Dev: trigger signal issues handled at acquire (#864)

* if blocking and handling sync, only master gets blocking acq, slaves get non blocking as they are first and so dont get status or error caught when slaves dont get trigger (due to not connected etc) and acq returns with slaves still in waiting status. so check status of all in blocking acq

* for all dets with sync, ensure atleast one master when starting acq

* docs updated about sync

* minor fix for test_simulator

* updating docs

* fixed doc

* added python 3.12 to the conda build variants

* documentation and examples

* formatting

* forward declare zmq_msg_t and moved include (#869)

* forward declare zmq_msg_t and moved include

* removed zmq from pkg list

* removed zmq as dependency for slsdet (#870)

* dev: moench: min exptime (#865)

* moench: remove min clock cycles for setting exptime (had been ported from jf)

* commands code generation (#871)

* commands code generation  (#803)

* commands code generation for only frames command

* fix cmake file and add Caller files

* working exptime, fully extended commands file and its variants

* start adding template commands

* add INT_CMD_VEC_ID template

* add list command, generate multiple bins, format code

* reach 208 commands using the cpp macros

* add tests for command parser

* start adding tests for commands parser

* fix typo to use commands.yaml

* add more tests for command_parser

* add all template functions (up to 218 commands)

* finish template functions and add more CmdProxy.cpp functions (250+)

* 257 commands

* 300 commands the rest are very special commands

* add special commands without generation

* separate special functions from generated c++ file

* implementing one command for put and get (buggy)

* add infer action in a separate file

* generate header for special commands from yaml

* allow only 0 or 1 for bool inputs

* group all commands in gen_commands.py

* add help to gen_commands.py

* add autocomplete bash script

* autocompletion: add support for module levels and help

* remove debugging line

* add autocompletion, help to commands, change int [0,1] to bool

* copy tests for Caller.cpp. Tests pass

* update with the new developer branch changes

* fix errors after merging (there is problems with tests)

* fixed port/stopport in yaml (intput typo), added '_caller' to the test dac and test on chip dac command in global test for cmdcaller

* undo previous test simulator debug change

* add documentation for the generated code

* reducing the comment to be replaced in length so formatting does not split into 2 lines

* removed formatting specific style of C++11 in gen_commands.py to keep with the top level clang format of the project
* regeneratign code for commands

* automation generated

* Redirect deprecated commands (#872)

* working implementation, need to fix dac

* fixed deprecation redirect for dac command

* Detector specific autocomplete (#873)

* working implementation, need to fix dac

* fixed deprecation redirect for dac command

* detector specific completion for dac

* added autocomplete using detector specific

* fixed error when autocompleting partial words

* Generate commands/fix commands (#875)

* fix vm_a, im_a etc have deg Celsius suffix, also help missing or changed in some places

* dac: require det id for all, arg0 to be printed at output, help for onchip dac and dac, onchipdac: spacing

* getscan detid and blocking trigger help

* udp_Dstlist det_id fixed, but rx_id invalid

* cmdApp in line with cmdLineApp (missing version, receiver_id, not creating det object in help action

* added set_command to differentiate between check_det_id and require_det_id (mixed up), args: -1 needs to check for at least one argument

* reordering

* reordering and checked till integer_command_hex

* fixed a lot more commands

* fix caller tests for eiger

* changes to tests after Bechir left

* changing .cmd to .cmdcall for the caller commands

* fixed tests for caller, still warning for setexptime about cast input

* autocomplete ran

* add moench test

* regenerating autocomplete and commands

* fixing other things from merge conflicts (renaming slsDetectorDefs to defs in commands.yaml)

* formatting

* added code injection to help (#876)

* updated 3 commands to have get output that can be put into put (#877)

* updated some commands to have get output that can be put into put

* fix tests for clkdiv

* adding help to free (#878)

* removing old commands and renaming them, (also making it work for parameters command as it was still calling cmdproxy) (#879)

* More helpful error messages for unsupported actions (#880)

* removing old commands and renaming them, (also making it work for parameters command as it was still calling cmdproxy)

* Added specific help for unsupported actions

* fixed a vetofile get special exception message. more specific warning for special exception message instead of no function warning

* added condition checking true in exceptions for special message

---------
Co-authored-by: Bechir Brahem <bachbrahem@gmail.com>
Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>
Co-authored-by: Dhanya Thattil <dhanya.thattil@psi.ch>

* Generate commands/fix det command rename (#881)

* made a link to bash autocompletion script in main folder, and replaced all references to 'det' command with 'sls_detector'

* Generate commands/fix detp detg command rename (#882)

* replacing detp with sls_Detector_put and detg with sls_detector_get

* sls_detector_not implemented, but extended message to ask user to use sls_detector_get or sls_detector_put

* autocompletion also for sls_detector or det

* Xilinx ctb (#884)

* updated registers, arm64

* compiler set to aarch64 for xilinx server

* updated RegisterDefs.h

* merge into generate branch and resolving conflicts and adding the xilinx changes to callerspecial and commands.yaml

* compiles and can print firmware version (using a different csp0 address)

* fixing other servers (gotthard, jungfrau, moench, mythen3) that it returns in case of mapping failure, xilinxctb: added that it checks type, prints proper fw version, checks kernel date, added armprocessor define to use in common places, added specifiers to supress overflow and truncation warnings

* added detector ip and mac adddress to the printout

* fixed tests and recompiled servers

* Xilinx client tests (#887)

* implemented testbus, testfpga, set/get #frames, triggers, allowed that and for connection to client, also allowed, getnumchannels, configuremac, getrunstatus, setdetectorposition with dummy values

* allowing tests for xilinx

* binaries in

* Dev/xilinx defaults and pattern (#888)

* implemented testbus, testfpga, set/get #frames, triggers, allowed that and for connection to client, also allowed, getnumchannels, configuremac, getrunstatus, setdetectorposition with dummy values

* connected kernelversion, hardwareversion, versions, framesl, triggersl, dr, timingmode, pattern (except patioctrl) thats there for altera ctb

* replaced set/get64Bit to set/getU64bit in all loadpattern.c for (ctb and m3 also)

* minor

* updated commands generation

* formatting

* moench default speed set to after init readout configuration (half speed) (#886)

* Fixed path when building as submodule

* Moench v8 (#892)

* new rct structure for moench03

* new moench data structure for offline processing

* meonch raw data and zmq process files updated to 7.0.3 version

* implemented config file for Zmq file

* raw data and zmq work with config file, but only with one file/interface

* zmq config change

* added config examples for zmq and rawdata

* pmod for 7.0.3 and 8.0.0 from previous releases

* updated pmod 8.0.1 for rh7 and rh8

* m3 fix to get kernel version properly on nios without an incorrect error msg (#898)

* moench: changed max shifts of adc clk from 240 to 200 (#900)

* Protect from getenv("HOME") returning nullptr  (#907) (#908)

* Protect from getenv("HOME") returning nullptr (e.g., in case running in systemd)

* Write proper warning in Module.cpp

Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

* Dev/xilinx acq (#901)

* period and exptime(patternwaittime level 0)

* added new regsieterdefs and updated api version and fixedpattern reg

* autogenerate commands

* formatting

* minor

* wip resetflow, readout mode, transceiver mask, transceiver enable

* acquisition, but streaming done bit and busy (exposing + read chip to fifo) not known yet from fw

* programming fpga and device tree done

* most configuration done, need to connect configuretransceiver to client

* stuck at resetting transciever timed out

* minor

* fixed virtual, added chip busyto fifo, streaming busy, set/getnext framenumber

* configuretransceiver from client, added help in client

* make formatt and command generation

* tests for xilinx ctb works

* command generation

* dacs added and tested, power not done

* power added

* added temp_fpga

* binaries in

* ctrlreg is 0 to enable chip=fixed, high dac val = min val= fixed, power regulators in weird order=fixed, device tree could be loaded with dacs before adcs=fixed

* start works

* virtual server sends

* receiver works

* tests

* python function and enum generation, commands generatorn and autocomplete, formatting, tests

* tests fail at start(transceiver not aligned)

* tests passed

* all binaries compiled

* eiger binary in

* added --nomodule cehck for xilinx

* updated binaries

* formatting

* moench server: changed default values of adcphase for full speed from 300 to 150 and dac vipre_cds from 800 to 1280 (#922)

* client bug fix: m3 multi module bad channel file throws bad allocation when modules skipped, needed to add vectors in 2d vector of bad channel list (#920)

Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com>

* developer: blocking acquire stop with slave temporarily in waiting (#926)

* client: stopping a blocking acquire of multi modules checks status to catch slaves that might still be in waiting. Problem is (gotthard2 25um at least) slave is in waiting only temporarily before going go idle/stopped. So a 50ms sleep is necessary ot not throw an unnecessary error

* client: when stopping blocking acquire, wait up to 1s in 50ms increments for slave to stop waiting temporarily

* fix to rapidjson for build with gcc 14 (#929)

* Dev: m3 clkdiv0 20 (#924)

* m3: clk 0 changed from 10 to 20 (100MHz to 50MHz)

* g2: startup clk div back to 10 as in firmware but setting in software startup to 20

* m3: minor print error if clk divider > max

* G2: reconfigure chip (#927)

* changed common.c readADCFromFile to make it more general and move temperature calculation for Eiger out of this function and inside whereever it is called.
* g2 and m2: gethighvoltage was just a variable set in server, it is now moved to a get inside DAC5671 implementation (but not reading a measured value, instead what is set from a file), high voltage variable used inside DAC5671 for virtual servers
* g2: switching off hv (ifrom non zero to zero value) will wait for 10s; powering on chip reconfigures chip; powering off chip unconfigures chip; powering off chip also includes check if hv = 0, if not throw exception; chip configuration checked before acquring; at start up: hv switched off and chip powered on, so does not wait 10s to switch off hv;
* included test to check powering off chip when hv is on should throw an exception
* g2:  check if chip configured before acquiring

* nios: read hv value set from file and virtual still goes into DAC5671 for conversions to and fro dac to V, change common readadc to readparameter to generalize, make sethighvoltage into a get and set to catch errors in get as well, g2: if not at startup, remmeber hv value before setting it and after check if value was being switched off (from a non zero value) and wait 10s if it was (10s wait only for switching off from non zero and not at startup)

* developer: moench empty data callback  (#936)

* moench (feature to wait for post processing to be done in new sls_detector_acquire_zmq executable)

READOUT_ACTION_ZMQ added to action enums
sls_detector_acquire_zmq added to executables
empty data call back so that client listens to last dummy zmq packet from moench post processor
processor: remove NEWZMQ ifdefs and remove connect for zmq publisher socket

* fix to compile

* cmds generated and parsed

* dev: client: status for blocking acquire stop with slave temporarily in waiting (#944)

* acq finish call back gets status squashed with default error but before that need to wait for gotthard slaves to catch up from waiting to stopped

* bug fixes related to file saving (#931) (#946)

* fix the file path resetting issue of GUI in the case where different modules have different fpath setting.

* fix stack-buffer-overflow issue when using HDF5 HDF5DataFile::parameterDataTypes have 64bit type (i.e. STD_U64LE), the size of fill_value should be at least 8 bytes.

* change the type of fill_value to uint64_t

Co-authored-by: Z.H. Li <zhenghenge@gmail.com>

* updated documentation from martin (#948)

* Dev/xilinx ctb test (#942)

* voltage regulators only looks at dac and not at ctrl_reg

* xilinx: change dac max to 2048, setting dac ist not inverse conversion from dac to voltage anymore, but setting power is inverse, also there is max and min to power, a different min for vio and this is checked at funcs interface, not printign or converting to mv in dac for power regulators (as its conversion max and min are different)

* Use links for dacs/adc and adapt power rglt thresholds

* Remove wait for transceiver reset

* adc and dac device not used anymore and hence removed

* udp restucturing: arm has to be multiple of 16 and no byteswap in udp_gen, option to compile locally in arm architecture, memsize of the second udp memory has to be limited

---------

Co-authored-by: Martin Brückner <martin.brueckner@psi.ch>

* formatting

* dev: jungfrau HW 1.0: adc output clock phase to 120 (#952)

* jungfrau: change adc output clock phase from 180 to 120 for v1.0 boards for reliable readout of adc #2

* versioning

* formatting

* rx: moved creating fpath (if it doesnt exist) from setting file path to at the start of acquisition when creating file. This is done here so that it does not fail if fwrite is disabled anyway. Also fixed it in documentation. Changed in documentation that the default for fwrite is disabled (#957)

* added keepalive zmq socket option (after 60s of idle time, 10 probes every sec. Mainly because an issue at Max IV (#956)

* Moench mess from developer (#953)

* new moench data structure for offline processing

* Dev/zmq stream all ipv6 adn remove rx_zmqip (#958)

* enable ipv6 in zmq socket

* removed rx_zmqip API and field in gui, changed client updaterxrzip to updateclientzmqip to have the rx_hostname ip if 0. 

* updated command line for rx_zmqip to give a warning. 

* Replaced 'depreciated' to 'deprecated' everywhere

* switching from * to 0.0.0.0 works for rebinding zmq sockets

* fixed help in command line for rx_zmqip * to 0.0.0.0 and removed cmd in python

* remove publisher zmq socket ip also for moench post processing

* fixed tests

* publisher zmq ip macros to be reused

* fixed a warning about narrowing conversion from size_t to int (#963)

* fixed stop server not starting up with setup variables (#949)

* m3: fixed stop server not starting up with setup variables

* all servers except eiger fixed for virtual stop server to start up with setupDetector function called

* virtual tests work

* eiger: versions print neednt be in stop server

* jungfrau: stop server (not virtual) also needs to read config file

* ensuring master is setup for virtual and real servers

* Dev/pyctbgui merge (#960)

* added empty c extension

* added rotation to the decoding

* added color map, options and findex

* minor

* move checks to before acquisition

* added pixel map based decoder

* cleanup

* no thread creation for single thread processing

* added rotation and test to compare

* allow high and low water mark for zmq (also buffer size) for fast readouts

* removed roatation during decoding

* added Transpose to image and invert Y False to invert it

* retains the zoomed state after the first image of gui, catch and display exception if no detector connected

* moved start frame to dockable widget, removed extra frame number label, moved current measurement also to dockable widget, hide frame plot entirely when showing patternviewer

* first image dependin on which plot

* remember settings of main window size and position, dockewidget if docked, its size and posisiotn as well, then update it next time the gui is opened

* change in comment

* using c decoder for moench 04 and matterhorn

* catch exception from invalid image from decoder

* clean up

* update row and col when choosing image type, neeeded to show values

* fix for previous PR

* disable resetting colormap values
keep the range selected for every new acquisition

* fix typos + tested on virtual matterhorn

* minor print

* refactored Slow ADCs Tab

* refactored DAC tab

* refactored power supplies

* refactored signals tab

* refactored transceiver tab

* fix typo

* fix typo2

* remove commented code

* delete commented code

* delete commented code

* delete commented signals code

* remove commented code for transceiver tab

* refactor adc tab

* refactor Pattern Tab

* Refactor transceivers tab (PR#5) (#118)

* refactored transceiver tab

* remove commented code for transceiver tab

---------

Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>

* refactor adc tab (PR#6) (#119)


* refactor adc tab

* refactored Plot and Acquisition Tabs

* fix the regression issue

* restructure project files

* applying singleton and renaming tabs to services

* working install using pip

* applies singleton to tab classes and remove CI erros

* added pyzmq and pillow

* remove the singleton implementation and keep changes

* fix merge errors in mainWindow

* moved misplaced init file

* rename service to tab

* reorganize imports

* iterate over tabs

* reorder tabs

* add slowadc to the list

* saving changes (buggy)
power supply ui not showing in the gui

* split power supply tab

* fixed tests

* add hardcoded values to defines file

* fix error

* separate power supply

* fix errors for powerSuppliesTab

* split dacs

* split slow adcs

* split signals tab

* added tests for bit_utils

* add slowAdc class to defines

* split transceiver ui file

* split adc.ui

* split pattern ui file

* split plot and acquisition ui file

* added basic test for parsing bit names

* removed redundant code in read_alias_file

* fix dacs ui position

* testing for correct exception

* cmd and args at split

* group radio buttons

* fix comments from PR#1

* show legend

* added python version and dev requirements to setup.py

* fix dac issue

* moved _decoder into pkg

* added inplace build

* removed clear

* fixed dependencies

* make tests run without slsdet

* updated name of action

* define colcount

* fixed loading of alias file

* add yapf and ruff

* apply formatting

* fix E and F rules

* add more ruff rules

* change variable name

* squashing gh debugging commits and add pre-commit

* update label values to mv units

* add hook for yapf

* reconfigure yapf precommit hook

* add format and check_format to makefile

* change gh actions

* update readme

* added check_format

* WIP

* added linting in github action

* updated readme]

* add more control for color choice

* remove useless file

* fix un-updated line after refactoring Defines
BIT0_31_MASK is not found in Defines.signals

* visually improve the interface

* fix last commit

* add only selected plots for legend

* add hide legend button

* change hide legend to show legend
checkbox show legend is checked by default

* add support for saving in numpy

* solve conversations

* fix acq index offset

* fix browse button in pattern error

* fix other browse button errors

* finish tests and add usage.md

* remove buffer

* add file,numpy-like interface and tests

* remove useless .npy files

* subscriptible npz files

* remove useless files

* remove repetetive tests

* save changes

* add mode r+, add with support,remove logging

* remove offset of acqIndex between raw and numpy saving

* fix only saving last frame

* save signals of multiple devices

* add comments and move condition for clearer code

* fix bug when vieweing pattern file

* iterate over enabled and plotted plots

* add padestal substraction to transceiver and analog data

* init pedestal frames to detector.frames

* restore old exception

* add pedestal substraction for digital signals

* remove frames spinbox from plotTab

* remove comments and use str instead of Path

* avoid saving all frames

* correct exception and log error's trace

* add gui tests

* add waveform test

* add pedestal test

* refactor by using fixtures

* add tests for moench analog and pattern

* add pytest-qt to dependencies

* add save and load gui parameters

* remove nohup file

* fix old bug IndexError

* save plot type

* a

* handle canceling load, loading matterhorn pedestal for moench

* remove comparing .png files for pattern test

* save plot type

* red error on status bar when shape mismatch for loaded pedestal

* fix makefile and docstrings

* fix PRs conversation

* move code into different function

* fix wrong function names for power supply

* removed old ctbgui

* removed unnecessary files

---------

Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>
Co-authored-by: Braham Bechir <braham_b@pc11979.psi.ch>
Co-authored-by: Bechir <bechir.braham@psi.ch>
Co-authored-by: Bechir <bechir.brahem420@gmail.com>

* Dev/xilinx mat update (#959)

* put back code to obtain adc and dac device indexafter loading device tree and then create folder iio_device_links and create symbolic links there according to device indices found. ln -sf operation not permitted, so folder has to be deleted and created everytime. Also refactored definitions to have all the xilinx name or detector specific stuff out of programbyArm.c

* uncommented waittransceiverreset at startup (should work now) and return of powering off chip at startup (error for transceiver alignment reset)

* updated registerdefs from firmware

* minor prints and updating names from registerdefs

* waittransceiverreset has been fixed in firmware and removing warnign for that, transceiver alignment check for powering off chip is not done in fw (giving a warning and returning ok for now)

* fixing ipchecksum (not done), removed startperiphery, allowing readout command to be allowed for xilinx when acquiring

* dont build doc for Tobi Schluter from libzmq, which uses iso-8859-1 and the umlaut cause compilation to fail on some machines (#973)

* 8.0.2 psi modules

* missed the rx_zmqip implementations in detector.h and python bindings (#975)

* rx_zmqip has been removed. Remove it also for pyctbgui (#979)

* format

* Dev/rx callbacks (#966)

* changed rxr callback signatures to all include structs
* removed datamodify call back as size can be changed in the original data call back now
* bringing some parameters (set functions) to dataProcessor class for its callback (namely udpport, quad, fliprows, totalframes, jsonheader), resulting in also removing totalframes from 2 other function signatures

* updated MultiReceiverApp to reflect the new callback signatures

* Dev/reg bit change no validate (#970)

- do not validate write reg, setbit and clearbit by default anymore
- --validate will force validation on the bitmask or entire reg
- remove return value for write reg (across server to client, but thankfully not in the Detector class)
- extend validation into writereg, setbit and clearbit for Eiger (always special)
-  need to check python (TODO)
- missed the rx_zmqip implementations in detector.h and python bindings

* sleep implemented for command line, mainly for config files for firmware developers (#982)

* change gain mode help from dynamicgain to dynamic (#988)

* fixing python version. allowing versions to execute even if no detector connected or in shared memory (#990)

* Jf: Electron collection mode (#983)

* electron collection mode for jungfrau. also removing the config chip when using register command
* collectionMode: HOLE/ELECTRON (enum)

* Dev/m3 readout speed (#985)

* added readoutspeed command to m3 (fullspeed - 10, half speed - 20, quarter speed - 40), removed reaodut pll, moved up system pll clock indices, leaving pll index in common altera code, default speed is half speed, allow only system_c0 to be set, the others can be obtained, same for clkphase, maxclkphaseshift, clkfreq. added to readoutspeedlist commands, updated help and updated tests

* updated readoutspeedlist command

* jf: timing info decoder (#987)

* timing_info_decoder command with options swissfel (default) and shine. added to python, command line generation, autocomplete, tostring, tests.

* updated jungfrau timing info decoder mask (#991)

* minor. removed warning print at startup for empty eth udp to listen to (#992)

* removed 'Caller/CALLER' from test names as there is only one command line now (#993)

* formatting

* Dev/g2 stop frame number (#980)

* get/set next frame number in G2 (firmware only has set, no get)
* firmware has issues: each stop keeps 2 frame header in fifo and the resetting frame number happens after that
* removed the option to set burstmode to burst external or continuwous internal
* needs to be revisited before 9.0.0

* formatting

* fix the command help in the command help generator for Gotthard2 about nextframenumber (#994)

* first draft at fixing nextframenumber properly with firmware (#995)

* fixing nextframenumber properly with firmware

* updated firmware to have getnextframenumber and fixed setnextframenumber to reset also the header fifo when stopping

* fix tests for gotthard2

* Dev/g2 fix next frame number (#996)

* binaries in

* formatting

* release notes

* release notes

* updating firmware dates

* release notes

* package release version and renaming server names

* updated client versioning

* updated moench fw release version

* 900/proper free (#1002)

* first draft of fixing the free function available within the class

* removed class member function freeSharedmemory for both Detector and Module; made the free function freeSharedmemory accessible to python interface; setHostname if there is already a module in shm will recreate the Detector object while freeing shm completely and keeping detsize and intitialchecks (previous commit), sethostname called from DetectorClass in virtual command to have one point of entry (previous commit), testing Module class frees shared memory using free function

* Detector class: added copy and move constructor and assignmentoperators due to explicit destructor (DetectorImpl fwd declared), DetectorImpl class: included ZmqSocket to remove destructor (should not be virtual in any case), Module class: removed explciit destructor to allow compiler generated constructor and operators

* formatting

* updated client version date

* minor fix for readme autocomplete

* setting detsize after hostname should throw also for single module for consistency (#999)

* 900/autocomplete documentation (#1003)

* fixed the gendoc to reflect the new parser, updated documentation to include info about autocomplete in the command line part, error in createing docs

* fixed list deprecated, fixed command help (to show properly on a html, fixed other help warnings

* minor indents

* 900/g2 chip configure at startup (#1008)

* g2: chip reconfigure variable not set when powering on at startup because readconfig is the one configuring the chip the first time to default chip settings

* cleaning up code

* 900/rm volatile (#1006)

* Removing volatile and replacing with atomic to ensure atomicity

* compiling header include issue

* 900/jf firmware rollback (#1010)

* jf: rolling back firmware required to v1.5 and 2.5, updated release notes, fixed a bug when updating server (when server name same as link name:throws with no message, pedestal mode check changed for the time being for loops to be 0xFF size

* compensating for jf fw bug for pedestalmode where loops should be 16 bit, but is 8 bit in fw. to be fixed in next version

* formatting

* fixed python test simulator to kill previous servers

* gui: hide 'complete image' and just show 'missing packets' when there are missing packets in that image form the receiver (#1013)

* release notes update (#1015)

* 900/detach pthreads not joining (#1017)

* detach the pthreads that are not joining else memory leak

* release notes

* removed the clean up comment, also refactored the pthread join/detach for ctb 1g

* 900/server malloc check (#1020)

* usleep in communication to actually relay the err message of memory allocation to the client (weird but test for now), function in server to handle memory allcoation issues (updates mess, ret and sendsit to the client and returns prior from function implementatin, setting fnum in client for the speicific functions that send to detector each argument separtely, they need to remember the fnum else they throw with the incorrect fnum

* server: every malloc must check if it succeeded, rearranging so that the free is clear as well (only in funcs so far)

* formatting

* fixed malloc checks in other places other than funcs.c

* bug fix return from previous commit

* pointer bug from previous commit

* formatting

* binaries in

* 900/document json ctb file format (#1027)

* docs receiver formats rewrite

* added documentation for all the receiver files, updated release notes, udpated help in commands help for timing, fixed by throwing exception for aa dividy by 0 error caused by not freeing memory (detsize) when switching between 1d and 2d detectors, removed unnecessary 'recevier up' printout, fixed dbit list 64 bit mask error in master json file (was not 64 bit before), fixed bug in reading gotthard1 data (needs to be tested)

* generating commands help and formatting, also fix help for trimen command line

* added ctb frame format documentation, added some links to some commands, added documentation about adding expat-devel in installation for rhel8 gui, fixed some indentation issues that screwed up command line help documentation

* added ctb frame format documentation

* updated documentation about zeromq-devel for <8.0.0 versions

* fixed typo in python for vb_pixbuf Jungfrau dac (#1030)

* fixed cli documentation (#1037)

* 900: legal gain values in jungfrau simulator (#1043)

* legal gain values in jungfrau simulator

* typo

* release notes

* 900/jungfrau temp control default enable (#1041)

* jungfrau: enabling temp control by default at server startup

* 900: fixed invalid arguments to slsmultireceiver (#1039)

* wasnt showing error message for invalid arguments to slsmultireceiver
* allow 0 arguments to act like an slsReceiver with start tcp port 1954 and just 1 receiver

* 9.0.0: version from file to cmake and python (#1024)

- renamed conda-recipe folder
- added a check to see if build and install folder exists in build.sh (conda recipe)
- created VERSION file that has '0.0.0'for developer but can be updated using update_version.py that takes in a version. The script checks for semantic versioning and updates VERSION file
- VERSION file also copied along with py files to slsdet in python cmakelist and build_pylib.sh (for conda), also copied in root folder for installations (for no coding purpose)
- init.py and setup.py reads this file to get the version (a bit differently to find the VERSION file)
- VERSION file read into cmake to get the version and also added to compile definition. So RELEASE removed from versionAPI.h (using SLS_DET_VERSION compile definiton instead) and also removed updateRelease script.
- conda getting project version from environment variable SLS_DET_VERSION that is set in build_pylib.sh prior.
- added 3.13 python to conda build
- anything related to ctb removed from release notes as users will always use developer
- sets 9.0.0 to VERSION file  by running update_version.py without an argument

* formatting

* finalized binaries

* updated m3 fw version (#1046)

* release notes

* fix cmake (cannot find VERSION file) when using package as subfolder as cmake_source_dir is not same anymore, add troubleshooting doc for m3 regarding loose control board for waiting status in auto timing mode, fix m3 tests to test register write (previously was read only) (#1047)

* 900: bumped pybind11 version and added setuptools on host (#1050)

* bumped pybind11 version and added setuptools on host

* updated pybind11 tarball to 2.13 and in cmakefile to get 2.13 frpm github, also updated documentation about pybind 2.13

* update release notes, doc

* updating readme

---------

Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com>

* 900 cmake_source_dir (#1053)

* when package used as subdirectory (cmake-subfolder-example) it fails when python is used because the cmake_source_dir is now the one above package.

* changed cmake_current_list_dir to cmake_current_source_dir

* removing the unnecessary VERSION file installed in the root directory (from PR #1020)

* 900: pybind 2.13.6 and python 3.8 (#1054)

* changed pybind 2.13.0 to 2.13.6, kept conda at min 2.13.0

* changed min python version from 3.6 to 3.8

* 900/docs (#1056)

* minimum python is 3.8, so >=

* removed ctb frame documentation. should be in internal wiki

* updated release notes

* updated releate date

---------

Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com>
Co-authored-by: froejdh_e <erik.frojdh@psi.ch>
Co-authored-by: anberga <34126852+anberga@users.noreply.github.com>
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
Co-authored-by: Z.H. Li <zhenghenge@gmail.com>
Co-authored-by: Martin Brückner <martin.brueckner@psi.ch>
Co-authored-by: Braham Bechir <braham_b@pc11979.psi.ch>
Co-authored-by: Bechir <bechir.braham@psi.ch>
Co-authored-by: Bechir <bechir.brahem420@gmail.com>
This commit is contained in:
maliakal_d
2024-11-26 11:13:45 +01:00
committed by GitHub
parent 4880f87791
commit 0aeb7e4417
327 changed files with 227791 additions and 19129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
slsDetectorSoftware/CMakeLists.txt
View File

@@ -4,10 +4,13 @@ set(SOURCES
src/DetectorImpl.cpp
src/Module.cpp
src/Detector.cpp
src/CmdProxy.cpp
src/HelpDacs.cpp
src/CmdParser.cpp
src/Pattern.cpp
src/CtbConfig.cpp
src/Caller.cpp
src/CallerSpecial.cpp
src/inferAction.cpp
)
add_library(slsDetectorObject OBJECT
@@ -76,27 +79,31 @@ endif()
if(SLS_USE_TEXTCLIENT)
# Loop over list to generate command line binaries
set(bin_names "sls_detector_put"
set(det_bin_names "sls_detector_put"
"sls_detector_get"
"sls_detector_acquire"
"sls_detector_acquire_zmq"
"sls_detector_help")
set(cmd_name "PUT" "GET" "READOUT" "READOUTZMQ" "HELP")
list(LENGTH bin_names len1)
"sls_detector_acquire"
"sls_detector_acquire_zmq"
"sls_detector_help"
"sls_detector"
)
set(det_cmd_name "PUT" "GET" "READOUT" "READOUTZMQ" "HELP" "INFER")
list(LENGTH det_bin_names len1)
math(EXPR len2 "${len1} - 1")
foreach(val RANGE ${len2})
list(GET bin_names ${val} val1)
list(GET cmd_name ${val} val2)
list(GET det_bin_names ${val} val1)
list(GET det_cmd_name ${val} val2)
message(STATUS "${val1} ${val2}")
add_executable(${val1} src/CmdLineApp.cpp)
add_executable(${val1} src/CmdApp.cpp)
target_link_libraries(${val1}
slsDetectorStatic
pthread
rt
slsDetectorStatic
pthread
rt
)
SET_SOURCE_FILES_PROPERTIES( src/Caller.cpp PROPERTIES COMPILE_FLAGS "-Wno-unused-variable -Wno-unused-but-set-variable")
set_target_properties(${val1} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
COMPILE_DEFINITIONS ${val2}=1
@@ -105,7 +112,8 @@ if(SLS_USE_TEXTCLIENT)
set_property(TARGET ${val1} PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
endif()
endforeach()
install(TARGETS ${bin_names} DESTINATION bin)
install(TARGETS ${det_bin_names} DESTINATION bin)
endif(SLS_USE_TEXTCLIENT)

10
slsDetectorSoftware/generator/Caller.in.cpp Normal file
View File

@@ -0,0 +1,10 @@
#include "Caller.h"
#include "sls/logger.h"
#include "sls/string_utils.h"
#include <iostream>
namespace sls {
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE
}

92
slsDetectorSoftware/generator/Caller.in.h Normal file
View File

@@ -0,0 +1,92 @@
// This file is used as input to generate the caller class
#include "CmdParser.h"
#include "HelpDacs.h"
#include "sls/Detector.h"
#include <iostream>
#include <string>
#include <vector>
namespace sls {
class Caller {
public:
Caller(Detector *ptr) : det(ptr) {}
void call(const std::string &command,
const std::vector<std::string> &arguments, int detector_id,
int action, std::ostream &os = std::cout, int receiver_id = -1);
IpAddr getDstIpFromAuto();
IpAddr getSrcIpFromAuto();
UdpDestination getUdpEntry();
void GetLevelAndUpdateArgIndex(int action,
std::string levelSeparatedCommand,
int &level, int &iArg, size_t nGetArgs,
size_t nPutArgs);
void WrongNumberOfParameters(size_t expected);
template <typename V> std::string OutStringHex(const V &value) {
if (value.equal())
return ToStringHex(value.front());
return ToStringHex(value);
}
template <typename V> std::string OutStringHex(const V &value, int width) {
if (value.equal())
return ToStringHex(value.front(), width);
return ToStringHex(value, width);
}
template <typename V> std::string OutString(const Result<V> &value) {
if (value.equal())
return ToString(value.front());
return ToString(value);
}
template <typename V> std::string OutString(const V &value) {
return ToString(value);
}
template <typename V>
std::string OutString(const V &value, const std::string &unit) {
if (value.equal())
return ToString(value.front(), unit);
return ToString(value, unit);
}
std::vector<std::string> getAllCommands();
std::map<std::string, std::string> GetDeprecatedCommands();
std::string list(int action);
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1)
std::vector<std::string> args;
std::string cmd;
Detector *det;
int det_id{-1};
int rx_id{-1};
private:
bool ReplaceIfDeprecated(std::string &command);
using FunctionMap = std::map<std::string, std::string (Caller::*)(int)>;
using StringMap = std::map<std::string, std::string>;
Detector *ptr; // pointer to the detector that executes the command
static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
uint32_t subFrameIndex, void *this_pointer);
FunctionMap functions{
{"list", &Caller::list},
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (2)
};
StringMap deprecated_functions{
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (3)
};
};
} // namespace sls

236
slsDetectorSoftware/generator/autocomplete/autocomplete.py Normal file
View File

@@ -0,0 +1,236 @@
import argparse
import json
from pathlib import Path
# command to generate the ast
# clang version: 14.0.0-1ubuntu1.1
# clang++ -Xclang -ast-dump=json -Xclang -ast-dump-filter -Xclang StringTo -c ToString.cpp -I ../include/ -std=gnu++11
#
import yaml
AUTOCOMPLETE_PATH = Path(__file__).parent
DUMP_PATH = AUTOCOMPLETE_PATH / 'dump.json'
FIXED_PATH = AUTOCOMPLETE_PATH / 'fixed.json'
type_values = {
'special::mv': ["mv", "mV"],
"special::deg": ["deg"],
"special::time_unit": ["s", "ms", "us", "ns"],
"special::hard": ["hard"],
"special::force-delete-normal-file": ["--force-delete-normal-file"],
"special::currentSourceFix": ["fix", "nofix"],
"special::currentSourceLow": ["normal", "low"],
"special::path": [],
"special::pedestal_parameters" : ["", "0"],
"special::validate": ["--validate"]
}
def get_types(arg_types):
ret = set()
for arg_type in arg_types:
if type_info(arg_type) == 'base':
if arg_type == 'bool':
ret = ret.union(["0", "1"])
else:
tmp = [not_list for not_list in type_values[arg_type] if not isinstance(not_list, list)]
ret = ret.union(tmp)
#Intercept the options and in case detector specific options appear replace the
#list of options with a command line call that fetches them
#TODO! Rename sls_detector_get
if "defs::dacIndex" in arg_types:
return "`sls_detector_get daclist | sed -e 's/.*\[\(.*\)\].*/\\1/' | sed 's/,//g'`"
elif "defs::detectorSettings" in arg_types:
return "`sls_detector_get settingslist | sed -e 's/.*\[\(.*\)\].*/\\1/' | sed 's/,//g'`"
elif "defs::timingMode" in arg_types:
return "`sls_detector_get timinglist | sed -e 's/.*\[\(.*\)\].*/\\1/' | sed 's/,//g'`"
return ret
def type_info(type_name):
if type_name.startswith('defs::') or type_name.startswith('slsDetectorDefs::'):
return 'enum'
if type_name.startswith('special::'):
return 'special'
return 'base'
def get_enum(function):
return function['type']['qualType'].split(' ')[0]
def get_literal(ifstmt):
stringliteral = []
expression = ifstmt['inner'][0]
if expression['kind'] == 'BinaryOperator':
if expression['opcode'] == '!=':
return None, None
for cxxOperatorCall in expression['inner']:
if cxxOperatorCall['kind'] == 'CXXOperatorCallExpr':
implicitCastExpr = cxxOperatorCall['inner'][2]
stringliteral.append(implicitCastExpr['inner'][0]['value'][1:-1])
else:
cxxOperatorCall = expression
implicitCastExpr = cxxOperatorCall['inner'][2]
stringliteral = implicitCastExpr['inner'][0]['value'][1:-1]
retstmt = get_object_by_kind(ifstmt['inner'], 'ReturnStmt')
declrefexpt = get_object_by_kind(retstmt['inner'], 'DeclRefExpr')
enum_val = declrefexpt["referencedDecl"]["name"]
return enum_val, stringliteral
def get_object_by_kind(inner, kind, position=1):
for obj in inner:
if obj['kind'] == kind:
position -= 1
if position == 0:
return obj
return None
def generate_type_values():
functions = json.loads(FIXED_PATH.read_text())
for function in functions:
if function['kind'] != 'FunctionDecl' or function['name'] != 'StringTo':
continue
enum = get_enum(function)
if not enum.startswith('defs::'):
continue
# if enum != 'defs::dacIndex':
# continue
if not function['loc']['file'].endswith('ToString.cpp'):
continue
compound_stmt = get_object_by_kind(function['inner'], 'CompoundStmt')
for ifstmt in compound_stmt['inner']:
if ifstmt['kind'] != 'IfStmt':
continue
enum_val, stringliteral = get_literal(ifstmt)
if enum_val is None:
continue
if enum not in type_values or type_values[enum] is None:
type_values[enum] = []
type_values[enum].append(stringliteral)
items = list(type_values.items())
for key, val in items:
if key.startswith('defs::'):
new_key = key.split('::')[1]
new_key = 'slsDetectorDefs::' + new_key
type_values[new_key] = val
elif key.startswith('slsDetectorDefs::'):
new_key = key.split('::')[1]
new_key = 'defs::' + new_key
type_values[new_key] = val
return json.dumps(type_values, indent=2)
def fix_json():
with DUMP_PATH.open('r') as f:
tmp = '[\n'
for line in f.read().split('\n'):
if line.startswith('}'):
tmp += line + ',\n'
else:
tmp += line + '\n'
tmp = tmp[:-3] + '\n]'
with FIXED_PATH.open('w') as f:
f.write(tmp)
def generate_bash_autocomplete(output_path=Path(__file__).parent / 'bash_autocomplete.sh', input_path=Path(__file__).parent / 'bash_autocomplete.in.sh'):
generate_type_values()
output_file = output_path.open('w')
template_file = input_path.open('r')
def writeline(line):
output_file.write(line + '\n')
class if_block:
def __init__(self, condition):
self.condition = condition
def __enter__(self):
output_file.write('if [[ ' + self.condition + ' ]]; then\n')
def __exit__(self, type, value, traceback):
output_file.write('fi\n')
class function:
def __init__(self, name):
self.name = name
def __enter__(self):
output_file.write(self.name + '() {\n')
def __exit__(self, type, value, traceback):
output_file.write('}\n')
command_path = Path(__file__).parent.parent / 'extended_commands.yaml'
commands = yaml.unsafe_load(command_path.open('r'))
for line in template_file:
if '-- THIS LINE WILL BE REPLACED WITH GENERATED CODE --' not in line:
output_file.write(line)
continue
writeline(f'local SLS_COMMANDS=" {" ".join(commands.keys())} "')
# generate functions
for command_name, command in commands.items():
# added for debugging
if command_name == 'xxxexptime':
continue
with function('__' + command_name):
writeline('FCN_RETURN=""')
actions = ['GET', 'PUT']
for action in actions:
if action in command['actions'] and 'args' in command['actions'][action]:
args = command['actions'][action]['args']
possible_argc = {}
for arg in args:
if arg['argc'] == 0:
pass
for i in range(arg['argc']):
if i + 1 not in possible_argc:
possible_argc[i + 1] = []
possible_argc[i + 1].append(arg['arg_types'][i])
if possible_argc:
with if_block(f'${{IS_GET}} -eq {"1" if action == "GET" else "0"}'):
for argc in possible_argc:
with if_block(f'"${{cword}}" == "{argc + 1}"'):
if "defs::detectorSettings" in possible_argc[argc]:
print(argc, command_name, possible_argc[argc])
choices = get_types(possible_argc[argc])
#check if we got choices back or a bash command
if isinstance(choices, (list,set)):
writeline(f'FCN_RETURN="{" ".join(sorted(choices))}"')
else:
writeline(f'FCN_RETURN="{choices}"')
if 'special::path' in possible_argc[argc]:
writeline('IS_PATH=1')
writeline('return 0')
output_file.close()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='use parsed c++ code to generate autocomplete snippets')
parser.add_argument('-f', '--fix', action='store_true', help='fix the parsed ast to make it loadable')
# parser.add_argument('-p', '--path', type=str, help='output path to the fixed ast', default='ast.json')
args = parser.parse_known_args()
if args[0].fix:
fix_json()
ret = generate_type_values()
print(ret)

167
slsDetectorSoftware/generator/autocomplete/bash_autocomplete.in.sh Normal file
View File

@@ -0,0 +1,167 @@
# GENERATED FILE - DO NOT EDIT
# ANY CHANGES TO THIS FILE WILL BE OVERWRITTEN
_sd() {
# Taken from https://github.com/scop/bash-completion/blob/15b74b1050333f425877a7cbd99af2998b95c476/bash_completion#L770C12-L770C12
# Reassemble command line words, excluding specified characters from the
# list of word completion separators (COMP_WORDBREAKS).
# @param $1 chars Characters out of $COMP_WORDBREAKS which should
# NOT be considered word breaks. This is useful for things like scp where
# we want to return host:path and not only path, so we would pass the
# colon (:) as $1 here.
# @param $2 words Name of variable to return words to
# @param $3 cword Name of variable to return cword to
#
_comp__reassemble_words()
{
local exclude="" i j line ref
# Exclude word separator characters?
if [[ $1 ]]; then
# Yes, exclude word separator characters;
# Exclude only those characters, which were really included
exclude="[${1//[^$COMP_WORDBREAKS]/}]"
fi
# Default to cword unchanged
printf -v "$3" %s "$COMP_CWORD"
# Are characters excluded which were former included?
if [[ $exclude ]]; then
# Yes, list of word completion separators has shrunk;
line=$COMP_LINE
# Re-assemble words to complete
for ((i = 0, j = 0; i < ${#COMP_WORDS[@]}; i++, j++)); do
# Is current word not word 0 (the command itself) and is word not
# empty and is word made up of just word separator characters to
# be excluded and is current word not preceded by whitespace in
# original line?
while [[ $i -gt 0 && ${COMP_WORDS[i]} == +($exclude) ]]; do
# Is word separator not preceded by whitespace in original line
# and are we not going to append to word 0 (the command
# itself), then append to current word.
[[ $line != [[:blank:]]* ]] && ((j >= 2)) && ((j--))
# Append word separator to current or new word
ref="$2[$j]"
printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}"
# Indicate new cword
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
# Remove optional whitespace + word separator from line copy
line=${line#*"${COMP_WORDS[i]}"}
# Indicate next word if available, else end *both* while and
# for loop
if ((i < ${#COMP_WORDS[@]} - 1)); then
((i++))
else
break 2
fi
# Start new word if word separator in original line is
# followed by whitespace.
[[ $line == [[:blank:]]* ]] && ((j++))
done
# Append word to current word
ref="$2[$j]"
printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}"
# Remove optional whitespace + word from line copy
line=${line#*"${COMP_WORDS[i]}"}
# Indicate new cword
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
done
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
else
# No, list of word completions separators hasn't changed;
for i in "${!COMP_WORDS[@]}"; do
printf -v "$2[i]" %s "${COMP_WORDS[i]}"
done
fi
}
local FCN_RETURN=""
local IS_PATH=0
# -- THIS LINE WILL BE REPLACED WITH GENERATED CODE --
COMPREPLY=()
local OPTIONS_NEW=""
# check if bash or zsh
# _get_comp_words_by_ref is a bash built-in function, we check if it exists
declare -Ff _get_comp_words_by_ref > /dev/null && IS_BASH=1 || IS_BASH=0
# bash interprets the colon character : as a special character and splits the argument in two
# different than what zsh does
# https://stackoverflow.com/a/3224910
# https://stackoverflow.com/a/12495727
local cur
local cword words=()
_comp__reassemble_words ":" words cword
cur=${words[cword]}
# check the action (get or put)
case "${words[0]}" in
"sls_detector_get" | "g" | "detg")
local IS_GET=1
;;
*)
local IS_GET=0
;;
esac
# if no command is written, autocomplete with the commands
if [[ ${cword} -eq 1 ]]; then
# local SLS_COMMANDS="trimbits exptime"
local SLS_COMMANDS_NEW=""
case "$cur" in
[0-9]*:*)
local suggestions=($(compgen -W "${SLS_COMMANDS}" -- "${cur#*:}"))
COMPREPLY=( ${suggestions[*]} )
;;
[0-9]*)
COMPREPLY=()
;;
*)
COMPREPLY=( $( compgen -W "$SLS_COMMANDS -h" -- "$cur" ) );;
esac
return 0
fi
if [[ ${cword} -eq 2 ]] && [[ ${words[1]} == "-h" ]]; then
COMPREPLY=( $( compgen -W "$SLS_COMMANDS" -- "$cur" ) )
return 0
fi
# if a command is written, autocomplete with the options
# call the function for the command
if [[ "$SLS_COMMANDS" == *"${words[1]##*:}"* ]]; then
__"${words[1]##*:}"
fi
# if IS_PATH is activated, autocomplete with the path
if [[ ${IS_PATH} -eq 1 ]]; then
COMPREPLY=($(compgen -f -- "${cur}"))
return 0
fi
# autocomplete with the options
COMPREPLY=($(compgen -W "${FCN_RETURN}" -- "${cur}"))
}
complete -F _sd -o filenames sls_detector_get
complete -F _sd -o filenames g
complete -F _sd -o filenames detg
complete -F _sd -o filenames sls_detector_put
complete -F _sd -o filenames p
complete -F _sd -o filenames detp
complete -F _sd -o filenames sls_detector
complete -F _sd -o filenames det

3313
slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh Normal file
View File

File diff suppressed because it is too large Load Diff

68283
slsDetectorSoftware/generator/autocomplete/dump.json Normal file
View File

File diff suppressed because it is too large Load Diff

68285
slsDetectorSoftware/generator/autocomplete/fixed.json Normal file
View File

File diff suppressed because it is too large Load Diff

177
slsDetectorSoftware/generator/autocomplete/slsdet-completion.bash Normal file
View File

@@ -0,0 +1,177 @@
#### simpler version of autocomplete.sh to understand the logic
#### each command has its own function when called it will produce the possible values for autocompletion
_sd() {
# Reassemble command line words, excluding specified characters from the
# list of word completion separators (COMP_WORDBREAKS).
# @param $1 chars Characters out of $COMP_WORDBREAKS which should
# NOT be considered word breaks. This is useful for things like scp where
# we want to return host:path and not only path, so we would pass the
# colon (:) as $1 here.
# @param $2 words Name of variable to return words to
# @param $3 cword Name of variable to return cword to
#
_comp__reassemble_words()
{
local exclude="" i j line ref
# Exclude word separator characters?
if [[ $1 ]]; then
# Yes, exclude word separator characters;
# Exclude only those characters, which were really included
exclude="[${1//[^$COMP_WORDBREAKS]/}]"
fi
# Default to cword unchanged
printf -v "$3" %s "$COMP_CWORD"
# Are characters excluded which were former included?
if [[ $exclude ]]; then
# Yes, list of word completion separators has shrunk;
line=$COMP_LINE
# Re-assemble words to complete
for ((i = 0, j = 0; i < ${#COMP_WORDS[@]}; i++, j++)); do
# Is current word not word 0 (the command itself) and is word not
# empty and is word made up of just word separator characters to
# be excluded and is current word not preceded by whitespace in
# original line?
while [[ $i -gt 0 && ${COMP_WORDS[i]} == +($exclude) ]]; do
# Is word separator not preceded by whitespace in original line
# and are we not going to append to word 0 (the command
# itself), then append to current word.
[[ $line != [[:blank:]]* ]] && ((j >= 2)) && ((j--))
# Append word separator to current or new word
ref="$2[$j]"
printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}"
# Indicate new cword
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
# Remove optional whitespace + word separator from line copy
line=${line#*"${COMP_WORDS[i]}"}
# Indicate next word if available, else end *both* while and
# for loop
if ((i < ${#COMP_WORDS[@]} - 1)); then
((i++))
else
break 2
fi
# Start new word if word separator in original line is
# followed by whitespace.
[[ $line == [[:blank:]]* ]] && ((j++))
done
# Append word to current word
ref="$2[$j]"
printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}"
# Remove optional whitespace + word from line copy
line=${line#*"${COMP_WORDS[i]}"}
# Indicate new cword
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
done
((i == COMP_CWORD)) && printf -v "$3" %s "$j"
else
# No, list of word completions separators hasn't changed;
for i in "${!COMP_WORDS[@]}"; do
printf -v "$2[i]" %s "${COMP_WORDS[i]}"
done
fi
}
__exptime(){
if [ "${IS_GET}" == "1" ]; then
if [ "${cword}" == "2" ]; then
FCN_RETURN="s ms us ns"
fi
else
if [ "${cword}" == "2" ]; then
FCN_RETURN=""
fi
if [ "${cword}" == "3" ]; then
FCN_RETURN="s ms us ns"
fi
fi
}
# trimbits will activate IS_PATH and signal that its input is a path
__trimbits(){
if [ "${IS_GET}" == "1" ]; then
if [ "${cword}" == "2" ]; then
FCN_RETURN=""
IS_PATH=1
fi
else
if [ "${cword}" == "2" ]; then
FCN_RETURN=""
IS_PATH=1
fi
fi
}
local cword words=()
_comp__reassemble_words ":" words cword
local FCN_RETURN=""
local IS_PATH=0
COMPREPLY=()
local OPTIONS_NEW=""
# _get_comp_words_by_ref -n : cur
local cur=${words[cword]}
# check the action (get or put)
if [ "${words[0]}" == "sls_detector_get" ]; then
local IS_GET=1
else
local IS_GET=0
fi
# if no command is written, autocomplete with the commands
if [[ ${cword} -eq 1 ]]; then
local SLS_COMMANDS="trimbits exptime"
local SLS_COMMANDS_NEW=""
case "$cur" in
[0-9]*:*)
local suggestions=($(compgen -W "${SLS_COMMANDS}" -- "${cur#*:}"))
COMPREPLY=( ${suggestions[*]} )
;;
[0-9]*)
COMPREPLY=()
;;
*)
COMPREPLY=( $( compgen -W "$SLS_COMMANDS -h" -- "$cur" ) );;
esac
return 0
fi
# if a command is written, autocomplete with the options
# call the function for the command
__"${words[1]##*:}"
# if IS_PATH is activated, autocomplete with the path
if [[ ${IS_PATH} -eq 1 ]]; then
COMPREPLY=($(compgen -f -- "${cur}"))
return 0
fi
# autocomplete with the options
COMPREPLY=($(compgen -W "${FCN_RETURN}" -- "${cur}"))
}
complete -F _sd -o filenames sls_detector_put
complete -F _sd -o filenames sls_detector_get
complete -F _sd -o filenames g
complete -F _sd -o filenames p
complete -F _sd -o filenames detg
complete -F _sd -o filenames detp
complete -F _sd -o filenames sls_detector
complete -F _sd -o filenames det

77
slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.in.sh Normal file
View File

@@ -0,0 +1,77 @@
# GENERATED FILE - DO NOT EDIT
# ANY CHANGES TO THIS FILE WILL BE OVERWRITTEN
_sd() {
# -- THIS LINE WILL BE REPLACED WITH GENERATED CODE --
local FCN_RETURN=""
local IS_PATH=0
COMPREPLY=()
local OPTIONS_NEW=""
words=("${COMP_WORDS[@]}")
cword=$COMP_CWORD
local cur=${words[cword]}
# check the action (get or put)
case "${words[0]}" in
"sls_detector_get" | "g" | "detg")
local IS_GET=1
;;
*)
local IS_GET=0
;;
esac
# if no command is written, autocomplete with the commands
if [[ ${cword} -eq 1 ]]; then
case "$cur" in
[0-9]*)
for i in $SLS_COMMANDS; do
SLS_COMMANDS_NEW="${SLS_COMMANDS_NEW} ${cur%%:*}:$i"
done
COMPREPLY=( $( compgen -W "${SLS_COMMANDS_NEW}" -- "$cur" ) );;
*)
COMPREPLY=( $( compgen -W "$SLS_COMMANDS -h" -- "$cur" ) );;
esac
return 0
fi
if [[ ${cword} -eq 2 ]] && [[ ${words[1]} == "-h" ]]; then
COMPREPLY=( $( compgen -W "$SLS_COMMANDS" -- "$cur" ) )
return 0
fi
# if a command is written, autocomplete with the options
# call the function for the command
if [[ "$SLS_COMMANDS" == *"${words[1]##*:}"* ]]; then
__"${words[1]##*:}"
fi
# if IS_PATH is activated, autocomplete with the path
if [[ ${IS_PATH} -eq 1 ]]; then
COMPREPLY=($(compgen -f -- "${cur}"))
return 0
fi
# autocomplete with the options
COMPREPLY=($(compgen -W "${FCN_RETURN}" -- "${cur}"))
}
complete -F _sd -o filenames sls_detector_get
complete -F _sd -o filenames g
complete -F _sd -o filenames detg
complete -F _sd -o filenames sls_detector_put
complete -F _sd -o filenames p
complete -F _sd -o filenames detp
complete -F _sd -o filenames sls_detector
complete -F _sd -o filenames det

3223
slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh Normal file
View File

File diff suppressed because it is too large Load Diff

4335
slsDetectorSoftware/generator/commands.yaml Normal file
View File

File diff suppressed because it is too large Load Diff

0
slsDetectorSoftware/generator/commands_parser/__init__.py Normal file
View File

379
slsDetectorSoftware/generator/commands_parser/commands_parser.py Normal file
View File

@@ -0,0 +1,379 @@
import copy
import logging
import yaml
from pathlib import Path
class CommandParser:
def __init__(
self,
commands_file: Path = Path(__file__).parent.parent / 'commands.yaml',
output_file: Path = Path(__file__).parent.parent / 'extended_commands.yaml'
):
self.output_file = output_file
self.commands_file = commands_file
self.fp = self.commands_file.open('r')
self.simple_commands = yaml.unsafe_load(self.fp)
self.extended_commands = {}
self.argc_set = set()
self.logger = logging.getLogger('command_parser')
self.__current_action: str = ''
FORMAT = '[%(levelname)s] %(message)s'
logging.basicConfig(format=FORMAT, level=logging.INFO)
self.propagate_config = {
'require_det_id': False,
'convert_det_id': True,
'input': [],
'input_types': [],
'function': '',
'output': [],
'cast_input': [],
'check_det_id': False,
'arg_types': [],
# 'store_result_in_t': False, # always true in GET action
}
self.default_config = {
'infer_action': True,
'help': '',
'actions': {}
}
def _verify_argument(self, arg, infer_action, command_name, action):
if arg['function'] == '' and 'ctb_output_list' not in arg:
special_exception_message_list = ["Cannot put", "Cannot get"]
if 'exceptions' in arg and arg['exceptions'][0]['condition'] == 'true' and any(ele in arg['exceptions'][0]['message'] for ele in special_exception_message_list):
self.logger.warning(f"{command_name} has a special exception message for {action}.")
else:
self.logger.warning(f"{command_name} [{action}] does not have a function")
if len(arg['input_types']) != len(arg['input']):
raise ValueError(f'Argument {arg} does not have the correct number of inputs')
if 'separate_time_units' in arg:
if arg['separate_time_units']['input'] == "":
raise ValueError(f'Argument {arg} does not have the correct number of inputs for separate_time_units')
if len(arg['separate_time_units']['output']) != 2:
raise ValueError(f'Argument {arg} does not have the correct number of outputs for separate_time_units')
if 'convert_to_time' in arg:
if len(arg['convert_to_time']['input']) != 2:
raise ValueError(f'Argument {arg} does not have the correct number of inputs for convert_to_time')
if len(arg['convert_to_time']['output']) == "":
raise ValueError(f'Argument {arg} does not have the correct number of outputs for convert_to_time')
# if infer_action:
# if arg['argc'] in self.argc_set:
# raise ValueError(f'Argument {arg} has a duplicate argc')
# self.argc_set.add(arg['argc'])
def verify_format(self):
# todo verify detectors
# todo verify circular inheritance
# todo verify child commands (those that inherit)
# todo verify that there is no wrongly typed parameters
# todo verify that the same number of input_types and input are given
# todo verify that each argument has argc (error can happen when inheriting)
for command_name, command in self.simple_commands.items():
if 'inherit_actions' in command or 'template' in command and command[
'template'] or 'is_description' in command and command['is_description']:
continue
self.argc_set = set()
if 'infer_action' not in command:
command['infer_action'] = True
if 'actions' not in command:
raise ValueError(f'Command {command_name} does not have any actions')
for action, action_params in command['actions'].items():
if 'argc' in action_params:
if 'args' in action_params:
raise ValueError(f'Action {action} has both argc and args')
arg = {**self.propagate_config, **action_params}
self._verify_argument(arg, command['infer_action'], command_name, action)
elif 'args' in action_params:
if type(action_params['args']) is not list:
raise ValueError(f'Action {action} args is not a list')
if len(action_params['args']) == 0:
raise ValueError(f'Action {action} args is empty')
action_args = {**self.propagate_config, **action_params}
del action_args['args']
for arg in action_params['args']:
arg = {**action_args, **arg}
self._verify_argument(arg, command['infer_action'], command_name, action)
self.logger.info('Commands file is valid ✅️')
return True
def _parse_inherited_command(self, parent, command, simple_parent):
"""
parse a command that inherits from parent command
:param parent: parsed parent command
:param command: the current command
:param simple_parent: unparsed parent command
:return: parsed command
"""
# deepcopy parent and command to avoid modifying the originals
command = copy.deepcopy(command)
config = copy.deepcopy(parent)
# add help
if 'help' in command:
config['help'] = command['help']
if 'actions' not in command:
return config
for action, command_params in command['actions'].items():
self.__current_action = action
if action not in config['actions']:
# todo: handle this case
pass
parent_params = config['actions'][action]
if 'args' in command_params:
# child has args => inherit action level params from parent + override with child args + use child's
# action level params
context = {**self.propagate_config, **simple_parent['actions'][action], **command_params}
config['actions'][action]['args'] = self.parse_action(context, command_params['args'])
elif 'argc' in command_params:
# child has action level args (argc)
context = {**self.propagate_config, **simple_parent['actions'][action], **command_params}
config['actions'][action]['args'] = self.parse_action(context, [])
else:
# child does not have args => use parent's action level params + override with child's action level
if 'args' in parent_params:
config['actions'][action]['args'] = self.parse_action({}, parent_params['args'], command_params)
if 'detectors' in command_params:
if command_params['detectors'] is None:
# if child has an empty detector section, then delete the parent's detector section
del config['actions'][action]['detectors']
continue
for detector_name, detector_params in command_params['detectors'].items():
if 'detectors' not in config['actions'][action]:
config['actions'][action]['detectors'] = {}
config_detector = config['actions'][action]['detectors']
if 'detectors' not in parent_params or detector_name not in parent_params['detectors']:
if 'args' in detector_params:
# if child has detector args and parent does not have detectors
# => use child's detector args
context = {**self.propagate_config, **simple_parent['actions'][action], **detector_params}
config_detector[detector_name] = self.parse_action(context, detector_params['args'])
elif 'args' in parent_params:
# if child does not have detector args and parent does not have detectors
# => use the child's action args
context = {**self.propagate_config, **simple_parent['actions'][action]}
config_detector[detector_name] = self.parse_action(context,
config['actions'][action]['args'],
detector_params)
elif detector_name in parent_params['detectors']:
if 'args' in detector_params:
# child and parent have the same detector and child has detector args
# => use child's detector args
context = {
**self.propagate_config,
**simple_parent['actions'][action],
**simple_parent['actions'][action]['detectors'][detector_name],
}
config_detector[detector_name] = self.parse_action(context, detector_params['args'])
else:
# child and parent have the same detector and child does not have detector args
# => use parent's detector args
priority_context = {**command_params, **detector_params}
config_detector[detector_name] = self.parse_action(
{},
parent_params['detectors'][detector_name],
priority_context
)
else:
pass
return config
def _parse_command(self, command):
"""
logic function for parse_command.
This function is recursive
:return: parsed command
"""
config = self.default_config.copy()
config.update(command)
config['actions'] = {}
# check if command inherits from another command
if 'inherit_actions' in command:
if command['inherit_actions'] in self.extended_commands:
# if parent command has already been parsed, use that
parent = self.extended_commands[command['inherit_actions']]
else:
# if parent command has not been parsed, parse it
parent = self.parse_command(command['inherit_actions'])
# parse the current command and merge it with the parent command
config = self._parse_inherited_command(parent, command, self.simple_commands[command['inherit_actions']])
return config
if 'actions' not in command:
return config
for action, action_params in command['actions'].items():
self.__current_action = action
config['actions'][action] = {}
config_action = config['actions'][action]
# the context in the current command and the current action
action_context = {**self.propagate_config, **action_params}
if 'args' not in action_params:
# parse the action with the action context
if action_params.keys() != {'detectors'}:
config_action['args'] = self.parse_action(action_context, [])
else:
config_action['args'] = self.parse_action(action_context, action_params['args'])
# check if the action has detectors
if 'detectors' in action_params:
config_action['detectors'] = {}
for detector_name, detector_params in action_params['detectors'].items():
# get the context for the detector and merge it with the action context
detector_context = {**action_context, **detector_params}
# if the detector does not have args, then use the action args
# otherwise, use the detector args and override the action args
tmp_args = []
if 'args' not in detector_params:
if 'args' in config_action:
tmp_args = config_action['args']
else:
tmp_args = detector_params['args']
detector_params['args'] = tmp_args
# parse the action with the detector context
config_action['detectors'][detector_name] = self.parse_action(detector_context,
tmp_args,
detector_params)
return config
def sanitize_argument(func):
def f(self, action_context, args_old, priority_context={}):
args = func(self, action_context, args_old, priority_context)
for i, arg in enumerate(args):
if 'args' in arg:
del arg['args']
if 'detectors' in arg:
del arg['detectors']
if not arg['cast_input']:
# if the cast_input is empty, then set it to False
arg['cast_input'] = [False] * len(arg['input'])
elif len(arg['cast_input']) != len(arg['input']):
# if the cast_input is not the same length as the input, then set it to False
arg['cast_input'] = [False] * len(arg['input'])
self.logger.warning(f'cast_input for {arg["function"]} '
f'with argc: {arg["argc"]} has different length than input')
if 'store_result_in_t' not in arg:
if self.__current_action == 'GET':
arg['store_result_in_t'] = True
else:
arg['store_result_in_t'] = False
return args
return f
@sanitize_argument
def parse_action(self, action_context, args, priority_context={}):
"""
parse an action
:param action_context: context of the action
:param args: arguments to be used in the action
:param priority_context: context that should override the arguments params
:return: parsed action
"""
def add_cast_input(argument):
return argument
# deepcopy action_context to avoid modifying the original
action_context = {**self.propagate_config, **copy.deepcopy(action_context)}
priority_context = copy.deepcopy(priority_context)
if 'detectors' in action_context:
del action_context['detectors']
if 'detectors' in priority_context:
del priority_context['detectors']
if args == []:
# if there are no arguments, then the action has only one argument
context = {**action_context, **priority_context}
return [add_cast_input(context)]
ret_args = []
if 'args' in action_context:
del action_context['args']
if 'args' in priority_context:
del priority_context['args']
# if there are arguments, then merge them with the action context and priority context
for arg in args:
arg = {**action_context, **arg, **priority_context}
ret_args.append(add_cast_input(arg))
return ret_args
def parse_command(self, command_name):
"""
parse a single command
This function is recursive
:param command_name: name of the command to parse
:return: the parsed command
"""
command = self.simple_commands[command_name]
parsed_command = self._parse_command(command)
if 'function_alias' not in command:
if 'command_name' in command:
parsed_command['function_alias'] = command['command_name']
else:
parsed_command['function_alias'] = command_name
if 'command_name' not in command:
parsed_command['command_name'] = command_name
if 'template' in command and command['template']:
return parsed_command
self.extended_commands[command_name] = parsed_command
return self.extended_commands[command_name]
def parse_all_commands(self):
"""
iterate over all commands in yaml file and parse them
:return: None
"""
for command_name in self.simple_commands:
# todo remove this (added for debugging)
if command_name != 'xtiming':
self.parse_command(command_name)
# post-process the parsed commands
self.post_process_all_commands()
yaml.Dumper.ignore_aliases = lambda *args: True
self.logger.info(f'parsed {len(self.extended_commands)} commands')
yaml.dump(self.extended_commands, self.output_file.open('w'), default_flow_style=False)
def post_process_all_commands(self):
for command_name, command in self.extended_commands.items():
if 'is_description' in command and command['is_description']:
continue
for action_name, action, in command['actions'].items():
for arg in action['args']:
if arg['argc'] == 0:
arg['arg_types'] = []
continue
if arg['argc'] == -1:
pass
if arg['arg_types'] == []:
arg['arg_types'] = arg['input_types']
# command_parser = CommandParser(Path(
# '/afs/psi.ch/user/b/braham_b/github/slsDetectorPackage/slsDetectorSoftware/generator/tests/command_parser/data/detectors.yaml'))
command_parser = CommandParser()
if __name__ == '__main__':
command_parser.verify_format()
command_parser.parse_all_commands()

0
slsDetectorSoftware/generator/cpp_codegen/__init__.py Normal file
View File

282
slsDetectorSoftware/generator/cpp_codegen/codegen.py Normal file
View File

@@ -0,0 +1,282 @@
class CodeGenerator:
def __init__(self):
self.file = None
self.actions_dict = {
'GET': 'slsDetectorDefs::GET_ACTION',
'PUT': 'slsDetectorDefs::PUT_ACTION',
'READOUT': 'slsDetectorDefs::READOUT_ACTION',
'HELP': 'slsDetectorDefs::HELP_ACTION',
}
self.template_file = None
def open(self, path):
self.file = path.open('w')
def close(self):
self.file.close()
self.file = None
def write_line(self, line):
self.file.write(line + '\n')
def write(self, text):
self.file.write(text)
def write_opening(self, path):
"""Write the opening file for the caller.cpp file"""
self.template_file = path.open('r')
for line in self.template_file:
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE" in line:
return
self.file.write(line)
def write_closing(self):
"""Write the closing file for the caller.cpp file"""
for line in self.template_file.readlines():
self.file.write(line)
self.template_file.close()
def write_header(self, in_path, out_path, commands, deprecated_commands):
"""Write the header file for the caller.h file"""
with out_path.open('w') as fp:
with in_path.open('r') as fp2:
for line in fp2:
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1)" in line:
for command_name, command in commands.items():
if 'duplicate_function' in command and command['duplicate_function']:
continue
fp.write(f'std::string {command["function_alias"]}(int action);\n')
continue
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (2)" in line:
map_string = ''
for command_name, command in commands.items():
map_string += f'{{"{command_name}", &Caller::{command["function_alias"]}}},'
fp.write(map_string[:-1] + '\n')
continue
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (3)" in line:
for key, value in deprecated_commands.items():
fp.write(f'{{"{key}", "{value}"}},\n')
continue
fp.write(line)
def write_infer_header(self, in_path, out_path, commands):
"""Write the header file for the inferAction.h file"""
with out_path.open('w+') as fp:
with in_path.open('r') as fp2:
for line in fp2:
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1) - DO NOT REMOVE" in line:
for command_name, command in commands.items():
if 'duplicate_function' in command and command['duplicate_function']:
continue
fp.write(f'int {command["function_alias"]}();\n')
continue
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (2) - DO NOT REMOVE" in line:
map_string = ''
for command_name, command in commands.items():
map_string += f'{{"{command_name}", &InferAction::{command["function_alias"]}}},'
fp.write(map_string[:-1] + '\n')
continue
fp.write(line)
def write_infer_cpp(self, in_path, out_path, commands, non_dist, type_dist):
"""Write the source file for the inferAction.cpp file"""
with in_path.open('r') as fp2:
for line in fp2:
if "THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1) - DO NOT REMOVE" in line:
for command_name, command in commands.items():
if 'duplicate_function' in command and command['duplicate_function']:
continue
with function('int', f"InferAction::{command['function_alias']}", []) as f:
if (command_name, -1) in non_dist| type_dist:
self.write_line(
f'throw RuntimeError("sls_detector is disabled for command: {command_name}. Use sls_detector_get or sls_detector_put");')
elif not command['infer_action']:
self.write_line('throw RuntimeError("infer_action is disabled");')
else:
checked_argcs = set()
for action, action_params in command['actions'].items():
for arg in action_params['args']:
if arg['argc'] in checked_argcs:
continue
checked_argcs.add(arg['argc'])
with if_block(f'args.size() == {arg["argc"]}'):
# check if this argc is not distinguishable
if (command_name, arg["argc"]) in non_dist | type_dist:
self.write_line(
f'throw RuntimeError("sls_detector is disabled for command: {command_name} with number of arguments {arg["argc"]}. Use sls_detector_get or sls_detector_put");')
else:
self.write_line(f'return {self.actions_dict[action]};')
with else_block():
self.write_line(
'throw RuntimeError("Could not infer action: Wrong number of arguments");')
continue
self.write_line(line)
def write_check_arg(self):
pass
def write_arg(self, args, action, command_name):
for arg in args:
if arg['argc'] != -1:
if_block(f'args.size() == {arg["argc"]}',).__enter__()
if 'pattern_command' in arg and arg['pattern_command']:
self.write_line(f'int level = -1, iArg = 0, '
f'nGetArgs = {arg["pattern_command"]["nGetArgs"]},'
f' nPutArgs = {arg["pattern_command"]["nPutArgs"]};\nGetLevelAndUpdateArgIndex(action, '
f'"{arg["pattern_command"]["command_name"]}", level, iArg, nGetArgs,nPutArgs);'
)
if 'extra_variables' in arg:
for var in arg['extra_variables']:
codegen.write_line(f'{var["type"]} {var["name"]} = {var["value"]};')
if 'separate_time_units' in arg and arg['separate_time_units']:
self.write_line(f'std::string tmp_time({arg["separate_time_units"]["input"]});')
self.write_line(f'std::string {arg["separate_time_units"]["output"][1]}'
f' = RemoveUnit(tmp_time);')
self.write_line(f'auto {arg["separate_time_units"]["output"][0]} = '
f'StringTo < time::ns > (tmp_time,'
f' {arg["separate_time_units"]["output"][1]});')
if 'convert_to_time' in arg and arg['convert_to_time']:
self.write_line(f'auto {arg["convert_to_time"]["output"]} = '
f'StringTo < time::ns > ({", ".join(arg["convert_to_time"]["input"])});')
input_arguments = []
if 'exceptions' in arg:
for exception in arg['exceptions']:
self.write_line(f'if ({exception["condition"]}) {{ throw RuntimeError({exception["message"]}); }}')
if 'check_det_id' in arg and arg['check_det_id']:
self.write_line(
f'if (det_id != -1) {{ throw RuntimeError("Cannot execute {command_name} at module level"); }} '
)
# only used for 3 commands :(
if 'ctb_output_list' in arg:
self.write_line(f"""
std::string suffix = " {arg['ctb_output_list']['suffix']}";
auto t = det->{arg['ctb_output_list']['GETFCNLIST']}();""")
if arg['ctb_output_list']['GETFCNNAME'] != '':
self.write_line(f"""
auto names = det->{arg['ctb_output_list']['GETFCNNAME']}();
auto name_it = names.begin();""")
self.write_line("os << '[';")
with if_block(f't.size() > 0'):
self.write_line(f"""
auto it = t.cbegin();
os << ToString({arg['ctb_output_list']['printable_name']}) << ' ';
os << OutString(det->{arg['ctb_output_list']['GETFCN']}(*it++, std::vector<int>{{det_id}}))<< suffix;
while (it != t.cend()) {{
os << ", " << ToString({arg['ctb_output_list']['printable_name']}) << ' ';
os << OutString(det->{arg['ctb_output_list']['GETFCN']}(*it++, std::vector<int>{{det_id}}))<< suffix;
}}
""")
self.write_line('os << "]\\n";')
if arg['argc'] != -1:
if_block().__exit__()
return
for i in range(len(arg['input'])):
if arg['cast_input'][i]:
self.write_line(
f'auto arg{i} = StringTo<{arg["input_types"][i]}>({arg["input"][i]});')
input_arguments.append(f'arg{i}')
else:
input_arguments.append(arg["input"][i])
if 'require_det_id' in arg and arg['require_det_id']:
if 'convert_det_id' in arg and arg['convert_det_id']:
input_arguments.append("std::vector<int>{ det_id }")
else:
input_arguments.append("det_id")
input_arguments = ", ".join(input_arguments)
# call function
if arg["function"]:
if arg['store_result_in_t']:
self.write_line(f'auto t = det->{arg["function"]}({input_arguments});')
else:
self.write_line(f'det->{arg["function"]}({input_arguments});')
else:
pass #We have no function so skip block
output_args = []
for output in arg['output']:
output_args.append(output)
if len(output_args) > 0:
self.write_line(f"os << {'<< '.join(output_args)} << '\\n';")
if arg['argc'] != -1:
if_block().__exit__()
class if_block:
def __init__(self, condition="", elseif=False):
self.condition = condition
self.elseif = elseif
self.block = False
def __enter__(self):
if self.elseif:
codegen.write_line('else if (' + self.condition + ') {')
else:
codegen.write_line('if (' + self.condition + ') {')
if self.block:
codegen.write_line('{\n')
def __exit__(self, *args):
codegen.write_line('}')
if self.block:
codegen.write_line('}')
codegen.write_line('')
class else_block:
def __init__(self):
pass
def __enter__(self):
codegen.write_line('else {')
codegen.write_line('')
def __exit__(self, *args):
codegen.write_line('}')
codegen.write_line('')
class for_block:
def __init__(self, condition):
self.condition = condition
def __enter__(self):
codegen.write_line('for (' + self.condition + ') {')
codegen.write_line('')
def __exit__(self, *args):
codegen.write_line('}')
codegen.write_line('')
class function:
def __init__(self, return_type, name, args: list[tuple[str, str]]):
self.name = name
self.args = args
self.return_type = return_type
def __enter__(self):
s = ""
for arg in self.args:
arg_type, arg_name = arg
s += arg_type + ' ' + arg_name + ', '
s = s[:-2]
codegen.write_line(self.return_type + ' ' + self.name +
f'({s}) {{')
codegen.write_line('')
return self
def __exit__(self, *args):
codegen.write_line('}')
codegen.write_line('')
codegen = CodeGenerator()

176
slsDetectorSoftware/generator/deprecated_commands.yaml Normal file
View File

@@ -0,0 +1,176 @@
#configuration
detectorversion: firmwareversion
softwareversion: detectorserverversion
receiverversion: rx_version
detectornumber: serialnumber
thisversion: clientversion
detsizechan: detsize
trimdir: settingspath
settingsdir: settingspath
flippeddatax: fliprows
#acquisition parameters
cycles: triggers
cyclesl: triggersl
clkdivider: readoutspeed
speed: readoutspeed
vhighvoltage: highvoltage
digitest: imagetest
filter: filterresistor
readnlines: readnrows
# temperature
# super old dacs
vtr: vtrim
vrf: vrpreamp
vrs: vrshaper
vcall: vcal
vis: vishaper
vshaper: vrshaper
vpreamp: vrpreamp
vshaperneg: vrshaper_n
viinsh: vishaper
vpl: vcal_n
vph: vcal_p
# dacs
vthreshold: dac
vsvp: dac
vsvn: dac
vtrim: dac
vrpreamp: dac
vrshaper: dac
vtgstv: dac
vcmp_ll: dac
vcmp_lr: dac
vcal: dac
vcmp_rl: dac
vcmp_rr: dac
rxb_rb: dac
rxb_lb: dac
vcp: dac
vcn: dac
vishaper: dac
iodelay: dac
vref_ds: dac
vcascn_pb: dac
vcascp_pb: dac
vout_cm: dac
vcasc_out: dac
vin_cm: dac
vref_comp: dac
ib_test_c: dac
vrshaper_n: dac
vipre: dac
vdcsh: dac
vth1: dac
vth2: dac
vth3: dac
vcal_n: dac
vcal_p: dac
vcassh: dac
vcas: dac
vicin: dac
vipre_out: dac
vref_h_adc: dac
vb_comp_fe: dac
vb_comp_adc: dac
vcom_cds: dac
vref_rstore: dac
vb_opa_1st: dac
vref_comp_fe: dac
vcom_adc1: dac
vref_prech: dac
vref_l_adc: dac
vref_cds: dac
vb_cs: dac
vb_opa_fd: dac
vcom_adc2: dac
vb_ds: dac
vb_comp: dac
vb_pixbuf: dac
vin_com: dac
vdd_prot: dac
vbp_colbuf: dac
vb_sda: dac
vcasc_sfp: dac
vipre_cds: dac
ibias_sfp: dac
defaultdacs: resetdacs
#acquisition
busy: clearbusy
receiver: rx_status
framescaught: rx_framescaught
startingfnum: nextframenumber
#Network Configuration (Detector<->Receiver)
detectorip: udp_srcip
detectorip2: udp_srcip2
detectormac: udp_srcmac
detectormac2: udp_srcmac2
rx_udpip: udp_dstip
rx_udpip2: udp_dstip2
rx_udpmac: udp_dstmac
rx_udpmac2: udp_dstmac2
rx_udpport: udp_dstport
rx_udpport2: udp_dstport2
flowcontrol_10g: flowcontrol10g
txndelay_frame: txdelay_frame
txndelay_left: txdelay_left
txndelay_right: txdelay_right
#Receiver Config
r_silent: rx_silent
r_discardpolicy: rx_discardpolicy
r_padding: rx_padding
r_lock: rx_lock
r_lastclient: rx_lastclient
#File
fileformat: fformat
outdir: fpath
index: findex
enablefwrite: fwrite
masterfile: fmaster
overwrite: foverwrite
r_framesperfile: rx_framesperfile
#ZMQ Streaming Parameters (Receiver<->Client)
r_readfreq: rx_zmqfreq
rx_readfreq: rx_zmqfreq
rx_datastream: rx_zmqstream
#Eiger Specific
resmat: partialreset
#Jungfrau Specific
storagecells: extrastoragecells
auto_comp_disable: autocompdisable
comp_disable_time: compdisabletime
#Gotthard Specific
#Gotthard2 Specific
#Mythen3 Specific
#CTB Specific
adc: slowadc
flags: romode
i_a: im_a
i_b: im_b
i_c: im_c
i_d: im_d
i_io: im_io
#Pattern
#Moench
#Advanced
copydetectorserver: updatedetectorserver
#Insignificant
nframes: framecounter
now: runtime
timestamp: frametime
frameindex: rx_frameindex

14072
slsDetectorSoftware/generator/extended_commands.yaml Normal file
View File

File diff suppressed because it is too large Load Diff

275
slsDetectorSoftware/generator/gen_commands.py Normal file
View File

@@ -0,0 +1,275 @@
import argparse
import os
import subprocess
from pathlib import Path
import yaml
from autocomplete.autocomplete import type_info
from cpp_codegen.codegen import codegen, if_block, for_block, function, else_block
from infer_action.check_infer import check_infer
from autocomplete.autocomplete import type_values
GEN_PATH = Path(__file__).parent
COMMANDS_PATH = GEN_PATH / 'extended_commands.yaml'
DEPRECATED_COMMANDS_PATH = GEN_PATH / 'deprecated_commands.yaml'
CPP_INPUT_PATH = GEN_PATH / 'Caller.in.cpp'
HEADER_INPUT_PATH = GEN_PATH / 'Caller.in.h'
CPP_OUTPUT_PATH = GEN_PATH.parent / 'src' / 'Caller.cpp'
HEADER_OUTPUT_PATH = GEN_PATH.parent / 'src' / 'Caller.h'
INFER_HEADER_INPUT_PATH = GEN_PATH / 'inferAction.in.h'
INFER_CPP_INPUT_PATH = GEN_PATH / 'inferAction.in.cpp'
INFER_HEADER_OUTPUT_PATH = GEN_PATH.parent / 'src' / 'inferAction.h'
INFER_CPP_OUTPUT_PATH = GEN_PATH.parent / 'src' / 'inferAction.cpp'
def generate(
commands_path=COMMANDS_PATH,
cpp_input_path=CPP_INPUT_PATH,
header_input_path=HEADER_INPUT_PATH,
cpp_output_path=CPP_OUTPUT_PATH,
header_output_path=HEADER_OUTPUT_PATH,
infer_header_input_path=INFER_HEADER_INPUT_PATH,
infer_cpp_input_path=INFER_CPP_INPUT_PATH,
infer_header_output_path=INFER_HEADER_OUTPUT_PATH,
infer_cpp_output_path=INFER_CPP_OUTPUT_PATH,
):
commands_config = yaml.unsafe_load(commands_path.open('r'))
deprecated_commands_config = yaml.unsafe_load(DEPRECATED_COMMANDS_PATH.open('r'))
type_dist, non_dist = check_infer(commands=commands_config)
codegen.open(cpp_output_path)
# write call function
codegen.write_opening(cpp_input_path)
# iterate over the commands and generate code for each
print(f"[X] found {len(commands_config)} commands")
print('[*] generating code for commands')
for command_name, command in commands_config.items():
if 'is_description' in command and command['is_description']:
continue
with function('std::string', 'Caller::' + command['function_alias'], [('int', 'action')]) as fn:
codegen.write_line('std::ostringstream os;')
# print help
codegen.write_line('// print help')
with if_block('action == slsDetectorDefs::HELP_ACTION'):
if command["help"].startswith('code:'):
codegen.write_line(command["help"].strip('code:'))
else:
codegen.write_line(f'os << R"V0G0N({command["help"]} )V0G0N" << std::endl;')
codegen.write_line('return os.str();')
# check if action and arguments are valid
codegen.write_line('// check if action and arguments are valid')
first = True
for action, action_params in command['actions'].items():
with if_block(f'action == {codegen.actions_dict[action]}', elseif=not first):
check_argc = True
for arg in action_params['args']:
if arg['argc'] == -1:
check_argc = False
break
# check number of arguments
condition = "1" if check_argc else "0"
if check_argc:
for arg in action_params['args']:
condition += f' && args.size() != {arg["argc"]}'
with if_block(condition):
codegen.write_line(f'throw RuntimeError("Wrong number of arguments for action {action}");')
for arg in action_params['args']:
if not check_argc:
continue
with if_block(f'args.size() == {arg["argc"]}'):
# check argument types
if 'extra_variables' in arg:
for var in arg['extra_variables']:
codegen.write_line(f'{var["type"]} {var["name"]} = {var["value"]};')
if 'separate_time_units' in arg and arg['separate_time_units']:
codegen.write_line(f'try {{')
# TODO: refactor this repeating code
codegen.write_line(f'std::string tmp_time({arg["separate_time_units"]["input"]});')
codegen.write_line(f'std::string {arg["separate_time_units"]["output"][1]}'
f' = RemoveUnit(tmp_time);')
codegen.write_line(f'auto {arg["separate_time_units"]["output"][0]} = '
f'StringTo < time::ns > (tmp_time,'
f' {arg["separate_time_units"]["output"][1]});')
codegen.write_line(
f'}} catch (...) {{ throw RuntimeError("Could not convert argument to time::ns");}}')
elif 'convert_to_time' in arg and arg['convert_to_time']:
codegen.write_line(f'try {{')
codegen.write_line(
f'StringTo < time::ns > ({", ".join(arg["convert_to_time"]["input"])});')
codegen.write_line(
f'}} catch (...) {{ throw RuntimeError("Could not convert arguments to time::ns");}}')
for i in range(len(arg['input'])):
if not arg['cast_input'][i]:
continue
codegen.write_line(f'try {{')
codegen.write_line(f'StringTo<{arg["input_types"][i]}>({arg["input"][i]});')
codegen.write_line(f'}} catch (...) {{')
codegen.write_line(
f' throw RuntimeError("Could not convert argument {i} to {arg["input_types"][i]}");')
codegen.write_line(f'}}')
first = False
with else_block():
codegen.write_line(
f'throw RuntimeError("INTERNAL ERROR: Invalid action: supported actions are {list(command["actions"].keys())}");')
# generate code for each action
codegen.write_line('// generate code for each action')
for action, action_params in command['actions'].items():
if 'detectors' in action_params:
codegen.write_line('auto detector_type = det->getDetectorType().squash();')
with if_block(f'action == {codegen.actions_dict[action]}'):
if 'detectors' in action_params:
first = True
for detector, detector_params in action_params['detectors'].items():
with if_block(f'detector_type == defs::{detector}', elseif=not first):
codegen.write_arg(detector_params, action, command_name)
else_block().__enter__()
if not action_params:
codegen.write_line(f'throw RuntimeError("detector not supported for action: {action}");')
else:
tmp_args = []
if 'args' in action_params:
tmp_args = action_params['args']
codegen.write_arg(tmp_args, action, command_name)
if 'detectors' in action_params:
else_block().__exit__()
codegen.write_line('return os.str();')
# close sls namespace
codegen.write_closing()
codegen.close()
print('[X] .cpp code generated')
deprecated_commands = []
codegen.write_header(header_input_path, header_output_path, commands_config, deprecated_commands_config)
print('[X] header code generated')
codegen.write_infer_header(infer_header_input_path, infer_header_output_path, commands_config) #TODO: add deprecated commands
print('[X] infer header code generated')
codegen.open(infer_cpp_output_path)
codegen.write_infer_cpp(infer_cpp_input_path, infer_cpp_output_path, commands_config, non_dist, type_dist)
codegen.close()
print('[X] infer cpp code generated')
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='generate c++ code for cli commands from the commands.yaml file',
)
parser.add_argument('-f', '--format', action='store_true', default=False, dest='format',
help='format header and cpp file using clang-format')
parser.add_argument('-p', '--parse', action='store_true', default=False, dest='parse',
help='parse the commands.yaml file into extended_commands.yaml')
parser.add_argument('-c', '--check', action='store_true', default=False, dest='check',
help='check missing commands')
parser.add_argument('-g', '--generate', action='store_true', default=False, dest='generate', help='generate code (C++ or bash if -a is used)')
parser.add_argument('-a', '--autocomplete', action='store_true', default=False, dest='autocomplete',
help='print bash autocomplete values')
cli_args = parser.parse_args()
if cli_args.autocomplete:
from autocomplete.autocomplete import generate_type_values, generate_bash_autocomplete
if cli_args.generate:
generate_bash_autocomplete()
print('[X] bash autocomplete generated')
generate_bash_autocomplete(
output_path=Path(__file__).parent / 'autocomplete' / 'zsh_autocomplete.sh',
input_path=Path(__file__).parent / 'autocomplete' / 'zsh_autocomplete.in.sh'
)
print('[X] zsh autocomplete generated')
exit(0)
else:
ret = generate_type_values()
print(ret)
exit(0)
if cli_args.check:
from commands_parser.commands_parser import command_parser
commands_config = yaml.unsafe_load(COMMANDS_PATH.open('r'))
# infer action based on number of arguments and types
type_dist, non_dist = check_infer(commands=commands_config)
command_parser.verify_format()
command_parser.parse_all_commands()
# generate list of commands found in sls_detector_get
glist_path = GEN_PATH / 'glist'
ret = subprocess.run([f"sls_detector_get list | tail -n +2 | sort > {glist_path.absolute()}"], shell=True,
capture_output=True, check=True)
if ret.stderr != b'':
print('[!] glist generation failed and glist not found')
exit(1)
if not COMMANDS_PATH.exists():
print('[!] extended_commands.yaml not found')
exit(1)
detglist = set(command['command_name'] for __, command in commands_config.items())
detglist.add('free')
detglist.add('list')
g_path = GEN_PATH / 'glist'
if not g_path.exists():
print('[!] glist not found')
exit(1)
glist = set(g_path.read_text().split('\n'))
if "" in glist:
glist.remove("")
if "" in detglist:
detglist.remove("")
not_found = set()
for command in glist:
if command not in detglist:
not_found.add(command)
print()
if len(not_found) > 0:
print(f'[!] found {len(not_found)} missing')
print(f"not_found: {not_found}")
else:
print(f'[X] found no missing commands')
for command in detglist:
if command not in glist:
print(f'[!] command {command} found in commands.yaml but not found in g list')
exit(0)
if cli_args.parse:
from commands_parser.commands_parser import command_parser
command_parser.verify_format()
command_parser.parse_all_commands()
if cli_args.generate:
generate()
if cli_args.format:
files = [CPP_OUTPUT_PATH, HEADER_OUTPUT_PATH, INFER_HEADER_OUTPUT_PATH, INFER_CPP_OUTPUT_PATH]
for file in files:
os.system(f'clang-format -i {file.absolute()}')
#os.system(f'clang-format -i --style="{{Standard: C++11}}" {file.absolute()}')
print('[X] code formatted')

20
slsDetectorSoftware/generator/inferAction.in.cpp Normal file
View File

@@ -0,0 +1,20 @@
#include "inferAction.h"
#include "sls/sls_detector_defs.h"
namespace sls {
int InferAction::infer(sls::CmdParser &parser, std::ostream &os) {
args = parser.arguments();
cmd = parser.command();
auto it = functions.find(parser.command());
if (it != functions.end()) {
return ((*this).*(it->second))();
} else {
throw RuntimeError(
"sls_detector not implemented for command: " + parser.command() +
". Use sls_detector_get or sls_detector_put.");
}
}
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1) - DO NOT REMOVE
} // namespace sls

30
slsDetectorSoftware/generator/inferAction.in.h Normal file
View File

@@ -0,0 +1,30 @@
#include "CmdParser.h"
#include <iostream>
#include <map>
#include <vector>
namespace sls {
class InferAction {
public:
InferAction() {}
int infer(sls::CmdParser &parser, std::ostream &os = std::cout);
std::vector<std::string> args;
std::string cmd;
// generated functions
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (1) - DO NOT REMOVE
// int frames();
private:
using FunctionMap = std::map<std::string, int (InferAction::*)()>;
FunctionMap functions{
// generated functions
// THIS COMMENT TO BE REPLACED BY THE ACTUAL CODE (2) - DO NOT REMOVE
// {"frames",&InferAction::frames}
};
};
} // namespace sls

64
slsDetectorSoftware/generator/infer_action/check_infer.py Normal file
View File

@@ -0,0 +1,64 @@
from pathlib import Path
import argparse
import yaml
def check_infer(EXTENDED_COMMANDS_PATH=Path(__file__).parent.parent / "extended_commands.yaml", commands=None):
if commands is None:
# load yaml file
with EXTENDED_COMMANDS_PATH.open('r') as f:
commands = yaml.safe_load(f)
type_distinguishable = {}
non_distinguishable = {}
for command_name, command in commands.items():
# todo: remove this (added for debug)
# if command_name != 'badchannels':
# continue
if len(command["actions"]) == 1:
action = list(command["actions"].items())[0][1]
for arg in action['args']:
if arg['argc'] == -1:
non_distinguishable[(command_name, arg['argc'])] = ([], arg['arg_types'])
continue
get_argcs = {}
get_args = command['actions']['GET']['args']
for arg in get_args:
if arg['argc'] != -1:
get_argcs[arg["argc"]] = arg['arg_types']
else:
non_distinguishable[(command_name, arg['argc'])] = ([], arg['arg_types'])
put_args = command['actions']['PUT']['args']
for arg in put_args:
if arg['argc'] == -1:
non_distinguishable[(command_name, arg['argc'])] = ([], arg['arg_types'])
elif arg['argc'] in get_argcs:
if arg['arg_types'] != get_argcs[arg['argc']]:
type_distinguishable[(command_name, arg['argc'])] = (get_argcs[arg['argc']], arg['arg_types'])
else:
non_distinguishable[(command_name, arg['argc'])] = (get_argcs[arg['argc']], arg['arg_types'])
return type_distinguishable, non_distinguishable
if __name__ == "__main__":
argparse = argparse.ArgumentParser()
argparse.add_argument("--print", choices=['all', 'type', 'impossible'], default="all", help="command name")
args = argparse.parse_args()
type_distinguishable, non_distinguishable = check_infer()
if args.print == 'type' or args.print == 'all':
print("type distinguishable:")
print("command_name: argc get_arg_type put_arg_type\n")
for (command_name, argc), (get_arg_types, put_arg_types) in type_distinguishable.items():
print(f"{command_name}: {argc} {get_arg_types} {put_arg_types}")
if args.print == 'impossible' or args.print == 'all':
print("\n\nimpossible to distinguish:")
print("command_name: argc get_arg_type put_arg_type")
for (command_name, argc), (get_arg_types, put_arg_types) in non_distinguishable.items():
print(f"{command_name}: {argc} {get_arg_types} {put_arg_types}")

288
slsDetectorSoftware/generator/readme.md Normal file
View File

@@ -0,0 +1,288 @@
# Generator
used to generate C++ cli commands. and bash autocompletion scripts.
## Autocomplete
### Overview
Looks through the `dump.json` file for the different values of an enum and stores them in the dictionary `type_values`.
```sh
# To print the different values for enums
python gen_commands.py -a
```
also the autocomplete.py generates shell autocompletion scripts for both bash and zsh. It uses the template file `bash_autocomplete.in.sh` and adds the necessary code in an output file `bash_autocomplete.sh` (same for zsh).
To use the bash autocompletion the `bash_autocomplete.sh` must be sourced.
```sh
source bash_autocomplete.sh
# g <Tab><Tab> will give the list of all commands
# p 0:<Tab><Tab> will also give the list of all commands
# g exp<Tab> will autocomplete to g exptime
# g exptime <Tab><Tab> will return "s ms us ns"
# p timing <Tab><Tab> will return "auto,burst_trigger,gating..."
```
**Note:**
The dump.json is the AST of the file `slsDetectorPackage/slsSupportLib/src/ToString.cpp`.
```sh
# to generate the dump.json file
cd slsSupportLib/src
clang++ -Xclang -ast-dump=json -Xclang -ast-dump-filter -Xclang StringTo -c ToString.cpp -I ../include/ -std=gnu++11 > ../../slsDetectorSoftware/generator/autocomplete/dump.json
# clang version used: 14.0.0-1ubuntu1.1
```
the `dump.json` file produced by clang is not a correct json file because we used the `-ast-dump-filter`. autocomplete.py can be used to fix the format of `dump.json` and produce a new file called `fixed.json` that is json format.
```
# to convert dump.json into correct json format.
python autocomplete.py -f # produces/updates the file fixed.json
```
### Code components
- `type_values` is a dictionary that contains the different values for commands args. It is populated with enum values that stard with defs:: or slsDetectorDefs:: (eg. defs::burstMode). Also it contains values added manually such as "mv,mV" and those start with special::
- `generate_type_values` parses the AST file to find the part that contains if statements. and extracts the different possible values for an enum.
- `generate_bash_autocomplete` generates autocompletion scripts for bash or zsh. the difference between zsh and bash scripts can be found in the template files. (bash handles 0:<Tab><Tab> completion differently than zsh more details can be found in the comments of the template files )
- `fix_json` fixes the file 'autocomplete/dump.json' and outputs a new corrected file in 'autocomplete/fixed.json'
## Command Parser
Definitely the most important component of all the generator module.
command_parser exist to keep the commands.yaml file concise and easy to read and produce a complete version of the commands.yaml for the code generator to work on.
The goal is that the code generator works on a version of commands.yaml that is easy to iterate over and generate code.
```
# complete version
some_command:
help: "do this"
infer_action: true
actions:
GET:
args:
- argc: 0
function: "getCommand"
...
- argc: 1
function: "getCommand"
...
detectors:
MYTHEN3:
- argc: 0
function: "getCommandMythen"
...
PUT:
args:
- argc: 2
function: "setCommand"
...
- argc: 3
function: "setCommand"
...
```
the complete vesion can only have `args` or `detectors` field inside an action (GET or PUT). **Each element in the args array have a different argc**. and in each element in the args array we can find all the information needed to generate the code for that one argc case. for example in the code `if(action == 'GET')` and `if (args.size() == 1)` then we can generate the code for that one case independetly.
commands.yaml has a lot on ~inheritance~. examples show best what it is:
> fields insides an action will be passed to args and detectors
> the extended args for default actions will be used for detectors
> any field can be overriden
```
resetdacs:
help: "[(optional) hard] ..."
actions:
PUT:
function: resetToDefaultDacs
require_det_id: true
output: [ '"successful"' ]
input_types: [ bool ]
args:
- argc: 1
arg_types: [ special::hard ]
input: [ '"1"' ]
- argc: 0
input: [ '"0"' ]
# this will be converted to
resetdacs:
actions:
PUT:
args:
- arg_types:
- special::hard
argc: 1
cast_input:
- false
check_det_id: false
convert_det_id: true
function: resetToDefaultDacs
input:
- '"1"'
input_types:
- bool
output:
- '"successful"'
require_det_id: true
store_result_in_t: false
- arg_types: []
argc: 0
cast_input:
- false
check_det_id: false
convert_det_id: true
function: resetToDefaultDacs
input:
- '"0"'
input_types:
- bool
output:
- '"successful"'
require_det_id: true
store_result_in_t: false
command_name: resetdacs
function_alias: resetdacs
help: "[(optional) hard] ..."
infer_action: true
```
command_parser does not have a specific schema for the commands.yaml this is by design so it can be very extensible and future-proof. This also can have problems when there is typos (writing intput instead of input...)
command_parser first verifies the commands.yaml and checks if there's some obvious problems in it.
templates found in commands.yaml were taken from the CmdProxy code they were added for debugging purposes when writing the generator.
tricky things:
--
- if input array has n elements and cast_input array is empty. command_parser will fill it with n false values.
- store_result_in_t will be added by default as true to GET action. but as false to PUT action. (unless it is written in the action)
- infer_action by default is true
- commands that have is_description true won't be verified
- function_alias is the name of the function in the c++ code. by default it is the command name. errors came up with the command virtual as virtual is a reserved keyword in c++
- command_name is the string of the command that will be typed in cli. (frames, exptime, ...). by default it is the command name. pattern is a special keyword in yaml. problems came up with the command pattern
- arg_types is by default input_types unless otherwise specified
- when the parent has specific detector behaviour and the child does not. writing an empty detector section in the action would not inherit any detector specific fields (check exptime1)
- commands can inherit other commands (check exptime1 and exptime2)
- argc: -1 means that the command has an unknown number of arguments
### Code Walkthrough
the code is well commented it is well explained in the script
### Tests
tests for command_parser can be found in `generator/tests/command_parser/`
```
pip install -r requirements.txt
python -m pytests
```
verification is not well tested
## codegen
Now for C++ code generation. After parsing the commands.yaml file and producing the extended_commands.yaml `gen_commands.py` will iterate over the commands and generate `Caller.h`, `Caller.cpp`, `inferAction.cpp` and `inferAction.h` .
### infer action
the generated code will produce 5 new targets: "sls_detector_get sls_detector_put sls_detector_acquire sls_detector_help sls_detector"
`sls_detector_get` will set the action as GET
`sls_detector_put` will the action as PUT
`sls_detector` will guess the action depending on the number of arguments
the codegen module will generate a function for every command that will return the action based on the number of arguments
```cpp
int InferAction::activate() {
if (args.size() == 0) {
return slsDetectorDefs::GET_ACTION;
}
if (args.size() == 1) {
return slsDetectorDefs::PUT_ACTION;
} else {
throw RuntimeError("Could not infer action: Wrong number of arguments");
}
}
```
the `inferAction` class will be called from `CmdApp.cpp` to infer the action and the command function will be called with the appropriate action.
some commands have the same number of argument count for both get and put. These commands can be found using the the `check_infer.py` script. in the generated code it will say that "sls_detector is disabled"
```bash
# to see these commands
python infer_action/check_infer.py
```
### Caller.cpp code
in this level we only use the extended_commands.yaml file.
the `generate()` function in `gen_commands.py` will iterate over all of the commands and :
- write the function signature
- write the help
- write c++ code to check the inputs: check argument count and check if we are able to convert the arguments into the required types
- iterate over actions and arguments
- iterate over the detectors and write code for each one of them (if mythen3 ... if eiger ... else default code... ) and call `codegen.write_arg()` to write the argument for a single argument
codegen.write_arg()
-
write_arg in codegen reads the argument fields and generate c++ code accordingly.
## fields explanations
- arg_types:[array of types] it is only used for autocompletion no C++ code is dependent on it
- is_description:[boolean] same as above
- template:[boolean] only used in commands.yaml and it won't present in extended_commands.yaml. it is inspired by the CmdProxy.h code
- help:[string] command help
- input:[array of variable names] the input arguments that will be passed to the function
- input_types:[array of types] the types of the input arguments given to the function
- cast_input:[array of boolean] if true it will cast the corresponding input to the type in input_types
- output:[array] outputs that will be printed (eg. ["123", "'a'"] will be os<<123<<'a')
- function: the function that will be called
- function_alias: the name of the function in the c++ code (more on it in tricky things)
- command_name: the string of the command that will be typed in cli. (more on it in tricky things)
- require_det_id: if true it will require a detector id to be passed as the last argument
- check_det_id: if true it will check the detector id and throw an error if it is not valid
- convert_det_id: if true it will convert the detector id to the correct type `std::vector<int>{ det_id }`
- store_result_in_t: if true it will store the result of the function in the variable t (more on it in tricky things)
- infer_action: if true it will infer the action (only if sls_detector is used)
- detectors: the detectors that have specific behaviour
- args: the arguments of the command
- argc: the number of arguments
- extra_variables[array]: each element takes three parameters: value, name, type and creates that variable in the beginning of the argument code
- exceptions[array]: each element takes two parameters: condition, message
- pattern_command: takes three arguments: nGetArgs, nPutArgs and command_name and it will write this code
```cpp
int level = -1, iArg = 0, nGetArgs = $nGetArgs$, nPutArgs = $nPutArgs$;
GetLevelAndUpdateArgIndex(action, $command_name$, level, iArg, nGetArgs,nPutArgs);
```
- separate_time_units: takes three parameters: input, output[0], output[1] each one is a variable name
```cpp
std::string tmp_time($input$);
std::string $output[1]$ = RemoveUnit(tmp_time);
auto $output[0]$ = StringTo<time::ns>(tmp_time, $output[1]$);
```
- convert_to_time: takes three parameters: input[0], input[1], output
```cpp
auto output = StringTo<time::ns>(input[0], input[1]);
```
- ctb_output_list: **maybe it should be removed?** takes 5 parameters: GETFCNLIST, GETFCNNAME, GETFCN, suffix, printable_name

6
slsDetectorSoftware/generator/requirements.txt Normal file
View File

@@ -0,0 +1,6 @@
coverage==7.3.1
iniconfig==2.0.0
packaging==23.1
pluggy==1.3.0
pytest==7.4.2
PyYAML==6.0.1

16
slsDetectorSoftware/generator/tests/command_parser/data/basic.yaml Normal file
View File

@@ -0,0 +1,16 @@
basic:
infer_action: false
help: "xx11"
actions:
GET:
function: 'func1'
output: [ OutString(t) ]
args:
- argc: 0
PUT:
function: 'func2'
output: [ 'args.front()' ]
input: [ 'args[0]' ]
input_types: [ int ]
cast_input: [ true ]
argc: 1

66
slsDetectorSoftware/generator/tests/command_parser/data/basic_inheritance.yaml Normal file
View File

@@ -0,0 +1,66 @@
---
template:
infer_action: false
help: ""
actions:
GET:
function: 'func1'
args:
- argc: 0
output: [ OutString(t) ]
PUT:
function: 'func2'
output: [ 'args.front()' ]
input: [ 'args[0]' ]
input_types: [ int ]
cast_input: [ true ]
argc: 1
basic:
help: "xx11"
inherit_actions: template
actions:
GET:
function: 'x'
argc: 2
args:
- check_det_id: true
template2:
infer_action: false
template: true
help: ""
actions:
GET:
convert_to_time:
input: [ 'args[0]', 'args[1]' ]
output: converted_time
separate_time_units:
input: 'args[0]'
output: [ converted_time, unit ]
function: 'func1'
output: [ OutString(t) ]
args:
- argc: 0
- argc: 99
PUT:
function: funcTemplatePUT
args:
- argc: 19
function: 'func19'
- argc: 91
basic2:
inherit_actions: template2
actions:
GET:
function: 'x'
argc: 2
args:
- check_det_id: true
input: [ 'args[0]', a,b,c ]
input_types: [ int, int, int, int ]
PUT:
function: 'y'

208
slsDetectorSoftware/generator/tests/command_parser/data/detectors.yaml Normal file
View File

@@ -0,0 +1,208 @@
basic:
infer_action: false
help: "xx11"
actions:
GET:
function: 'func1'
output: [ OutString(t) ]
args:
- argc: 0
- argc : 1
output: [ testytest ]
detectors:
MYTHEN3:
function: 'do_mythen3'
CHIPTESTBOARD:
args:
- argc: 55
output: [ ctbOutput ]
PUT:
detectors:
EIGER:
function: 'do_eiger'
argc: 99
output: [ eigerOutput ]
# classes of tests:
# classes of template tests: has args or has detectors => 4 cases noted (0,0) ... (1,1)
# classes of childs: has args or has detectors => 4 cases noted (0,0) ... (1,1)
# => 16 cases
# example: case_0111: template (0,1) and child (1,1)
#################### exhaustive testing over chosen classes of tests
template_01:
infer_action: true
help: "vv12"
template: true
actions:
GET:
detectors:
MYTHEN3:
function: 'do_mythen3'
argc: 99
CHIPTESTBOARD:
function: 'do_ctb'
argc: 98
case_0100:
inherit_actions: template_01
help: "0100"
case_0101:
inherit_actions: template_01
help: "0101"
actions:
GET:
function: 'get_function'
detectors:
MYTHEN3:
function: 'do_mythen23'
argc: 420
case_0110:
inherit_actions: template_01
help: "0110"
actions:
GET:
argc: 111
function: 'get_function'
case_0110v2:
inherit_actions: template_01
help: "0110v2"
actions:
GET:
args:
- argc: 111
function: 'get_function'
case_0111:
inherit_actions: template_01
help: "0111"
actions:
GET:
args:
- argc: 111
function: 'get_function'
detectors:
MYTHEN3:
function: 'do_mythen23'
argc: 420
##### cases 10** tests
template_10:
template: true
actions:
GET:
args:
- argc: 0
- argc : 1
output: [ testytest ]
case_1000:
inherit_actions: template_10
help: "1000"
case_1001:
inherit_actions: template_10
help: "1001"
actions:
GET:
detectors:
MYTHEN3:
args:
- function: 'do_mythen23'
argc: 420
- function: 'do_mythen3'
argc: 99
case_1010:
inherit_actions: template_10
help: "1010"
actions:
GET:
args:
- argc: 111
function: 'get_function'
case_1011:
inherit_actions: template_10
help: "1011"
actions:
GET:
args:
- argc: 111
function: 'get_function'
detectors:
MYTHEN3:
function: 'do_mythen23'
##### cases 11** tests
template_11:
template: true
actions:
GET:
args:
- argc: 0
- argc : 1
output: [ testytest ]
detectors:
EIGER:
function: 'do_eiger'
args:
- argc: 99
output: [ eigerOutput ]
POTATO:
function: 'do_potato'
case_1100:
inherit_actions: template_11
help: "1100"
case_1101:
inherit_actions: template_11
help: "1101"
actions:
GET:
detectors:
MYTHEN3:
function: 'do_mythen3'
POTATO:
function: 'do_potato'
args:
- argc: 101
function: 'potato_function'
- argc: 202
case_1110:
inherit_actions: template_11
help: "1110"
actions:
GET:
argc: 77
function: 'get_function'
case_1111:
inherit_actions: template_11
help: "1111"
actions:
GET:
argc: 77
function: 'get_function'
detectors:
MYTHEN3:
function: 'do_mythen3'
POTATO:
function: 'do_potato'
args:
- argc: 101
function: 'potato_function'
- argc: 202

101
slsDetectorSoftware/generator/tests/command_parser/functional_tests/test_commands_parser_basic.py Normal file
View File

@@ -0,0 +1,101 @@
from pathlib import Path
import yaml
from commands_parser.commands_parser import CommandParser
data_path = Path(__file__).parent.parent / "data"
def test_basic_propagation(tmp_path):
output_file = tmp_path / "basic.yaml"
command_parser = CommandParser(commands_file=data_path / "basic.yaml", output_file=output_file)
command_parser.verify_format()
command_parser.parse_all_commands()
assert output_file.exists()
command = yaml.unsafe_load(output_file.open('r'))['basic']
assert command['help'] == "xx11"
assert len(command['actions']) == 2
# test 'GET' action
assert 'args' in command['actions']['GET']
assert len(command['actions']['GET'].keys()) == 1 # only 'args' key
assert len(command['actions']['GET']['args']) == 1 # only one argument
assert command['actions']['GET']['args'][0]['argc'] == 0
assert command['actions']['GET']['args'][0]['function'] == 'func1'
assert command['actions']['GET']['args'][0]['output'] == ['OutString(t)']
assert command['actions']['GET']['args'][0]['input'] == []
assert command['actions']['GET']['args'][0]['cast_input'] == []
assert command['actions']['GET']['args'][0]['require_det_id'] is False
# test PUT action
assert 'args' in command['actions']['PUT']
assert len(command['actions']['PUT'].keys()) == 1 # only 'args' key
assert len(command['actions']['PUT']['args']) == 1 # only one argument
assert command['actions']['PUT']['args'][0]['argc'] == 1
assert command['actions']['PUT']['args'][0]['function'] == 'func2'
assert command['actions']['PUT']['args'][0]['cast_input'] == [True]
assert command['actions']['PUT']['args'][0]['output'] == ['args.front()']
assert command['actions']['PUT']['args'][0]['input_types'] == ['int']
assert command['actions']['PUT']['args'][0]['require_det_id'] is False
def test_basic_inheritance(tmp_path):
output_file = tmp_path / "basic_inheritance.yaml"
command_parser = CommandParser(commands_file=data_path / "basic_inheritance.yaml", output_file=output_file)
command_parser.verify_format()
command_parser.parse_all_commands()
assert output_file.exists()
command = yaml.unsafe_load(output_file.open('r'))['basic']
assert command['help'] == "xx11"
assert command['actions'].keys() == {'GET', 'PUT'}
# test 'GET' action
assert 'args' in command['actions']['GET']
assert command['actions']['GET'].keys() == {'args'} # only 'args' key
assert len(command['actions']['GET']['args']) == 1 # only one argument
assert command['actions']['GET']['args'][0]['argc'] == 2
assert command['actions']['GET']['args'][0]['function'] == 'x'
assert command['actions']['GET']['args'][0]['output'] == [] # test overwriting args when they are present in child
assert command['actions']['GET']['args'][0]['input'] == []
assert command['actions']['GET']['args'][0]['cast_input'] == []
assert command['actions']['GET']['args'][0]['require_det_id'] is False
# test PUT action
assert 'args' in command['actions']['PUT']
assert command['actions']['PUT'].keys() == {'args'} # only 'args' key
assert len(command['actions']['PUT']['args']) == 1 # only one argument
assert command['actions']['PUT']['args'][0]['argc'] == 1
assert command['actions']['PUT']['args'][0]['function'] == 'func2'
assert command['actions']['PUT']['args'][0]['cast_input'] == [True]
assert command['actions']['PUT']['args'][0]['output'] == ['args.front()']
assert command['actions']['PUT']['args'][0]['input_types'] == ['int']
assert command['actions']['PUT']['args'][0]['require_det_id'] is False
def test_basic_inheritance2(tmp_path):
output_file = tmp_path / "basic_inheritance.yaml"
command_parser = CommandParser(commands_file=data_path / "basic_inheritance.yaml", output_file=output_file)
command_parser.verify_format()
command_parser.parse_all_commands()
assert output_file.exists()
command = yaml.unsafe_load(output_file.open('r'))['basic2']
# check GET
assert len(command['actions']['GET']['args']) == 1
assert command['actions']['GET'].keys() == {'args'}
arg = command['actions']['GET']['args'][0]
assert arg['argc'] == 2
assert arg['output'] == ['OutString(t)']
# check that length of cast input is equal to length of input_types and input
assert len(arg['input']) == len(arg['input_types']) == len(arg['cast_input']) == 4
assert arg['function'] == 'x'
assert 'convert_to_time' in arg
assert arg['convert_to_time'].keys() == {'input', 'output'}
assert 'separate_time_units' in arg
assert arg['separate_time_units'].keys() == {'input', 'output'}
# check PUT
assert command['actions']['PUT'].keys() == {'args'}
assert len(command['actions']['PUT']['args']) == 2
assert command['actions']['PUT']['args'][0]['argc'] == 19
assert command['actions']['PUT']['args'][0]['function'] == 'y'
assert command['actions']['PUT']['args'][1]['argc'] == 91
assert command['actions']['PUT']['args'][1]['function'] == 'y'

309
slsDetectorSoftware/generator/tests/command_parser/functional_tests/test_commands_parser_detector.py Normal file
View File

@@ -0,0 +1,309 @@
import json
from pathlib import Path
import pytest as pytest
import yaml
from commands_parser.commands_parser import CommandParser
data_path = Path(__file__).parent.parent / "data"
@pytest.fixture()
def detector_file_commands(tmp_path):
output_file = tmp_path / "detectors.yaml"
command_parser = CommandParser(commands_file=data_path / "detectors.yaml", output_file=output_file)
command_parser.verify_format()
def func(command):
return command_parser.parse_command(command)
return func
def test_basic_propagation(tmp_path, detector_file_commands):
command = detector_file_commands('basic')
assert command['help'] == "xx11"
# GET
assert command['actions']['GET'].keys() == {'detectors', 'args'}
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3', 'CHIPTESTBOARD'}
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 2
assert mythen[0]['argc'] == 0
assert mythen[1]['argc'] == 1
assert mythen[0]['function'] == mythen[1]['function'] == 'do_mythen3'
assert mythen[0]['output'] == ['OutString(t)']
assert mythen[1]['output'] == ['testytest']
ctb = command['actions']['GET']['detectors']['CHIPTESTBOARD']
assert len(ctb) == 1
assert ctb[0]['argc'] == 55
assert ctb[0]['function'] == 'func1'
# PUT
assert command['actions']['PUT'].keys() == {'detectors'}
assert command['actions']['PUT']['detectors'].keys() == {'EIGER'}
eiger = command['actions']['PUT']['detectors']['EIGER']
assert len(eiger) == 1
assert eiger[0]['argc'] == 99
assert eiger[0]['function'] == 'do_eiger'
assert eiger[0]['output'] == ['eigerOutput']
# 16 test cases for inheritance
# 1st bit: parent has args
# 2nd bit: parent has detectors
# 3rd bit: child has args
# 4th bit: child has detectors
# each test case is a combination of the above bits
# all the possible combinations are tested
def test_inheritance_0100(tmp_path, detector_file_commands):
command = detector_file_commands('case_0100')
assert command['help'] == "0100"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'detectors'}
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3', 'CHIPTESTBOARD'}
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 1
assert mythen[0]['argc'] == 99
assert mythen[0]['function'] == 'do_mythen3'
def test_inheritance_0101(tmp_path, detector_file_commands):
command = detector_file_commands('case_0101')
assert command['help'] == "0101"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'detectors'}
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3', 'CHIPTESTBOARD'}
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 1
assert mythen[0]['argc'] == 420
assert mythen[0]['function'] == 'do_mythen23'
ctb = command['actions']['GET']['detectors']['CHIPTESTBOARD']
assert len(ctb) == 1
assert ctb[0]['argc'] == 98
assert ctb[0]['function'] == 'do_ctb'
def test_inheritance_0110(tmp_path, detector_file_commands):
command = detector_file_commands('case_0110')
assert command['help'] == "0110"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert command['actions']['GET']['args'][0]['argc'] == 111
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 1
assert mythen[0]['argc'] == 99
assert mythen[0]['function'] == 'do_mythen3'
ctb = command['actions']['GET']['detectors']['CHIPTESTBOARD']
assert len(ctb) == 1
assert ctb[0]['argc'] == 98
assert ctb[0]['function'] == 'do_ctb'
def test_inheritance_0110v2(tmp_path, detector_file_commands):
command = detector_file_commands('case_0110v2')
assert command['help'] == "0110v2"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert command['actions']['GET']['args'][0]['argc'] == 111
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 1
assert mythen[0]['argc'] == 99
assert mythen[0]['function'] == 'do_mythen3'
ctb = command['actions']['GET']['detectors']['CHIPTESTBOARD']
assert len(ctb) == 1
assert ctb[0]['argc'] == 98
assert ctb[0]['function'] == 'do_ctb'
def test_inheritacnce_0111(tmp_path, detector_file_commands):
command = detector_file_commands('case_0111')
assert command['help'] == "0111"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3', 'CHIPTESTBOARD'}
mythen = command['actions']['GET']['detectors']['MYTHEN3']
assert len(mythen) == 1
assert command['actions']['GET']['args'][0]['argc'] == 111
assert len(mythen) == 1
assert mythen[0]['argc'] == 420
assert mythen[0]['function'] == 'do_mythen23'
ctb = command['actions']['GET']['detectors']['CHIPTESTBOARD']
assert len(ctb) == 1
assert ctb[0]['argc'] == 98
assert ctb[0]['function'] == 'do_ctb'
# cases 1000, 1001, 1010, 1011
def test_inheritance_1000(tmp_path, detector_file_commands):
command = detector_file_commands('case_1000')
assert command['help'] == "1000"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args'}
assert len(command['actions']['GET']['args']) == 2
assert command['actions']['GET']['args'][0]['argc'] == 0
assert command['actions']['GET']['args'][0]['output'] == []
assert command['actions']['GET']['args'][1]['argc'] == 1
assert command['actions']['GET']['args'][1]['output'] == ['testytest']
def test_inheritance_1001(tmp_path, detector_file_commands):
command = detector_file_commands('case_1001')
assert command['help'] == "1001"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 2
assert command['actions']['GET']['args'][0]['argc'] == 0
assert command['actions']['GET']['args'][0]['output'] == []
assert command['actions']['GET']['args'][1]['argc'] == 1
assert command['actions']['GET']['args'][1]['output'] == ['testytest']
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3'}
assert len(command['actions']['GET']['detectors']['MYTHEN3']) == 2
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['argc'] == 420
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['function'] == 'do_mythen23'
assert command['actions']['GET']['detectors']['MYTHEN3'][1]['argc'] == 99
assert command['actions']['GET']['detectors']['MYTHEN3'][1]['function'] == 'do_mythen3'
def test_inheritance_1010(tmp_path, detector_file_commands):
command = detector_file_commands('case_1010')
assert command['help'] == "1010"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args'}
assert len(command['actions']['GET']['args']) == 1
assert command['actions']['GET']['args'][0]['argc'] == 111
assert command['actions']['GET']['args'][0]['function'] == 'get_function'
def test_inheritance_1011(tmp_path, detector_file_commands):
command = detector_file_commands('case_1011')
assert command['help'] == "1011"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 1
assert command['actions']['GET']['args'][0]['argc'] == 111
assert command['actions']['GET']['args'][0]['function'] == 'get_function'
assert command['actions']['GET']['detectors'].keys() == {'MYTHEN3'}
assert len(command['actions']['GET']['detectors']['MYTHEN3']) == 1
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['argc'] == 111
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['function'] == 'do_mythen23'
# cases 1100, 1101, 1110, 1111
def test_inheritance_1100(tmp_path, detector_file_commands):
command = detector_file_commands('case_1100')
assert command['help'] == "1100"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 2
assert command['actions']['GET']['args'][0]['argc'] == 0
assert command['actions']['GET']['args'][0]['output'] == []
assert command['actions']['GET']['args'][1]['argc'] == 1
assert command['actions']['GET']['args'][1]['output'] == ['testytest']
assert command['actions']['GET']['detectors'].keys() == {'EIGER', 'POTATO'}
assert len(command['actions']['GET']['detectors']['EIGER']) == 1
assert command['actions']['GET']['detectors']['EIGER'][0]['argc'] == 99
assert command['actions']['GET']['detectors']['EIGER'][0]['function'] == 'do_eiger'
assert command['actions']['GET']['detectors']['EIGER'][0]['output'] == ['eigerOutput']
assert len(command['actions']['GET']['detectors']['POTATO']) == 2
assert command['actions']['GET']['detectors']['POTATO'][0]['argc'] == 0
assert command['actions']['GET']['detectors']['POTATO'][0]['function'] == 'do_potato'
def test_inheritance_1101(tmp_path, detector_file_commands):
command = detector_file_commands('case_1101')
assert command['help'] == "1101"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 2
assert command['actions']['GET']['args'][0]['argc'] == 0
assert command['actions']['GET']['args'][0]['output'] == []
assert command['actions']['GET']['args'][1]['argc'] == 1
assert command['actions']['GET']['args'][1]['output'] == ['testytest']
assert command['actions']['GET']['detectors'].keys() == {'EIGER', 'MYTHEN3', 'POTATO'}
assert len(command['actions']['GET']['detectors']['MYTHEN3']) == 2
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['argc'] == 0
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['function'] == 'do_mythen3'
assert command['actions']['GET']['detectors']['MYTHEN3'][1]['argc'] == 1
assert command['actions']['GET']['detectors']['MYTHEN3'][1]['function'] == 'do_mythen3'
assert len(command['actions']['GET']['detectors']['EIGER']) == 1
assert command['actions']['GET']['detectors']['EIGER'][0]['argc'] == 99
assert command['actions']['GET']['detectors']['EIGER'][0]['function'] == 'do_eiger'
assert command['actions']['GET']['detectors']['EIGER'][0]['output'] == ['eigerOutput']
assert len(command['actions']['GET']['detectors']['POTATO']) == 2
assert command['actions']['GET']['detectors']['POTATO'][0]['argc'] == 101
assert command['actions']['GET']['detectors']['POTATO'][0]['function'] == 'potato_function'
assert command['actions']['GET']['detectors']['POTATO'][1]['argc'] == 202
assert command['actions']['GET']['detectors']['POTATO'][1]['function'] == 'do_potato'
def test_inheritance_1110(tmp_path, detector_file_commands):
command = detector_file_commands('case_1110')
assert command['help'] == "1110"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 1
assert command['actions']['GET']['args'][0]['argc'] == 77
assert command['actions']['GET']['args'][0]['function'] == 'get_function'
assert command['actions']['GET']['detectors'].keys() == {'EIGER', 'POTATO'}
assert len(command['actions']['GET']['detectors']['EIGER']) == 1
assert command['actions']['GET']['detectors']['EIGER'][0]['argc'] == 99
assert command['actions']['GET']['detectors']['EIGER'][0]['function'] == 'do_eiger'
assert len(command['actions']['GET']['detectors']['POTATO']) == 2
assert command['actions']['GET']['detectors']['POTATO'][0]['argc'] == 0
assert command['actions']['GET']['detectors']['POTATO'][0]['function'] == 'do_potato'
assert command['actions']['GET']['detectors']['POTATO'][1]['argc'] == 1
assert command['actions']['GET']['detectors']['POTATO'][1]['function'] == 'do_potato'
def test_inheritance_1111(tmp_path, detector_file_commands):
command = detector_file_commands('case_1111')
assert command['help'] == "1111"
assert 'actions' in command
assert command['actions'].keys() == {'GET'}
assert command['actions']['GET'].keys() == {'args', 'detectors'}
assert len(command['actions']['GET']['args']) == 1
assert command['actions']['GET']['args'][0]['argc'] == 77
assert command['actions']['GET']['args'][0]['function'] == 'get_function'
assert command['actions']['GET']['detectors'].keys() == {'EIGER', 'MYTHEN3', 'POTATO'}
assert len(command['actions']['GET']['detectors']['MYTHEN3']) == 1
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['argc'] == 77
assert command['actions']['GET']['detectors']['MYTHEN3'][0]['function'] == 'do_mythen3'
assert len(command['actions']['GET']['detectors']['EIGER']) == 1
assert command['actions']['GET']['detectors']['EIGER'][0]['argc'] == 99
assert command['actions']['GET']['detectors']['EIGER'][0]['function'] == 'do_eiger'
assert len(command['actions']['GET']['detectors']['POTATO']) == 2
assert command['actions']['GET']['detectors']['POTATO'][0]['argc'] == 101
assert command['actions']['GET']['detectors']['POTATO'][0]['function'] == 'potato_function'
assert command['actions']['GET']['detectors']['POTATO'][1]['argc'] == 202
assert command['actions']['GET']['detectors']['POTATO'][1]['function'] == 'do_potato'

29
slsDetectorSoftware/generator/tests/test_parse_and_generate.py Normal file
View File

@@ -0,0 +1,29 @@
from pathlib import Path
from commands_parser.commands_parser import CommandParser
import gen_commands
data_path = Path(__file__).parent.parent
def test_parse_and_generate(tmp_path):
"""
tests that the parse and generate functions work without errors
:param tmp_path:
:return:
"""
output_file = tmp_path / "detectors.yaml"
command_parser = CommandParser(commands_file=data_path / "commands.yaml", output_file=output_file)
command_parser.verify_format()
command_parser.parse_all_commands()
assert output_file.exists()
GEN_PATH = Path(__file__).parent.parent
gen_commands.generate(
output_file,
GEN_PATH / "Caller.in.cpp",
GEN_PATH / "Caller.in.h",
tmp_path / "Caller.cpp",
tmp_path / "Caller.h",
)
assert (tmp_path / "Caller.cpp").exists()
assert (tmp_path / "Caller.h").exists()

28
slsDetectorSoftware/generator/very_special_functions.txt Normal file
View File

@@ -0,0 +1,28 @@
hostname (find +)
acquire
versions (maybe with few tweaks)
threshold (+++++)
trimen (maybe with few tweaks)
badchannels (somewhat special)
currentsource (special)
dacvalues (can be done with the ctb_output_list)
udp_srcip (could be done if I add condition functionality for logging)
udp_srcip2 (same as above)
udp_dstip (same as above)
udp_dstip2
rx_hostname (split('+'))
rx_roi (can be done if there;s condition support?)
ratecorr (can be done if there's condition support?)
burstmode (very special)
vetostream
counters
gaincaps (has for loop and condition)
samples (ask Dhanya if it is okay to change the order of calling the ctb functions in PUT)
slowadc (has for loop)
rx_dbitlist (very special)
rx_jsonaddheader (very special)
execcommand (has for loop)
thresholdnotb
# notes
# ReceiverStatus error on put is not done
# ask about burstmode function

258
slsDetectorSoftware/include/sls/Detector.h
View File

@@ -20,7 +20,7 @@ class IpAddr;
// Free function to avoid dependence on class
// and avoid the option to free another objects
// shm by mistake
void freeSharedMemory(int detectorIndex, int moduleIndex = -1);
void freeSharedMemory(const int detectorIndex = 0, const int moduleIndex = -1);
/**
* \class Detector
@@ -46,9 +46,13 @@ class Detector {
Detector(int shm_id = 0);
~Detector();
/** Free the shared memory of this detector and all modules
belonging to it */
void freeSharedMemory();
// Disable copy since SharedMemory object is unique in DetectorImpl
Detector(const Detector &other) = delete;
Detector &operator=(const Detector &other) = delete;
// Move constructor and assignment operator
Detector(Detector &&other) noexcept;
Detector &operator=(Detector &&other) noexcept;
/** Frees shared memory before loading configuration file. Set up once
normally */
@@ -71,7 +75,6 @@ class Detector {
/** Gets shared memory ID */
int getShmId() const;
/** package git branch */
std::string getPackageVersion() const;
std::string getClientVersion() const;
@@ -99,7 +102,7 @@ class Detector {
Result<std::string> getReceiverVersion(Positions pos = {}) const;
/** Options: EIGER, JUNGFRAU, GOTTHARD, MOENCH, MYTHEN3, GOTTHARD2,
* CHIPTESTBOARD */
* CHIPTESTBOARD, XILINX_CHIPTESTBOARD */
Result<defs::detectorType> getDetectorType(Positions pos = {}) const;
/** Gets the total number of modules in shared memory */
@@ -304,11 +307,11 @@ class Detector {
void setNumberOfTriggers(int64_t value);
/** [Gotthard][Jungfrau][Moench][Eiger][CTB][Gotthard2] \n
/** [Gotthard][Jungfrau][Moench][Eiger][CTB][Xilinx CTB][Gotthard2] \n
* [Mythen3] use function with gate index **/
Result<ns> getExptime(Positions pos = {}) const;
/** [Gotthard][Jungfrau][Moench][Eiger][CTB][Gotthard2] \n
/** [Gotthard][Jungfrau][Moench][Eiger][CTB][Xilinx CTB][Gotthard2] \n
* [Mythen3] sets exptime for all gate signals. To specify gate index, use
* function with gate index **/
void setExptime(ns t, Positions pos = {});
@@ -317,25 +320,25 @@ class Detector {
void setPeriod(ns t, Positions pos = {});
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2] */
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2][Xilinx CTB] */
Result<ns> getDelayAfterTrigger(Positions pos = {}) const;
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2] */
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2][Xilinx CTB] */
void setDelayAfterTrigger(ns value, Positions pos = {});
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3]
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Xilinx CTB]
* [Gotthard2] only in continuous auto mode */
Result<int64_t> getNumberOfFramesLeft(Positions pos = {}) const;
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3]
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Xilinx CTB]
* Only when external trigger used */
Result<int64_t> getNumberOfTriggersLeft(Positions pos = {}) const;
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2]
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Gotthard2][Xilinx CTB]
* [Gotthard2] only in continuous mode */
Result<ns> getPeriodLeft(Positions pos = {}) const;
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3]
/** [Gotthard][Jungfrau][Moench][CTB][Mythen3][Xilinx CTB]
* [Gotthard2] only in continuous mode */
Result<ns> getDelayAfterTriggerLeft(Positions pos = {}) const;
@@ -344,7 +347,7 @@ class Detector {
/**
* [Eiger] Options: 4, 8, 12, 16, 32. If i is 32, also sets clkdivider to 2,
* else sets clkdivider to 1 \n [Mythen3] Options: 8, 16, 32 \n
* [Jungfrau][Moench][Gotthard][Ctb][Mythen3][Gotthard2] 16
* [Jungfrau][Moench][Gotthard][CTB][Mythen3][Gotthard2][Xilinx CTB] 16
*/
void setDynamicRange(int value);
@@ -354,21 +357,21 @@ class Detector {
Result<defs::timingMode> getTimingMode(Positions pos = {}) const;
/**
* [Gotthard][Jungfrau][Moench][Gotthard][CTB][Gotthard2] Options:
* AUTO_TIMING, TRIGGER_EXPOSURE \n
* [Mythen3] Options: AUTO_TIMING, TRIGGER_EXPOSURE, GATED, TRIGGER_GATED \n
* [Eiger] Options: AUTO_TIMING, TRIGGER_EXPOSURE, GATED, BURST_TRIGGER
* [Gotthard][Jungfrau][Moench][Gotthard][CTB][Gotthard2][Xilinx CTB]
* Options: AUTO_TIMING, TRIGGER_EXPOSURE \n [Mythen3] Options: AUTO_TIMING,
* TRIGGER_EXPOSURE, GATED, TRIGGER_GATED \n [Eiger] Options: AUTO_TIMING,
* TRIGGER_EXPOSURE, GATED, BURST_TRIGGER
*/
void setTimingMode(defs::timingMode value, Positions pos = {});
/** list of possible timing modes for this detector */
std::vector<defs::timingMode> getTimingModeList() const;
/** [Eiger][Jungfrau][Moench][Gotthard2] */
/** [Eiger][Jungfrau][Moench][Gotthard2][Mythen3] */
Result<defs::speedLevel> getReadoutSpeed(Positions pos = {}) const;
/** [Eiger][Jungfrau][Moench][Gotthard2]
* [Jungfrau] Options: FULL_SPEED, HALF_SPEED (Default),
* [Jungfrau][Mythen3] Options: FULL_SPEED, HALF_SPEED (Default),
* QUARTER_SPEED \n [Moench] Options: FULL_SPEED (Default) \n [Eiger]
* Options: FULL_SPEED (Default), HALF_SPEED, QUARTER_SPEED \n [Gotthard2]
* Options: G2_108MHZ (Default), G2_144MHZ \n [Jungfrau][Moench] FULL_SPEED
@@ -430,7 +433,8 @@ class Detector {
/** [Mythen3][Gotthard2] */
Result<int> getClockPhase(int clkIndex, Positions pos = {});
/** [Mythen3][Gotthard2] absolute phase shift */
/** [Mythen3][Gotthard2] absolute phase shift \n
* [Gotthard2] clkIndex: 0-5, [Mythen3] clkIndex 0 only */
void setClockPhase(int clkIndex, int value, Positions pos = {});
/** [Mythen3][Gotthard2] */
@@ -439,13 +443,15 @@ class Detector {
/** [Mythen3][Gotthard2] */
Result<int> getClockPhaseinDegrees(int clkIndex, Positions pos = {});
/** [Mythen3][Gotthard2] */
/** [Mythen3][Gotthard2] \n
* [Gotthard2] clkIndex: 0-5, [Mythen3] clkIndex 0 only */
void setClockPhaseinDegrees(int clkIndex, int value, Positions pos = {});
/** [Mythen3][Gotthard2] */
Result<int> getClockDivider(int clkIndex, Positions pos = {});
/** [Mythen3][Gotthard2] Must be greater than 1. */
/** [Mythen3][Gotthard2] Must be greater than 1. \n
* [Gotthard2] clkIndex: 0-5, [Mythen3] clkIndex 0 only */
void setClockDivider(int clkIndex, int value, Positions pos = {});
Result<int> getHighVoltage(Positions pos = {}) const;
@@ -457,16 +463,17 @@ class Detector {
*/
void setHighVoltage(int value, Positions pos = {});
/** [Jungfrau][Moench][Mythen3][Gotthard2] */
/** [Jungfrau][Moench][Mythen3][Gotthard2][Xilinx Ctb] */
Result<bool> getPowerChip(Positions pos = {}) const;
/** [Jungfrau][Moench][Mythen3][Gotthard2] Power the chip. \n
/** [Jungfrau][Moench][Mythen3][Gotthard2][Xilinx Ctb] Power the chip. \n
* Default is disabled. \n
* [Jungfrau][Moench] Default is disabled. Get will return power status. Can
* be off if temperature event occured (temperature over temp_threshold with
* temp_control enabled. Will configure chip (only chip v1.1)\n
* [Mythen3][Gotthard2] Default is 1. If module not connected or wrong
* module, powerchip will fail.
* module, powerchip will fail.\n
* [Xilinx CTB] Default is 0. Also configures chip if powered on.
*/
void setPowerChip(bool on, Positions pos = {});
@@ -484,7 +491,7 @@ class Detector {
/**
* (Degrees)
* [Mythen3][Gotthard2] Options: TEMPERATURE_FPGA
* [Mythen3][Gotthard2][Xilinx Ctb] Options: TEMPERATURE_FPGA
* [Gotthard] Options: TEMPERATURE_ADC, TEMPERATURE_FPGA \n
* [Jungfrau][Moench] Options: TEMPERATURE_ADC, TEMPERATURE_FPGA \n
* [Eiger] Options: TEMPERATURE_FPGA, TEMPERATURE_FPGAEXT, TEMPERATURE_10GE,
@@ -658,11 +665,13 @@ class Detector {
Result<std::vector<int64_t>>
getRxCurrentFrameIndex(Positions pos = {}) const;
/** [Eiger][Jungfrau][Moench][CTB] */
/** [Eiger][Jungfrau][Moench][CTB][Xilinx CTB][Gotthard2] */
Result<uint64_t> getNextFrameNumber(Positions pos = {}) const;
/** [Eiger][Jungfrau][Moench][CTB] Stopping acquisition might result in
* different frame numbers for different modules.*/
/** [Eiger][Jungfrau][Moench][CTB][Xilinx CTB][Gotthard2] Stopping
* acquisition might result in different frame numbers for different
* modules. So, after stopping, next frame number (max + 1) is set for all
* the modules afterwards.*/
void setNextFrameNumber(uint64_t value, Positions pos = {});
/** [Eiger][Mythen3][Jungfrau][Moench] Sends an internal software trigger to
@@ -1004,7 +1013,8 @@ class Detector {
Result<std::string> getFilePath(Positions pos = {}) const;
/** Default is "/"If path does not exist, it will try to create it */
/** Default is "/". If path does not exist and fwrite enabled, it will try
* to create it at start of acquisition. */
void setFilePath(const std::string &fpath, Positions pos = {});
Result<std::string> getFileNamePrefix(Positions pos = {}) const;
@@ -1025,7 +1035,7 @@ class Detector {
Result<bool> getFileWrite(Positions pos = {}) const;
/** default enabled */
/** default disabled */
void setFileWrite(bool value, Positions pos = {});
bool getMasterFileWrite() const;
@@ -1103,14 +1113,6 @@ class Detector {
*/
void setRxZmqPort(uint16_t port, int module_id = -1);
Result<IpAddr> getRxZmqIP(Positions pos = {}) const;
/** Zmq Ip Address from which data is to be streamed out of the receiver. \n
* Also restarts receiver zmq streaming if enabled. \n Default is from
* rx_hostname. \n Modified only when using an intermediate process between
* receiver. */
void setRxZmqIP(const IpAddr ip, Positions pos = {});
Result<uint16_t> getClientZmqPort(Positions pos = {}) const;
/** Port number to listen to zmq data streamed out from receiver or
@@ -1376,6 +1378,20 @@ class Detector {
void setPedestalMode(const defs::pedestalParameters par,
Positions pos = {});
/** [Jungfrau] */
Result<defs::timingInfoDecoder>
getTimingInfoDecoder(Positions pos = {}) const;
/** [Jungfrau] Advanced Command! */
void setTimingInfoDecoder(defs::timingInfoDecoder value,
Positions pos = {});
/** [Jungfrau] */
Result<defs::collectionMode> getCollectionMode(Positions pos = {}) const;
/** [Jungfrau] */
void setCollectionMode(defs::collectionMode value, Positions pos = {});
///@}
/** @name Gotthard Specific */
@@ -1608,7 +1624,7 @@ class Detector {
///@{
/**************************************************
* *
* CTB Specific *
* CTB / Xilinx CTB Specific *
* *
* ************************************************/
/** [CTB] */
@@ -1638,12 +1654,12 @@ class Detector {
/** gets list of slow adc enums */
std::vector<defs::dacIndex> getSlowADCList() const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
Result<int> getPower(defs::dacIndex index, Positions pos = {}) const;
/**
* [CTB] mV
* [Ctb] Options: V_LIMIT, V_POWER_A, V_POWER_B, V_POWER_C,
* [CTB][Xilinx CTB] mV
* [Ctb][Xilinx CTB] Options: V_LIMIT, V_POWER_A, V_POWER_B, V_POWER_C,
* V_POWER_D, V_POWER_IO, V_POWER_CHIP
*/
void setPower(defs::dacIndex index, int value, Positions pos = {});
@@ -1669,39 +1685,30 @@ class Detector {
"complete 4 bits are enabled */
void setTenGigaADCEnableMask(uint32_t mask, Positions pos = {});
/** [CTB] */
/** [CTB][Xilinx CTB] */
Result<uint32_t> getTransceiverEnableMask(Positions pos = {}) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setTransceiverEnableMask(uint32_t mask, Positions pos = {});
///@}
/** @name CTB Specific */
///@{
/**************************************************
* *
* CTB Specific *
* *
* ************************************************/
/** [CTB] */
Result<int> getNumberOfDigitalSamples(Positions pos = {}) const;
/** [CTB] */
void setNumberOfDigitalSamples(int value, Positions pos = {});
/** [CTB] */
/** [CTB][Xilinx CTB] */
Result<int> getNumberOfTransceiverSamples(Positions pos = {}) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setNumberOfTransceiverSamples(int value, Positions pos = {});
/** [CTB] */
/** [CTB][Xilinx CTB] */
Result<defs::readoutMode> getReadoutMode(Positions pos = {}) const;
/** [CTB] Options: ANALOG_ONLY (default), DIGITAL_ONLY, ANALOG_AND_DIGITAL,
* TRANSCEIVER_ONLY, DIGITAL_AND_TRANSCEIVER
* [Xilinx CTB] Options: TRANSCEIVER_ONLY (default)
*/
void setReadoutMode(defs::readoutMode value, Positions pos = {});
@@ -1723,7 +1730,7 @@ class Detector {
Result<int> getMeasuredCurrent(defs::dacIndex index,
Positions pos = {}) const;
/** [CTB] Options: SLOW_ADC0 - SLOW_ADC7 in uV */
/** [CTB][Xilinx CTB] Options: SLOW_ADC0 - SLOW_ADC7 in uV */
Result<int> getSlowADC(defs::dacIndex index, Positions pos = {}) const;
/** [CTB] */
@@ -1765,81 +1772,95 @@ class Detector {
/** [CTB] Default is enabled. */
void setLEDEnable(bool enable, Positions pos = {});
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setDacNames(const std::vector<std::string> names);
/** [CTB][Xilinx CTB] */
std::vector<std::string> getDacNames() const;
/** [CTB][Xilinx CTB] */
defs::dacIndex getDacIndex(const std::string &name) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setDacName(const defs::dacIndex i, const std::string &name);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::string getDacName(const defs::dacIndex i) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setAdcNames(const std::vector<std::string> names);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::vector<std::string> getAdcNames() const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
int getAdcIndex(const std::string &name) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setAdcName(const int i, const std::string &name);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::string getAdcName(const int i) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setSignalNames(const std::vector<std::string> names);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::vector<std::string> getSignalNames() const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
int getSignalIndex(const std::string &name) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setSignalName(const int i, const std::string &name);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::string getSignalName(const int i) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setPowerNames(const std::vector<std::string> names);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::vector<std::string> getPowerNames() const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
defs::dacIndex getPowerIndex(const std::string &name) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setPowerName(const defs::dacIndex i, const std::string &name);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::string getPowerName(const defs::dacIndex i) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setSlowADCNames(const std::vector<std::string> names);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::vector<std::string> getSlowADCNames() const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
defs::dacIndex getSlowADCIndex(const std::string &name) const;
/** [CTB] */
/** [CTB][Xilinx CTB] */
void setSlowADCName(const defs::dacIndex i, const std::string &name);
/** [CTB] */
/** [CTB][Xilinx CTB] */
std::string getSlowADCName(const defs::dacIndex i) const;
///@}
/** @name Xilinx CTB Specific */
///@{
/**************************************************
* *
* Xilinx CTB Specific *
* *
* ************************************************/
///@}
/** [Xilinx Ctb] */
void configureTransceiver(Positions pos = {});
/** @name Pattern */
///@{
/**************************************************
@@ -1847,20 +1868,20 @@ class Detector {
* Pattern *
* *
* ************************************************/
/** [CTB][Mythen3] Gets the pattern file name including path of the last
* pattern uploaded. \n Returns an empty if nothing was uploaded or via a
* server default file*/
/** [CTB][Mythen3][Xilinx CTB] Gets the pattern file name including path of
* the last pattern uploaded. \n Returns an empty if nothing was uploaded or
* via a server default file*/
Result<std::string> getPatterFileName(Positions pos = {}) const;
/** [CTB][Mythen3] Loads ASCII pattern file directly to server
/** [CTB][Mythen3][Xilinx CTB] Loads ASCII pattern file directly to server
* (instead of executing line by line)*/
void setPattern(const std::string &fname, Positions pos = {});
/** [CTB][Mythen3] Loads pattern parameters structure directly to
* server */
/** [CTB][Mythen3][Xilinx CTB] Loads pattern parameters structure directly
* to server */
void setPattern(const Pattern &pat, Positions pos = {});
/** [CTB][Mythen3] [Ctb][Mythen3] Saves pattern to file
/** [CTB][Mythen3][Xilinx CTB] Saves pattern to file
* (ascii). \n [Ctb] Also executes pattern.*/
void savePattern(const std::string &fname);
@@ -1873,57 +1894,57 @@ class Detector {
/** [CTB] */
void setPatternIOControl(uint64_t word, Positions pos = {});
/** [CTB][Mythen3] same as executing for ctb */
/** [CTB][Mythen3][Xilinx CTB] same as executing for ctb */
Result<uint64_t> getPatternWord(int addr, Positions pos = {});
/** [CTB] Caution: If word is -1 reads the addr (same as
/** [CTB][Xilinx CTB] Caution: If word is -1 reads the addr (same as
* executing the pattern)
* [Mythen3] */
void setPatternWord(int addr, uint64_t word, Positions pos = {});
/**[CTB][Mythen3] Options: level: -1 (complete pattern) and 0-2
/**[CTB][Mythen3][Xilinx CTB] Options: level: -1 (complete pattern) and 0-2
* levels
* @returns array of start address and stop address
*/
Result<std::array<int, 2>>
getPatternLoopAddresses(int level, Positions pos = {}) const;
/** [CTB][Mythen3] Options: level: -1 (complete pattern) and 0-2
/** [CTB][Mythen3][Xilinx CTB] Options: level: -1 (complete pattern) and 0-2
* levels */
void setPatternLoopAddresses(int level, int start, int stop,
Positions pos = {});
/**[CTB][Mythen3] Options: level: -1 (complete pattern) and 0-2
/**[CTB][Mythen3][Xilinx CTB] Options: level: -1 (complete pattern) and 0-2
* levels */
Result<int> getPatternLoopCycles(int level, Positions pos = {}) const;
/** [CTB][Mythen3] n: 0-2, level: -1 (complete pattern) and 0-2
/** [CTB][Mythen3][Xilinx CTB] n: 0-2, level: -1 (complete pattern) and 0-2
* levels */
void setPatternLoopCycles(int level, int n, Positions pos = {});
/**[CTB][Mythen3] */
/**[CTB][Mythen3][Xilinx CTB] */
Result<int> getPatternWaitAddr(int level, Positions pos = {}) const;
/** [CTB][Mythen3] Options: level 0-2 */
/** [CTB][Mythen3][Xilinx CTB] Options: level 0-2 */
void setPatternWaitAddr(int level, int addr, Positions pos = {});
/** [CTB][Mythen3] */
/** [CTB][Mythen3][Xilinx CTB] */
Result<uint64_t> getPatternWaitTime(int level, Positions pos = {}) const;
/** [CTB][Mythen3] Options: level 0-2 */
/** [CTB][Mythen3][Xilinx CTB] Options: level 0-2 */
void setPatternWaitTime(int level, uint64_t t, Positions pos = {});
/** [CTB][Mythen3] */
/** [CTB][Mythen3][Xilinx CTB] */
Result<uint64_t> getPatternMask(Positions pos = {});
/** [CTB][Mythen3] Selects the bits that will have a pattern mask
* applied to the selected patmask for every pattern. */
/** [CTB][Mythen3][Xilinx CTB] Selects the bits that will have a pattern
* mask applied to the selected patmask for every pattern. */
void setPatternMask(uint64_t mask, Positions pos = {});
/** [CTB][Mythen3] */
/** [CTB][Mythen3][Xilinx CTB] */
Result<uint64_t> getPatternBitMask(Positions pos = {}) const;
/** [CTB][Mythen3] Sets the mask applied to every pattern to the
/** [CTB][Mythen3][Xilinx CTB] Sets the mask applied to every pattern to the
* selected bits */
void setPatternBitMask(uint64_t mask, Positions pos = {});
@@ -1987,7 +2008,7 @@ class Detector {
void programFPGA(const std::string &fname, const bool forceDeleteNormalFile,
Positions pos = {});
/** [Jungfrau][Moench][CTB] Advanced user Function! */
/** [Jungfrau][Moench][CTB][Xilinx CTB] Advanced user Function! */
void resetFPGA(Positions pos = {});
/** [Jungfrau][Moench][Eiger][Ctb][Mythen3][Gotthard2] Copies detector
@@ -2005,8 +2026,8 @@ class Detector {
*/
void updateKernel(const std::string &fname, Positions pos = {});
/** [Jungfrau][Moench][Gotthard][CTB][Mythen3][Gotthard2] Advanced user
* Function! */
/** [Jungfrau][Moench][Gotthard][CTB][Mythen3][Gotthard2][Xilinx CTB]
* Advanced user Function! */
void rebootController(Positions pos = {});
/**
@@ -2036,13 +2057,16 @@ class Detector {
* Goes to stop server. Hence, can be called while calling blocking
* acquire(). \n [Eiger] Address is +0x100 for only left, +0x200 for only
* right. */
void writeRegister(uint32_t addr, uint32_t val, Positions pos = {});
void writeRegister(uint32_t addr, uint32_t val, bool validate = false,
Positions pos = {});
/** Advanced user Function! */
void setBit(uint32_t addr, int bitnr, Positions pos = {});
void setBit(uint32_t addr, int bitnr, bool validate = false,
Positions pos = {});
/** Advanced user Function! */
void clearBit(uint32_t addr, int bitnr, Positions pos = {});
void clearBit(uint32_t addr, int bitnr, bool validate = false,
Positions pos = {});
/** Advanced user Function! */
Result<int> getBit(uint32_t addr, int bitnr, Positions pos = {});
@@ -2110,16 +2134,16 @@ class Detector {
Result<std::string> executeCommand(const std::string &value,
Positions pos = {});
/** [Jungfrau][Moench][Mythen3][CTB]
/** [Jungfrau][Moench][Mythen3][CTB][Xilinx CTB]
* [Gotthard2] only in continuous mode */
Result<int64_t> getNumberOfFramesFromStart(Positions pos = {}) const;
/** [Jungfrau][Moench][Mythen3][CTB] Get time from detector start
* [Gotthard2] not in burst and auto mode */
/** [Jungfrau][Moench][Mythen3][CTB][Xilinx CTB] Get time from detector
* start [Gotthard2] not in burst and auto mode */
Result<ns> getActualTime(Positions pos = {}) const;
/** [Jungfrau][Moench][Mythen3][CTB] Get timestamp at a frame start
* [Gotthard2] not in burst and auto mode */
/** [Jungfrau][Moench][Mythen3][CTB][Xilinx CTB] Get timestamp at a frame
* start [Gotthard2] not in burst and auto mode */
Result<ns> getMeasurementTime(Positions pos = {}) const;
/** get user details from shared memory (hostname, type, PID, User, Date)

18214
slsDetectorSoftware/src/Caller.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

890
slsDetectorSoftware/src/Caller.h Normal file
View File

@@ -0,0 +1,890 @@
// This file is used as input to generate the caller class
#include "CmdParser.h"
#include "HelpDacs.h"
#include "sls/Detector.h"
#include <iostream>
#include <string>
#include <vector>
namespace sls {
class Caller {
public:
Caller(Detector *ptr) : det(ptr) {}
void call(const std::string &command,
const std::vector<std::string> &arguments, int detector_id,
int action, std::ostream &os = std::cout, int receiver_id = -1);
IpAddr getDstIpFromAuto();
IpAddr getSrcIpFromAuto();
UdpDestination getUdpEntry();
void GetLevelAndUpdateArgIndex(int action,
std::string levelSeparatedCommand,
int &level, int &iArg, size_t nGetArgs,
size_t nPutArgs);
void WrongNumberOfParameters(size_t expected);
template <typename V> std::string OutStringHex(const V &value) {
if (value.equal())
return ToStringHex(value.front());
return ToStringHex(value);
}
template <typename V> std::string OutStringHex(const V &value, int width) {
if (value.equal())
return ToStringHex(value.front(), width);
return ToStringHex(value, width);
}
template <typename V> std::string OutString(const Result<V> &value) {
if (value.equal())
return ToString(value.front());
return ToString(value);
}
template <typename V> std::string OutString(const V &value) {
return ToString(value);
}
template <typename V>
std::string OutString(const V &value, const std::string &unit) {
if (value.equal())
return ToString(value.front(), unit);
return ToString(value, unit);
}
std::vector<std::string> getAllCommands();
std::map<std::string, std::string> GetDeprecatedCommands();
std::string list(int action);
std::string acquire(int action);
std::string activate(int action);
std::string adcclk(int action);
std::string adcenable(int action);
std::string adcenable10g(int action);
std::string adcindex(int action);
std::string adcinvert(int action);
std::string adclist(int action);
std::string adcname(int action);
std::string adcphase(int action);
std::string adcpipeline(int action);
std::string adcreg(int action);
std::string adcvpp(int action);
std::string apulse(int action);
std::string asamples(int action);
std::string autocompdisable(int action);
std::string badchannels(int action);
std::string blockingtrigger(int action);
std::string burstmode(int action);
std::string burstperiod(int action);
std::string bursts(int action);
std::string burstsl(int action);
std::string bustest(int action);
std::string cdsgain(int action);
std::string chipversion(int action);
std::string clearbit(int action);
std::string clearbusy(int action);
std::string clearroi(int action);
std::string clientversion(int action);
std::string clkdiv(int action);
std::string clkfreq(int action);
std::string clkphase(int action);
std::string collectionmode(int action);
std::string column(int action);
std::string compdisabletime(int action);
std::string confadc(int action);
std::string config(int action);
std::string configtransceiver(int action);
std::string counters(int action);
std::string currentsource(int action);
std::string dac(int action);
std::string dacindex(int action);
std::string daclist(int action);
std::string dacname(int action);
std::string dacvalues(int action);
std::string datastream(int action);
std::string dbitclk(int action);
std::string dbitphase(int action);
std::string dbitpipeline(int action);
std::string defaultdac(int action);
std::string defaultpattern(int action);
std::string delay(int action);
std::string delayl(int action);
std::string detectorserverversion(int action);
std::string detsize(int action);
std::string diodelay(int action);
std::string dpulse(int action);
std::string dr(int action);
std::string drlist(int action);
std::string dsamples(int action);
std::string execcommand(int action);
std::string exptime(int action);
std::string exptime1(int action);
std::string exptime2(int action);
std::string exptime3(int action);
std::string exptimel(int action);
std::string extrastoragecells(int action);
std::string extsampling(int action);
std::string extsamplingsrc(int action);
std::string extsig(int action);
std::string fformat(int action);
std::string filtercells(int action);
std::string filterresistor(int action);
std::string findex(int action);
std::string firmwaretest(int action);
std::string firmwareversion(int action);
std::string fliprows(int action);
std::string flowcontrol10g(int action);
std::string fmaster(int action);
std::string fname(int action);
std::string foverwrite(int action);
std::string fpath(int action);
std::string framecounter(int action);
std::string frames(int action);
std::string framesl(int action);
std::string frametime(int action);
std::string free(int action);
std::string fwrite(int action);
std::string gaincaps(int action);
std::string gainmode(int action);
std::string gappixels(int action);
std::string gatedelay(int action);
std::string gatedelay1(int action);
std::string gatedelay2(int action);
std::string gatedelay3(int action);
std::string gates(int action);
std::string getbit(int action);
std::string hardwareversion(int action);
std::string highvoltage(int action);
std::string hostname(int action);
std::string im_a(int action);
std::string im_b(int action);
std::string im_c(int action);
std::string im_d(int action);
std::string im_io(int action);
std::string imagetest(int action);
std::string initialchecks(int action);
std::string inj_ch(int action);
std::string interpolation(int action);
std::string interruptsubframe(int action);
std::string kernelversion(int action);
std::string lastclient(int action);
std::string led(int action);
std::string lock(int action);
std::string master(int action);
std::string maxadcphaseshift(int action);
std::string maxclkphaseshift(int action);
std::string maxdbitphaseshift(int action);
std::string measuredperiod(int action);
std::string measuredsubperiod(int action);
std::string moduleid(int action);
std::string nextframenumber(int action);
std::string nmod(int action);
std::string numinterfaces(int action);
std::string overflow(int action);
std::string packageversion(int action);
std::string parallel(int action);
std::string parameters(int action);
std::string partialreset(int action);
std::string patfname(int action);
std::string patioctrl(int action);
std::string patlimits(int action);
std::string patloop(int action);
std::string patloop0(int action);
std::string patloop1(int action);
std::string patloop2(int action);
std::string patmask(int action);
std::string patnloop(int action);
std::string patnloop0(int action);
std::string patnloop1(int action);
std::string patnloop2(int action);
std::string patsetbit(int action);
std::string pattern(int action);
std::string patternstart(int action);
std::string patwait(int action);
std::string patwait0(int action);
std::string patwait1(int action);
std::string patwait2(int action);
std::string patwaittime(int action);
std::string patwaittime0(int action);
std::string patwaittime1(int action);
std::string patwaittime2(int action);
std::string patword(int action);
std::string pedestalmode(int action);
std::string period(int action);
std::string periodl(int action);
std::string polarity(int action);
std::string port(int action);
std::string powerchip(int action);
std::string powerindex(int action);
std::string powerlist(int action);
std::string powername(int action);
std::string powervalues(int action);
std::string programfpga(int action);
std::string pulse(int action);
std::string pulsechip(int action);
std::string pulsenmove(int action);
std::string pumpprobe(int action);
std::string quad(int action);
std::string ratecorr(int action);
std::string readnrows(int action);
std::string readout(int action);
std::string readoutspeed(int action);
std::string readoutspeedlist(int action);
std::string rebootcontroller(int action);
std::string reg(int action);
std::string resetdacs(int action);
std::string resetfpga(int action);
std::string roi(int action);
std::string romode(int action);
std::string row(int action);
std::string runclk(int action);
std::string runtime(int action);
std::string rx_arping(int action);
std::string rx_clearroi(int action);
std::string rx_dbitlist(int action);
std::string rx_dbitoffset(int action);
std::string rx_discardpolicy(int action);
std::string rx_fifodepth(int action);
std::string rx_frameindex(int action);
std::string rx_framescaught(int action);
std::string rx_framesperfile(int action);
std::string rx_hostname(int action);
std::string rx_jsonaddheader(int action);
std::string rx_jsonpara(int action);
std::string rx_lastclient(int action);
std::string rx_lock(int action);
std::string rx_missingpackets(int action);
std::string rx_padding(int action);
std::string rx_printconfig(int action);
std::string rx_realudpsocksize(int action);
std::string rx_roi(int action);
std::string rx_silent(int action);
std::string rx_start(int action);
std::string rx_status(int action);
std::string rx_stop(int action);
std::string rx_tcpport(int action);
std::string rx_threads(int action);
std::string rx_udpsocksize(int action);
std::string rx_version(int action);
std::string rx_zmqfreq(int action);
std::string rx_zmqhwm(int action);
std::string rx_zmqip(int action);
std::string rx_zmqport(int action);
std::string rx_zmqstartfnum(int action);
std::string rx_zmqstream(int action);
std::string samples(int action);
std::string savepattern(int action);
std::string scan(int action);
std::string scanerrmsg(int action);
std::string selinterface(int action);
std::string serialnumber(int action);
std::string setbit(int action);
std::string settings(int action);
std::string settingslist(int action);
std::string settingspath(int action);
std::string signalindex(int action);
std::string signallist(int action);
std::string signalname(int action);
std::string sleep(int action);
std::string slowadc(int action);
std::string slowadcindex(int action);
std::string slowadclist(int action);
std::string slowadcname(int action);
std::string slowadcvalues(int action);
std::string start(int action);
std::string status(int action);
std::string stop(int action);
std::string stopport(int action);
std::string storagecell_delay(int action);
std::string storagecell_start(int action);
std::string subdeadtime(int action);
std::string subexptime(int action);
std::string sync(int action);
std::string syncclk(int action);
std::string temp_10ge(int action);
std::string temp_adc(int action);
std::string temp_control(int action);
std::string temp_dcdc(int action);
std::string temp_event(int action);
std::string temp_fpga(int action);
std::string temp_fpgaext(int action);
std::string temp_fpgafl(int action);
std::string temp_fpgafr(int action);
std::string temp_slowadc(int action);
std::string temp_sodl(int action);
std::string temp_sodr(int action);
std::string temp_threshold(int action);
std::string templist(int action);
std::string tempvalues(int action);
std::string tengiga(int action);
std::string threshold(int action);
std::string timing(int action);
std::string timing_info_decoder(int action);
std::string timinglist(int action);
std::string timingsource(int action);
std::string top(int action);
std::string transceiverenable(int action);
std::string trigger(int action);
std::string triggers(int action);
std::string triggersl(int action);
std::string trimbits(int action);
std::string trimen(int action);
std::string trimval(int action);
std::string tsamples(int action);
std::string txdelay(int action);
std::string txdelay_frame(int action);
std::string txdelay_left(int action);
std::string txdelay_right(int action);
std::string type(int action);
std::string udp_cleardst(int action);
std::string udp_dstip(int action);
std::string udp_dstip2(int action);
std::string udp_dstlist(int action);
std::string udp_dstmac(int action);
std::string udp_dstmac2(int action);
std::string udp_dstport(int action);
std::string udp_dstport2(int action);
std::string udp_firstdst(int action);
std::string udp_numdst(int action);
std::string udp_reconfigure(int action);
std::string udp_srcip(int action);
std::string udp_srcip2(int action);
std::string udp_srcmac(int action);
std::string udp_srcmac2(int action);
std::string udp_validate(int action);
std::string update(int action);
std::string updatedetectorserver(int action);
std::string updatekernel(int action);
std::string updatemode(int action);
std::string user(int action);
std::string v_a(int action);
std::string v_b(int action);
std::string v_c(int action);
std::string v_chip(int action);
std::string v_d(int action);
std::string v_io(int action);
std::string v_limit(int action);
std::string vchip_comp_adc(int action);
std::string vchip_comp_fe(int action);
std::string vchip_cs(int action);
std::string vchip_opa_1st(int action);
std::string vchip_opa_fd(int action);
std::string vchip_ref_comp_fe(int action);
std::string versions(int action);
std::string veto(int action);
std::string vetoalg(int action);
std::string vetofile(int action);
std::string vetophoton(int action);
std::string vetoref(int action);
std::string vetostream(int action);
std::string virtualFunction(int action);
std::string vm_a(int action);
std::string vm_b(int action);
std::string vm_c(int action);
std::string vm_d(int action);
std::string vm_io(int action);
std::string zmqhwm(int action);
std::string zmqip(int action);
std::string zmqport(int action);
std::vector<std::string> args;
std::string cmd;
Detector *det;
int det_id{-1};
int rx_id{-1};
private:
bool ReplaceIfDeprecated(std::string &command);
using FunctionMap = std::map<std::string, std::string (Caller::*)(int)>;
using StringMap = std::map<std::string, std::string>;
Detector *ptr; // pointer to the detector that executes the command
static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
uint32_t subFrameIndex, void *this_pointer);
FunctionMap functions{
{"list", &Caller::list},
{"acquire", &Caller::acquire},
{"activate", &Caller::activate},
{"adcclk", &Caller::adcclk},
{"adcenable", &Caller::adcenable},
{"adcenable10g", &Caller::adcenable10g},
{"adcindex", &Caller::adcindex},
{"adcinvert", &Caller::adcinvert},
{"adclist", &Caller::adclist},
{"adcname", &Caller::adcname},
{"adcphase", &Caller::adcphase},
{"adcpipeline", &Caller::adcpipeline},
{"adcreg", &Caller::adcreg},
{"adcvpp", &Caller::adcvpp},
{"apulse", &Caller::apulse},
{"asamples", &Caller::asamples},
{"autocompdisable", &Caller::autocompdisable},
{"badchannels", &Caller::badchannels},
{"blockingtrigger", &Caller::blockingtrigger},
{"burstmode", &Caller::burstmode},
{"burstperiod", &Caller::burstperiod},
{"bursts", &Caller::bursts},
{"burstsl", &Caller::burstsl},
{"bustest", &Caller::bustest},
{"cdsgain", &Caller::cdsgain},
{"chipversion", &Caller::chipversion},
{"clearbit", &Caller::clearbit},
{"clearbusy", &Caller::clearbusy},
{"clearroi", &Caller::clearroi},
{"clientversion", &Caller::clientversion},
{"clkdiv", &Caller::clkdiv},
{"clkfreq", &Caller::clkfreq},
{"clkphase", &Caller::clkphase},
{"collectionmode", &Caller::collectionmode},
{"column", &Caller::column},
{"compdisabletime", &Caller::compdisabletime},
{"confadc", &Caller::confadc},
{"config", &Caller::config},
{"configtransceiver", &Caller::configtransceiver},
{"counters", &Caller::counters},
{"currentsource", &Caller::currentsource},
{"dac", &Caller::dac},
{"dacindex", &Caller::dacindex},
{"daclist", &Caller::daclist},
{"dacname", &Caller::dacname},
{"dacvalues", &Caller::dacvalues},
{"datastream", &Caller::datastream},
{"dbitclk", &Caller::dbitclk},
{"dbitphase", &Caller::dbitphase},
{"dbitpipeline", &Caller::dbitpipeline},
{"defaultdac", &Caller::defaultdac},
{"defaultpattern", &Caller::defaultpattern},
{"delay", &Caller::delay},
{"delayl", &Caller::delayl},
{"detectorserverversion", &Caller::detectorserverversion},
{"detsize", &Caller::detsize},
{"diodelay", &Caller::diodelay},
{"dpulse", &Caller::dpulse},
{"dr", &Caller::dr},
{"drlist", &Caller::drlist},
{"dsamples", &Caller::dsamples},
{"execcommand", &Caller::execcommand},
{"exptime", &Caller::exptime},
{"exptime1", &Caller::exptime1},
{"exptime2", &Caller::exptime2},
{"exptime3", &Caller::exptime3},
{"exptimel", &Caller::exptimel},
{"extrastoragecells", &Caller::extrastoragecells},
{"extsampling", &Caller::extsampling},
{"extsamplingsrc", &Caller::extsamplingsrc},
{"extsig", &Caller::extsig},
{"fformat", &Caller::fformat},
{"filtercells", &Caller::filtercells},
{"filterresistor", &Caller::filterresistor},
{"findex", &Caller::findex},
{"firmwaretest", &Caller::firmwaretest},
{"firmwareversion", &Caller::firmwareversion},
{"fliprows", &Caller::fliprows},
{"flowcontrol10g", &Caller::flowcontrol10g},
{"fmaster", &Caller::fmaster},
{"fname", &Caller::fname},
{"foverwrite", &Caller::foverwrite},
{"fpath", &Caller::fpath},
{"framecounter", &Caller::framecounter},
{"frames", &Caller::frames},
{"framesl", &Caller::framesl},
{"frametime", &Caller::frametime},
{"free", &Caller::free},
{"fwrite", &Caller::fwrite},
{"gaincaps", &Caller::gaincaps},
{"gainmode", &Caller::gainmode},
{"gappixels", &Caller::gappixels},
{"gatedelay", &Caller::gatedelay},
{"gatedelay1", &Caller::gatedelay1},
{"gatedelay2", &Caller::gatedelay2},
{"gatedelay3", &Caller::gatedelay3},
{"gates", &Caller::gates},
{"getbit", &Caller::getbit},
{"hardwareversion", &Caller::hardwareversion},
{"highvoltage", &Caller::highvoltage},
{"hostname", &Caller::hostname},
{"im_a", &Caller::im_a},
{"im_b", &Caller::im_b},
{"im_c", &Caller::im_c},
{"im_d", &Caller::im_d},
{"im_io", &Caller::im_io},
{"imagetest", &Caller::imagetest},
{"initialchecks", &Caller::initialchecks},
{"inj_ch", &Caller::inj_ch},
{"interpolation", &Caller::interpolation},
{"interruptsubframe", &Caller::interruptsubframe},
{"kernelversion", &Caller::kernelversion},
{"lastclient", &Caller::lastclient},
{"led", &Caller::led},
{"lock", &Caller::lock},
{"master", &Caller::master},
{"maxadcphaseshift", &Caller::maxadcphaseshift},
{"maxclkphaseshift", &Caller::maxclkphaseshift},
{"maxdbitphaseshift", &Caller::maxdbitphaseshift},
{"measuredperiod", &Caller::measuredperiod},
{"measuredsubperiod", &Caller::measuredsubperiod},
{"moduleid", &Caller::moduleid},
{"nextframenumber", &Caller::nextframenumber},
{"nmod", &Caller::nmod},
{"numinterfaces", &Caller::numinterfaces},
{"overflow", &Caller::overflow},
{"packageversion", &Caller::packageversion},
{"parallel", &Caller::parallel},
{"parameters", &Caller::parameters},
{"partialreset", &Caller::partialreset},
{"patfname", &Caller::patfname},
{"patioctrl", &Caller::patioctrl},
{"patlimits", &Caller::patlimits},
{"patloop", &Caller::patloop},
{"patloop0", &Caller::patloop0},
{"patloop1", &Caller::patloop1},
{"patloop2", &Caller::patloop2},
{"patmask", &Caller::patmask},
{"patnloop", &Caller::patnloop},
{"patnloop0", &Caller::patnloop0},
{"patnloop1", &Caller::patnloop1},
{"patnloop2", &Caller::patnloop2},
{"patsetbit", &Caller::patsetbit},
{"patternX", &Caller::pattern},
{"patternstart", &Caller::patternstart},
{"patwait", &Caller::patwait},
{"patwait0", &Caller::patwait0},
{"patwait1", &Caller::patwait1},
{"patwait2", &Caller::patwait2},
{"patwaittime", &Caller::patwaittime},
{"patwaittime0", &Caller::patwaittime0},
{"patwaittime1", &Caller::patwaittime1},
{"patwaittime2", &Caller::patwaittime2},
{"patword", &Caller::patword},
{"pedestalmode", &Caller::pedestalmode},
{"period", &Caller::period},
{"periodl", &Caller::periodl},
{"polarity", &Caller::polarity},
{"port", &Caller::port},
{"powerchip", &Caller::powerchip},
{"powerindex", &Caller::powerindex},
{"powerlist", &Caller::powerlist},
{"powername", &Caller::powername},
{"powervalues", &Caller::powervalues},
{"programfpga", &Caller::programfpga},
{"pulse", &Caller::pulse},
{"pulsechip", &Caller::pulsechip},
{"pulsenmove", &Caller::pulsenmove},
{"pumpprobe", &Caller::pumpprobe},
{"quad", &Caller::quad},
{"ratecorr", &Caller::ratecorr},
{"readnrows", &Caller::readnrows},
{"readout", &Caller::readout},
{"readoutspeed", &Caller::readoutspeed},
{"readoutspeedlist", &Caller::readoutspeedlist},
{"rebootcontroller", &Caller::rebootcontroller},
{"reg", &Caller::reg},
{"resetdacs", &Caller::resetdacs},
{"resetfpga", &Caller::resetfpga},
{"roi", &Caller::roi},
{"romode", &Caller::romode},
{"row", &Caller::row},
{"runclk", &Caller::runclk},
{"runtime", &Caller::runtime},
{"rx_arping", &Caller::rx_arping},
{"rx_clearroi", &Caller::rx_clearroi},
{"rx_dbitlist", &Caller::rx_dbitlist},
{"rx_dbitoffset", &Caller::rx_dbitoffset},
{"rx_discardpolicy", &Caller::rx_discardpolicy},
{"rx_fifodepth", &Caller::rx_fifodepth},
{"rx_frameindex", &Caller::rx_frameindex},
{"rx_framescaught", &Caller::rx_framescaught},
{"rx_framesperfile", &Caller::rx_framesperfile},
{"rx_hostname", &Caller::rx_hostname},
{"rx_jsonaddheader", &Caller::rx_jsonaddheader},
{"rx_jsonpara", &Caller::rx_jsonpara},
{"rx_lastclient", &Caller::rx_lastclient},
{"rx_lock", &Caller::rx_lock},
{"rx_missingpackets", &Caller::rx_missingpackets},
{"rx_padding", &Caller::rx_padding},
{"rx_printconfig", &Caller::rx_printconfig},
{"rx_realudpsocksize", &Caller::rx_realudpsocksize},
{"rx_roi", &Caller::rx_roi},
{"rx_silent", &Caller::rx_silent},
{"rx_start", &Caller::rx_start},
{"rx_status", &Caller::rx_status},
{"rx_stop", &Caller::rx_stop},
{"rx_tcpport", &Caller::rx_tcpport},
{"rx_threads", &Caller::rx_threads},
{"rx_udpsocksize", &Caller::rx_udpsocksize},
{"rx_version", &Caller::rx_version},
{"rx_zmqfreq", &Caller::rx_zmqfreq},
{"rx_zmqhwm", &Caller::rx_zmqhwm},
{"rx_zmqip", &Caller::rx_zmqip},
{"rx_zmqport", &Caller::rx_zmqport},
{"rx_zmqstartfnum", &Caller::rx_zmqstartfnum},
{"rx_zmqstream", &Caller::rx_zmqstream},
{"samples", &Caller::samples},
{"savepattern", &Caller::savepattern},
{"scan", &Caller::scan},
{"scanerrmsg", &Caller::scanerrmsg},
{"selinterface", &Caller::selinterface},
{"serialnumber", &Caller::serialnumber},
{"setbit", &Caller::setbit},
{"settings", &Caller::settings},
{"settingslist", &Caller::settingslist},
{"settingspath", &Caller::settingspath},
{"signalindex", &Caller::signalindex},
{"signallist", &Caller::signallist},
{"signalname", &Caller::signalname},
{"sleep", &Caller::sleep},
{"slowadc", &Caller::slowadc},
{"slowadcindex", &Caller::slowadcindex},
{"slowadclist", &Caller::slowadclist},
{"slowadcname", &Caller::slowadcname},
{"slowadcvalues", &Caller::slowadcvalues},
{"start", &Caller::start},
{"status", &Caller::status},
{"stop", &Caller::stop},
{"stopport", &Caller::stopport},
{"storagecell_delay", &Caller::storagecell_delay},
{"storagecell_start", &Caller::storagecell_start},
{"subdeadtime", &Caller::subdeadtime},
{"subexptime", &Caller::subexptime},
{"sync", &Caller::sync},
{"syncclk", &Caller::syncclk},
{"temp_10ge", &Caller::temp_10ge},
{"temp_adc", &Caller::temp_adc},
{"temp_control", &Caller::temp_control},
{"temp_dcdc", &Caller::temp_dcdc},
{"temp_event", &Caller::temp_event},
{"temp_fpga", &Caller::temp_fpga},
{"temp_fpgaext", &Caller::temp_fpgaext},
{"temp_fpgafl", &Caller::temp_fpgafl},
{"temp_fpgafr", &Caller::temp_fpgafr},
{"temp_slowadc", &Caller::temp_slowadc},
{"temp_sodl", &Caller::temp_sodl},
{"temp_sodr", &Caller::temp_sodr},
{"temp_threshold", &Caller::temp_threshold},
{"templist", &Caller::templist},
{"tempvalues", &Caller::tempvalues},
{"tengiga", &Caller::tengiga},
{"threshold", &Caller::threshold},
{"thresholdnotb", &Caller::threshold},
{"timing", &Caller::timing},
{"timing_info_decoder", &Caller::timing_info_decoder},
{"timinglist", &Caller::timinglist},
{"timingsource", &Caller::timingsource},
{"top", &Caller::top},
{"transceiverenable", &Caller::transceiverenable},
{"trigger", &Caller::trigger},
{"triggers", &Caller::triggers},
{"triggersl", &Caller::triggersl},
{"trimbits", &Caller::trimbits},
{"trimen", &Caller::trimen},
{"trimval", &Caller::trimval},
{"tsamples", &Caller::tsamples},
{"txdelay", &Caller::txdelay},
{"txdelay_frame", &Caller::txdelay_frame},
{"txdelay_left", &Caller::txdelay_left},
{"txdelay_right", &Caller::txdelay_right},
{"type", &Caller::type},
{"udp_cleardst", &Caller::udp_cleardst},
{"udp_dstip", &Caller::udp_dstip},
{"udp_dstip2", &Caller::udp_dstip2},
{"udp_dstlist", &Caller::udp_dstlist},
{"udp_dstmac", &Caller::udp_dstmac},
{"udp_dstmac2", &Caller::udp_dstmac2},
{"udp_dstport", &Caller::udp_dstport},
{"udp_dstport2", &Caller::udp_dstport2},
{"udp_firstdst", &Caller::udp_firstdst},
{"udp_numdst", &Caller::udp_numdst},
{"udp_reconfigure", &Caller::udp_reconfigure},
{"udp_srcip", &Caller::udp_srcip},
{"udp_srcip2", &Caller::udp_srcip2},
{"udp_srcmac", &Caller::udp_srcmac},
{"udp_srcmac2", &Caller::udp_srcmac2},
{"udp_validate", &Caller::udp_validate},
{"update", &Caller::update},
{"updatedetectorserver", &Caller::updatedetectorserver},
{"updatekernel", &Caller::updatekernel},
{"updatemode", &Caller::updatemode},
{"user", &Caller::user},
{"v_a", &Caller::v_a},
{"v_b", &Caller::v_b},
{"v_c", &Caller::v_c},
{"v_chip", &Caller::v_chip},
{"v_d", &Caller::v_d},
{"v_io", &Caller::v_io},
{"v_limit", &Caller::v_limit},
{"vchip_comp_adc", &Caller::vchip_comp_adc},
{"vchip_comp_fe", &Caller::vchip_comp_fe},
{"vchip_cs", &Caller::vchip_cs},
{"vchip_opa_1st", &Caller::vchip_opa_1st},
{"vchip_opa_fd", &Caller::vchip_opa_fd},
{"vchip_ref_comp_fe", &Caller::vchip_ref_comp_fe},
{"versions", &Caller::versions},
{"veto", &Caller::veto},
{"vetoalg", &Caller::vetoalg},
{"vetofile", &Caller::vetofile},
{"vetophoton", &Caller::vetophoton},
{"vetoref", &Caller::vetoref},
{"vetostream", &Caller::vetostream},
{"virtual", &Caller::virtualFunction},
{"vm_a", &Caller::vm_a},
{"vm_b", &Caller::vm_b},
{"vm_c", &Caller::vm_c},
{"vm_d", &Caller::vm_d},
{"vm_io", &Caller::vm_io},
{"zmqhwm", &Caller::zmqhwm},
{"zmqip", &Caller::zmqip},
{"zmqport", &Caller::zmqport}
};
StringMap deprecated_functions{
{"detectorversion", "firmwareversion"},
{"softwareversion", "detectorserverversion"},
{"receiverversion", "rx_version"},
{"detectornumber", "serialnumber"},
{"thisversion", "clientversion"},
{"detsizechan", "detsize"},
{"trimdir", "settingspath"},
{"settingsdir", "settingspath"},
{"flippeddatax", "fliprows"},
{"cycles", "triggers"},
{"cyclesl", "triggersl"},
{"clkdivider", "readoutspeed"},
{"speed", "readoutspeed"},
{"vhighvoltage", "highvoltage"},
{"digitest", "imagetest"},
{"filter", "filterresistor"},
{"readnlines", "readnrows"},
{"vtr", "vtrim"},
{"vrf", "vrpreamp"},
{"vrs", "vrshaper"},
{"vcall", "vcal"},
{"vis", "vishaper"},
{"vshaper", "vrshaper"},
{"vpreamp", "vrpreamp"},
{"vshaperneg", "vrshaper_n"},
{"viinsh", "vishaper"},
{"vpl", "vcal_n"},
{"vph", "vcal_p"},
{"vthreshold", "dac"},
{"vsvp", "dac"},
{"vsvn", "dac"},
{"vtrim", "dac"},
{"vrpreamp", "dac"},
{"vrshaper", "dac"},
{"vtgstv", "dac"},
{"vcmp_ll", "dac"},
{"vcmp_lr", "dac"},
{"vcal", "dac"},
{"vcmp_rl", "dac"},
{"vcmp_rr", "dac"},
{"rxb_rb", "dac"},
{"rxb_lb", "dac"},
{"vcp", "dac"},
{"vcn", "dac"},
{"vishaper", "dac"},
{"iodelay", "dac"},
{"vref_ds", "dac"},
{"vcascn_pb", "dac"},
{"vcascp_pb", "dac"},
{"vout_cm", "dac"},
{"vcasc_out", "dac"},
{"vin_cm", "dac"},
{"vref_comp", "dac"},
{"ib_test_c", "dac"},
{"vrshaper_n", "dac"},
{"vipre", "dac"},
{"vdcsh", "dac"},
{"vth1", "dac"},
{"vth2", "dac"},
{"vth3", "dac"},
{"vcal_n", "dac"},
{"vcal_p", "dac"},
{"vcassh", "dac"},
{"vcas", "dac"},
{"vicin", "dac"},
{"vipre_out", "dac"},
{"vref_h_adc", "dac"},
{"vb_comp_fe", "dac"},
{"vb_comp_adc", "dac"},
{"vcom_cds", "dac"},
{"vref_rstore", "dac"},
{"vb_opa_1st", "dac"},
{"vref_comp_fe", "dac"},
{"vcom_adc1", "dac"},
{"vref_prech", "dac"},
{"vref_l_adc", "dac"},
{"vref_cds", "dac"},
{"vb_cs", "dac"},
{"vb_opa_fd", "dac"},
{"vcom_adc2", "dac"},
{"vb_ds", "dac"},
{"vb_comp", "dac"},
{"vb_pixbuf", "dac"},
{"vin_com", "dac"},
{"vdd_prot", "dac"},
{"vbp_colbuf", "dac"},
{"vb_sda", "dac"},
{"vcasc_sfp", "dac"},
{"vipre_cds", "dac"},
{"ibias_sfp", "dac"},
{"defaultdacs", "resetdacs"},
{"busy", "clearbusy"},
{"receiver", "rx_status"},
{"framescaught", "rx_framescaught"},
{"startingfnum", "nextframenumber"},
{"detectorip", "udp_srcip"},
{"detectorip2", "udp_srcip2"},
{"detectormac", "udp_srcmac"},
{"detectormac2", "udp_srcmac2"},
{"rx_udpip", "udp_dstip"},
{"rx_udpip2", "udp_dstip2"},
{"rx_udpmac", "udp_dstmac"},
{"rx_udpmac2", "udp_dstmac2"},
{"rx_udpport", "udp_dstport"},
{"rx_udpport2", "udp_dstport2"},
{"flowcontrol_10g", "flowcontrol10g"},
{"txndelay_frame", "txdelay_frame"},
{"txndelay_left", "txdelay_left"},
{"txndelay_right", "txdelay_right"},
{"r_silent", "rx_silent"},
{"r_discardpolicy", "rx_discardpolicy"},
{"r_padding", "rx_padding"},
{"r_lock", "rx_lock"},
{"r_lastclient", "rx_lastclient"},
{"fileformat", "fformat"},
{"outdir", "fpath"},
{"index", "findex"},
{"enablefwrite", "fwrite"},
{"masterfile", "fmaster"},
{"overwrite", "foverwrite"},
{"r_framesperfile", "rx_framesperfile"},
{"r_readfreq", "rx_zmqfreq"},
{"rx_readfreq", "rx_zmqfreq"},
{"rx_datastream", "rx_zmqstream"},
{"resmat", "partialreset"},
{"storagecells", "extrastoragecells"},
{"auto_comp_disable", "autocompdisable"},
{"comp_disable_time", "compdisabletime"},
{"adc", "slowadc"},
{"flags", "romode"},
{"i_a", "im_a"},
{"i_b", "im_b"},
{"i_c", "im_c"},
{"i_d", "im_d"},
{"i_io", "im_io"},
{"copydetectorserver", "updatedetectorserver"},
{"nframes", "framecounter"},
{"now", "runtime"},
{"timestamp", "frametime"},
{"frameindex", "rx_frameindex"},
};
};
} // namespace sls

1277
slsDetectorSoftware/src/CallerSpecial.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

51
slsDetectorSoftware/src/CmdLineApp.cpp → slsDetectorSoftware/src/CmdApp.cpp
View File

@@ -1,22 +1,12 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
/*
This file is used to generate the command line binaries
(sls_detector_get/put/acquire/help). By defines in CMake
we get the different files.
*/
#include "sls/Detector.h"
#include "Caller.h"
#include "CmdParser.h"
#include "CmdProxy.h"
#include "sls/sls_detector_defs.h"
#include "inferAction.h"
#include "sls/Detector.h"
#include "sls/logger.h"
#include "sls/versionAPI.h"
#include <cstring> //strcmp
#include <iostream>
int main(int argc, char *argv[]) {
// To genereate sepereate binaries for put, get, acquire and help
#ifdef PUT
int action = slsDetectorDefs::PUT_ACTION;
@@ -37,6 +27,9 @@ int main(int argc, char *argv[]) {
#ifdef HELP
int action = slsDetectorDefs::HELP_ACTION;
#endif
#ifdef INFER
int action = -1;
#endif
// Check for --version in the arguments
for (int i = 1; i < argc; ++i) {
@@ -49,7 +42,6 @@ int main(int argc, char *argv[]) {
sls::CmdParser parser;
parser.Parse(argc, argv);
// If we called sls_detector_acquire, add the acquire command
if (action == slsDetectorDefs::READOUT_ACTION ||
action == slsDetectorDefs::READOUT_ZMQ_ACTION)
parser.setCommand("acquire");
@@ -57,7 +49,6 @@ int main(int argc, char *argv[]) {
if (parser.isHelp())
action = slsDetectorDefs::HELP_ACTION;
else {
// Free shared memory should work also without a detector
// if we have an option for verify in the detector constructor
// we could avoid this but clutter the code
@@ -70,22 +61,30 @@ int main(int argc, char *argv[]) {
}
}
// prevent mem size check
if (parser.command() == "config" && action == slsDetectorDefs::PUT_ACTION) {
sls::freeSharedMemory(parser.multi_id());
}
sls::InferAction inferAction = sls::InferAction();
try {
std::unique_ptr<sls::Detector> det{nullptr};
if (action != slsDetectorDefs::HELP_ACTION) {
det = sls::make_unique<sls::Detector>(parser.multi_id());
if (action == -1) {
action = inferAction.infer(parser);
std::string actionString =
(action == slsDetectorDefs::GET_ACTION) ? "GET" : "PUT";
std::cout << "inferred action: " << actionString << std::endl;
}
sls::CmdProxy proxy(det.get());
proxy.Call(parser.command(), parser.arguments(), parser.detector_id(),
action, std::cout, parser.receiver_id());
} catch (const sls::RuntimeError &e) {
std::unique_ptr<sls::Detector> d{nullptr};
if (action != slsDetectorDefs::HELP_ACTION) {
d = sls::make_unique<sls::Detector>(parser.multi_id());
}
sls::Caller c(d.get());
c.call(parser.command(), parser.arguments(), parser.detector_id(),
action, std::cout, parser.receiver_id());
} catch (sls::RuntimeError &e) {
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

1
slsDetectorSoftware/src/CmdParser.h
View File

@@ -20,7 +20,6 @@ reason that the header file is not exposed.
#include <vector>
namespace sls {
class CmdParser {
public:
void Parse(int argc, const char *const argv[]);

3439
slsDetectorSoftware/src/CmdProxy.cpp
View File

File diff suppressed because it is too large Load Diff

2658
slsDetectorSoftware/src/CmdProxy.h
View File

File diff suppressed because it is too large Load Diff

188
slsDetectorSoftware/src/Detector.cpp
View File

@@ -3,8 +3,8 @@
#include "sls/Detector.h"
#include "sls/detectorData.h"
#include "Caller.h"
#include "CmdParser.h"
#include "CmdProxy.h"
#include "CtbConfig.h"
#include "DetectorImpl.h"
#include "Module.h"
@@ -23,7 +23,7 @@
namespace sls {
void freeSharedMemory(int detectorIndex, int moduleIndex) {
void freeSharedMemory(const int detectorIndex, const int moduleIndex) {
// single module
if (moduleIndex >= 0) {
@@ -34,10 +34,10 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
return;
}
// detector - multi module - get number of detectors from shm
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
int numDetectors = 0;
// detector - multi module - get number of detectors from shm
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
if (detectorShm.exists()) {
detectorShm.openSharedMemory(false);
numDetectors = detectorShm()->totalNumberOfModules;
@@ -58,15 +58,19 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
using defs = slsDetectorDefs;
Detector::Detector(int shm_id) : pimpl(make_unique<DetectorImpl>(shm_id)) {}
Detector::~Detector() = default;
// Move constructor
Detector::Detector(Detector &&other) noexcept = default;
// Move assignment operator
Detector &Detector::operator=(Detector &&other) noexcept = default;
// Configuration
void Detector::freeSharedMemory() { pimpl->freeSharedMemory(); }
void Detector::loadConfig(const std::string &fname) {
int shm_id = getShmId();
freeSharedMemory();
freeSharedMemory(shm_id);
pimpl = make_unique<DetectorImpl>(shm_id);
LOG(logINFO) << "Loading configuration file: " << fname;
loadParameters(fname);
@@ -91,12 +95,12 @@ void Detector::loadParameters(const std::string &fname) {
}
void Detector::loadParameters(const std::vector<std::string> &parameters) {
CmdProxy proxy(this);
Caller caller(this);
CmdParser parser;
for (const auto &current_line : parameters) {
parser.Parse(current_line);
proxy.Call(parser.command(), parser.arguments(), parser.detector_id(),
defs::PUT_ACTION, std::cout, parser.receiver_id());
caller.call(parser.command(), parser.arguments(), parser.detector_id(),
defs::PUT_ACTION, std::cout, parser.receiver_id());
}
}
@@ -105,18 +109,35 @@ Result<std::string> Detector::getHostname(Positions pos) const {
}
void Detector::setHostname(const std::vector<std::string> &hostname) {
if (pimpl->hasModulesInSharedMemory()) {
LOG(logWARNING) << "There are already module(s) in shared memory."
"Freeing Shared memory now.";
auto numChannels = getDetectorSize();
auto initialChecks = getInitialChecks();
freeSharedMemory(getShmId());
pimpl = make_unique<DetectorImpl>(getShmId());
setDetectorSize(numChannels);
setInitialChecks(initialChecks);
}
pimpl->setHostname(hostname);
}
void Detector::setVirtualDetectorServers(int numServers,
uint16_t startingPort) {
validatePortRange(startingPort, numServers * 2);
pimpl->setVirtualDetectorServers(numServers, startingPort);
std::vector<std::string> hostnames;
for (int i = 0; i < numServers; ++i) {
// * 2 is for control and stop port
hostnames.push_back(std::string("localhost:") +
std::to_string(startingPort + i * 2));
}
setHostname(hostnames);
}
int Detector::getShmId() const { return pimpl->getDetectorIndex(); }
std::string Detector::getPackageVersion() const { return RELEASE; }
std::string Detector::getPackageVersion() const { return SLS_DET_VERSION; }
std::string Detector::getClientVersion() const {
Version v(APILIB);
@@ -208,6 +229,7 @@ std::vector<defs::detectorSettings> Detector::getSettingsList() const {
defs::G2_LOWCAP_HIGHGAIN, defs::G2_LOWCAP_LOWGAIN,
defs::G4_HIGHGAIN, defs::G4_LOWGAIN};
case defs::CHIPTESTBOARD:
case defs::XILINX_CHIPTESTBOARD:
throw RuntimeError("Settings not implemented for this detector");
default:
throw RuntimeError("Unknown detector type");
@@ -532,6 +554,7 @@ std::vector<defs::speedLevel> Detector::getReadoutSpeedList() const {
case defs::EIGER:
case defs::JUNGFRAU:
case defs::MOENCH:
case defs::MYTHEN3:
return std::vector<defs::speedLevel>{defs::FULL_SPEED, defs::HALF_SPEED,
defs::QUARTER_SPEED};
case defs::GOTTHARD2:
@@ -666,6 +689,7 @@ std::vector<defs::dacIndex> Detector::getTemperatureList() const {
defs::TEMPERATURE_FPGA2, defs::TEMPERATURE_FPGA3};
case defs::MYTHEN3:
case defs::GOTTHARD2:
case defs::XILINX_CHIPTESTBOARD:
return std::vector<defs::dacIndex>{defs::TEMPERATURE_FPGA};
default:
return std::vector<defs::dacIndex>{};
@@ -696,6 +720,7 @@ Result<int> Detector::getTemperature(defs::dacIndex index,
case defs::MOENCH:
case defs::MYTHEN3:
case defs::GOTTHARD2:
case defs::XILINX_CHIPTESTBOARD:
for (auto &it : res) {
it /= 1000;
}
@@ -743,6 +768,7 @@ std::vector<defs::dacIndex> Detector::getDacList() const {
defs::VBP_COLBUF, defs::VIPRE, defs::VIN_CM, defs::VB_SDA,
defs::VCASC_SFP, defs::VOUT_CM, defs::VIPRE_CDS, defs::IBIAS_SFP};
case defs::CHIPTESTBOARD:
case defs::XILINX_CHIPTESTBOARD:
for (int i = 0; i != 18; ++i) {
retval.push_back(static_cast<defs::dacIndex>(i));
}
@@ -905,7 +931,9 @@ void Detector::stopDetector(Positions pos) {
case defs::EIGER:
case defs::JUNGFRAU:
case defs::MOENCH:
case defs::CHIPTESTBOARD: {
case defs::CHIPTESTBOARD:
case defs::XILINX_CHIPTESTBOARD:
case defs::GOTTHARD2: {
auto res = getNextFrameNumber(pos);
if (!res.equal()) {
uint64_t maxVal = 0;
@@ -1478,19 +1506,6 @@ void Detector::setRxZmqPort(uint16_t port, int module_id) {
}
}
Result<IpAddr> Detector::getRxZmqIP(Positions pos) const {
return pimpl->Parallel(&Module::getReceiverStreamingIP, pos);
}
void Detector::setRxZmqIP(const IpAddr ip, Positions pos) {
bool previouslyReceiverStreaming = getRxZmqDataStream(pos).squash(false);
pimpl->Parallel(&Module::setReceiverStreamingIP, pos, ip);
if (previouslyReceiverStreaming) {
setRxZmqDataStream(false, pos);
setRxZmqDataStream(true, pos);
}
}
Result<uint16_t> Detector::getClientZmqPort(Positions pos) const {
return pimpl->Parallel(&Module::getClientStreamingPort, pos);
}
@@ -1779,6 +1794,24 @@ void Detector::setPedestalMode(const defs::pedestalParameters par,
pimpl->Parallel(&Module::setPedestalMode, pos, par);
}
Result<defs::timingInfoDecoder>
Detector::getTimingInfoDecoder(Positions pos) const {
return pimpl->Parallel(&Module::getTimingInfoDecoder, pos);
}
void Detector::setTimingInfoDecoder(defs::timingInfoDecoder value,
Positions pos) {
pimpl->Parallel(&Module::setTimingInfoDecoder, pos, value);
}
Result<defs::collectionMode> Detector::getCollectionMode(Positions pos) const {
return pimpl->Parallel(&Module::getCollectionMode, pos);
}
void Detector::setCollectionMode(defs::collectionMode value, Positions pos) {
pimpl->Parallel(&Module::setCollectionMode, pos, value);
}
// Gotthard Specific
Result<defs::ROI> Detector::getROI(Positions pos) const {
@@ -2079,7 +2112,9 @@ Result<int> Detector::getSYNCClock(Positions pos) const {
}
std::vector<defs::dacIndex> Detector::getPowerList() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD) {
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD &&
dettype != defs::XILINX_CHIPTESTBOARD) {
throw RuntimeError("Power list not implemented for this detector");
}
return std::vector<defs::dacIndex>{defs::V_POWER_A, defs::V_POWER_B,
@@ -2088,7 +2123,9 @@ std::vector<defs::dacIndex> Detector::getPowerList() const {
}
std::vector<defs::dacIndex> Detector::getSlowADCList() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD) {
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD &&
dettype != defs::XILINX_CHIPTESTBOARD) {
throw RuntimeError("Slow ADC list not implemented for this detector");
}
return std::vector<defs::dacIndex>{
@@ -2277,7 +2314,8 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
}
void Detector::setDacNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named dacs only for CTB");
pimpl->setCtbDacNames(names);
}
@@ -2285,7 +2323,7 @@ void Detector::setDacNames(const std::vector<std::string> names) {
std::vector<std::string> Detector::getDacNames() const {
std::vector<std::string> names;
auto type = getDetectorType().squash();
if (type == defs::CHIPTESTBOARD)
if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD)
return pimpl->getCtbDacNames();
for (const auto &index : getDacList())
@@ -2295,7 +2333,7 @@ std::vector<std::string> Detector::getDacNames() const {
defs::dacIndex Detector::getDacIndex(const std::string &name) const {
auto type = getDetectorType().squash();
if (type == defs::CHIPTESTBOARD) {
if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD) {
auto names = getDacNames();
auto it = std::find(names.begin(), names.end(), name);
if (it == names.end())
@@ -2306,32 +2344,36 @@ defs::dacIndex Detector::getDacIndex(const std::string &name) const {
}
void Detector::setDacName(const defs::dacIndex i, const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named dacs only for CTB");
pimpl->setCtbDacName(i, name);
}
std::string Detector::getDacName(const defs::dacIndex i) const {
auto type = getDetectorType().squash();
if (type == defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype == defs::CHIPTESTBOARD || dettype == defs::XILINX_CHIPTESTBOARD)
return pimpl->getCtbDacName(i);
return ToString(i);
}
void Detector::setAdcNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named adcs only for CTB");
pimpl->setCtbAdcNames(names);
}
std::vector<std::string> Detector::getAdcNames() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named adcs only for CTB");
return pimpl->getCtbAdcNames();
}
int Detector::getAdcIndex(const std::string &name) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named adcs only for CTB");
auto names = getAdcNames();
auto it = std::find(names.begin(), names.end(), name);
@@ -2341,31 +2383,36 @@ int Detector::getAdcIndex(const std::string &name) const {
}
void Detector::setAdcName(const int index, const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named adcs only for CTB");
pimpl->setCtbAdcName(index, name);
}
std::string Detector::getAdcName(const int i) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named adcs only for CTB");
return pimpl->getCtbAdcName(i);
}
void Detector::setSignalNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named signals only for CTB");
pimpl->setCtbSignalNames(names);
}
std::vector<std::string> Detector::getSignalNames() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named signals only for CTB");
return pimpl->getCtbSignalNames();
}
int Detector::getSignalIndex(const std::string &name) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named signals only for CTB");
auto names = getSignalNames();
auto it = std::find(names.begin(), names.end(), name);
@@ -2375,31 +2422,37 @@ int Detector::getSignalIndex(const std::string &name) const {
}
void Detector::setSignalName(const int index, const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named signals only for CTB");
pimpl->setCtbSignalName(index, name);
}
std::string Detector::getSignalName(const int i) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named signals only for CTB");
return pimpl->getCtbSignalName(i);
}
void Detector::setPowerNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (getDetectorType().squash() != defs::CHIPTESTBOARD &&
dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
pimpl->setCtbPowerNames(names);
}
std::vector<std::string> Detector::getPowerNames() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
return pimpl->getCtbPowerNames();
}
defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
auto names = getPowerNames();
auto it = std::find(names.begin(), names.end(), name);
@@ -2410,31 +2463,36 @@ defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
void Detector::setPowerName(const defs::dacIndex index,
const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
pimpl->setCtbPowerName(index, name);
}
std::string Detector::getPowerName(const defs::dacIndex i) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named powers only for CTB");
return pimpl->getCtbPowerName(i);
}
void Detector::setSlowADCNames(const std::vector<std::string> names) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named SlowADCs only for CTB");
pimpl->setCtbSlowADCNames(names);
}
std::vector<std::string> Detector::getSlowADCNames() const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named SlowADCs only for CTB");
return pimpl->getCtbSlowADCNames();
}
defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named SlowADCs only for CTB");
auto names = getSlowADCNames();
auto it = std::find(names.begin(), names.end(), name);
@@ -2445,17 +2503,25 @@ defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
void Detector::setSlowADCName(const defs::dacIndex index,
const std::string &name) {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named SlowADCs only for CTB");
pimpl->setCtbSlowADCName(index, name);
}
std::string Detector::getSlowADCName(const defs::dacIndex i) const {
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
auto dettype = getDetectorType().squash();
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
throw RuntimeError("Named SlowADCs only for CTB");
return pimpl->getCtbSlowADCName(i);
}
// Xilinx Ctb Specific
void Detector::configureTransceiver(Positions pos) {
pimpl->Parallel(&Module::configureTransceiver, pos);
}
// Pattern
Result<std::string> Detector::getPatterFileName(Positions pos) const {
@@ -2648,16 +2714,18 @@ Result<uint32_t> Detector::readRegister(uint32_t addr, Positions pos) const {
return pimpl->Parallel(&Module::readRegister, pos, addr);
}
void Detector::writeRegister(uint32_t addr, uint32_t val, Positions pos) {
pimpl->Parallel(&Module::writeRegister, pos, addr, val);
void Detector::writeRegister(uint32_t addr, uint32_t val, bool validate,
Positions pos) {
pimpl->Parallel(&Module::writeRegister, pos, addr, val, validate);
}
void Detector::setBit(uint32_t addr, int bitnr, Positions pos) {
pimpl->Parallel(&Module::setBit, pos, addr, bitnr);
void Detector::setBit(uint32_t addr, int bitnr, bool validate, Positions pos) {
pimpl->Parallel(&Module::setBit, pos, addr, bitnr, validate);
}
void Detector::clearBit(uint32_t addr, int bitnr, Positions pos) {
pimpl->Parallel(&Module::clearBit, pos, addr, bitnr);
void Detector::clearBit(uint32_t addr, int bitnr, bool validate,
Positions pos) {
pimpl->Parallel(&Module::clearBit, pos, addr, bitnr, validate);
}
Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) {

111
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@@ -37,8 +37,6 @@ DetectorImpl::DetectorImpl(int detector_index, bool verify, bool update)
setupDetector(verify, update);
}
DetectorImpl::~DetectorImpl() = default;
void DetectorImpl::setupDetector(bool verify, bool update) {
initSharedMemory(verify);
initializeMembers(verify);
@@ -59,51 +57,6 @@ void DetectorImpl::setAcquiringFlag(bool flag) { shm()->acquiringFlag = flag; }
int DetectorImpl::getDetectorIndex() const { return detectorIndex; }
void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
// single
if (detPos >= 0) {
SharedMemory<sharedModule> moduleShm(detectorIndex, detPos);
if (moduleShm.exists()) {
moduleShm.removeSharedMemory();
}
return;
}
// multi - get number of modules from shm
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
int numModules = 0;
if (detectorShm.exists()) {
detectorShm.openSharedMemory(false);
numModules = detectorShm()->totalNumberOfModules;
detectorShm.removeSharedMemory();
}
for (int i = 0; i < numModules; ++i) {
SharedMemory<sharedModule> moduleShm(detectorIndex, i);
moduleShm.removeSharedMemory();
}
SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
if (ctbShm.exists())
ctbShm.removeSharedMemory();
}
void DetectorImpl::freeSharedMemory() {
zmqSocket.clear();
for (auto &module : modules) {
module->freeSharedMemory();
}
modules.clear();
// clear detector shm
shm.removeSharedMemory();
client_downstream = false;
if (ctb_shm.exists())
ctb_shm.removeSharedMemory();
}
std::string DetectorImpl::getUserDetails() {
if (modules.empty()) {
return std::string("none");
@@ -242,24 +195,11 @@ std::string DetectorImpl::exec(const char *cmd) {
return result;
}
void DetectorImpl::setVirtualDetectorServers(const int numdet,
const uint16_t port) {
std::vector<std::string> hostnames;
for (int i = 0; i < numdet; ++i) {
// * 2 is for control and stop port
hostnames.push_back(std::string("localhost:") +
std::to_string(port + i * 2));
}
setHostname(hostnames);
bool DetectorImpl::hasModulesInSharedMemory() {
return (shm.exists() && shm()->totalNumberOfModules > 0);
}
void DetectorImpl::setHostname(const std::vector<std::string> &name) {
// do not free always to allow the previous detsize/ initialchecks command
if (shm.exists() && shm()->totalNumberOfModules != 0) {
LOG(logWARNING) << "There are already module(s) in shared memory."
"Freeing Shared memory now.";
freeSharedMemory();
}
// could be called after freeing shm from API
if (!shm.exists()) {
setupDetector();
@@ -272,7 +212,8 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
// Here we know the detector type and can add ctb shared memory
// if needed, CTB dac names are only on detector level
if (shm()->detType == defs::CHIPTESTBOARD) {
if (shm()->detType == defs::CHIPTESTBOARD ||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
if (ctb_shm.exists())
ctb_shm.openSharedMemory(true);
else
@@ -291,8 +232,8 @@ void DetectorImpl::addModule(const std::string &name) {
// gotthard cannot have more than 2 modules (50um=1, 25um=2
if ((type == GOTTHARD || type == GOTTHARD2) && modules.size() > 2) {
freeSharedMemory();
throw RuntimeError("Gotthard cannot have more than 2 modules");
throw RuntimeError("Gotthard cannot have more than 2 modules. Please "
"free the shared memory and start again.");
}
auto pos = modules.size();
@@ -336,7 +277,19 @@ void DetectorImpl::updateDetectorSize() {
if (detSizeX > 1 && detSizeX <= maxChanX) {
maxChanX = detSizeX;
}
if (maxChanX < modSize.x) {
std::stringstream os;
os << "The max det size in x dim (" << maxChanX
<< ") is less than the module size in x dim (" << modSize.x
<< "). Probably using shared memory of a different detector "
"type. Please free and try again.";
throw RuntimeError(os.str());
}
nModx = maxChanX / modSize.x;
if (nModx == 0) {
throw RuntimeError(
"number of modules in x dimension is 0. Unable to proceed.");
}
nMody = size() / nModx;
if ((maxChanX % modSize.x) > 0) {
++nMody;
@@ -350,7 +303,18 @@ void DetectorImpl::updateDetectorSize() {
if (detSizeY > 1 && detSizeY <= maxChanY) {
maxChanY = detSizeY;
}
if (maxChanY < modSize.y) {
std::stringstream os;
os << "The max det size in y dim (" << maxChanY
<< ") is less than the module size in y dim (" << modSize.y
<< "). Probably using shared memory of a different detector "
"type. Please free and try again.";
throw RuntimeError(os.str());
}
nMody = maxChanY / modSize.y;
if (nMody == 0)
throw RuntimeError(
"number of modules in y dimension is 0. Unable to proceed.");
nModx = size() / nMody;
if ((maxChanY % modSize.y) > 0) {
++nModx;
@@ -389,7 +353,8 @@ slsDetectorDefs::xy DetectorImpl::getNumberOfChannels() const {
}
void DetectorImpl::setNumberOfChannels(const slsDetectorDefs::xy c) {
if (size() > 1) {
// detsize is set before hostname
if (size() >= 1) {
throw RuntimeError(
"Set the number of channels before setting hostname.");
}
@@ -615,7 +580,7 @@ void DetectorImpl::readFrameFromReceiver() {
memset(multiframe.get(), 0xFF, multisize);
}
completeImage = (numZmqRunning == (int)zmqSocket.size());
completeImage = true;
// get each frame
for (unsigned int isocket = 0; isocket < zmqSocket.size(); ++isocket) {
@@ -632,7 +597,6 @@ void DetectorImpl::readFrameFromReceiver() {
// parse error, version error or end of acquisition for
// socket
runningList[isocket] = false;
completeImage = false;
--numZmqRunning;
continue;
}
@@ -711,7 +675,8 @@ void DetectorImpl::readFrameFromReceiver() {
uint32_t yoffset = coordY * nPixelsY;
uint32_t singledetrowoffset = nPixelsX * bytesPerPixel;
uint32_t rowoffset = nX * singledetrowoffset;
if (shm()->detType == CHIPTESTBOARD) {
if (shm()->detType == CHIPTESTBOARD ||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
singledetrowoffset = size;
}
LOG(logDEBUG1)
@@ -1382,7 +1347,7 @@ void DetectorImpl::stopDetector(Positions pos) {
void DetectorImpl::printProgress(double progress) {
// spaces for python printout
std::cout << " " << std::fixed << std::setprecision(2) << std::setw(6)
std::cout << " " << std::fixed << std::setprecision(2) << std::setw(10)
<< progress << " \%";
std::cout << '\r' << std::flush;
}
@@ -1744,7 +1709,8 @@ void DetectorImpl::verifyUniqueHost(
}
defs::ROI DetectorImpl::getRxROI() const {
if (shm()->detType == CHIPTESTBOARD) {
if (shm()->detType == CHIPTESTBOARD ||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
throw RuntimeError("RxRoi not implemented for this Detector");
}
if (modules.size() == 0) {
@@ -1819,7 +1785,8 @@ defs::ROI DetectorImpl::getRxROI() const {
}
void DetectorImpl::setRxROI(const defs::ROI arg) {
if (shm()->detType == CHIPTESTBOARD) {
if (shm()->detType == CHIPTESTBOARD ||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
throw RuntimeError("RxRoi not implemented for this Detector");
}
if (modules.size() == 0) {

24
slsDetectorSoftware/src/DetectorImpl.h
View File

@@ -5,6 +5,7 @@
#include "CtbConfig.h"
#include "SharedMemory.h"
#include "sls/Result.h"
#include "sls/ZmqSocket.h"
#include "sls/logger.h"
#include "sls/sls_detector_defs.h"
@@ -19,7 +20,6 @@
namespace sls {
class ZmqSocket;
class detectorData;
class Module;
@@ -79,11 +79,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
explicit DetectorImpl(int detector_index = 0, bool verify = true,
bool update = true);
/**
* Destructor
*/
virtual ~DetectorImpl();
template <class CT> struct NonDeduced { using type = CT; };
template <typename RT, typename... CT>
Result<RT> Parallel(RT (Module::*somefunc)(CT...),
@@ -198,14 +193,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
/** return detector index in shared memory */
int getDetectorIndex() const;
/** Free specific shared memory from the command line without creating
* object */
static void freeSharedMemory(int detectorIndex, int detPos = -1);
/** Free all modules from current multi Id shared memory and delete members
*/
void freeSharedMemory();
/** Get user details of shared memory */
std::string getUserDetails();
@@ -215,12 +202,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
* default enabled */
void setInitialChecks(const bool value);
/**
* Connect to Virtual Detector Servers at local host
* @param numdet number of modules
* @param port starting port number
*/
void setVirtualDetectorServers(const int numdet, const uint16_t port);
bool hasModulesInSharedMemory();
/** Sets the hostname of all sls modules in shared memory and updates
* local cache */
@@ -452,7 +434,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
/** data streaming (down stream) enabled in client (zmq sckets created) */
bool client_downstream{false};
std::vector<std::unique_ptr<ZmqSocket>> zmqSocket;
volatile int numZmqRunning{0};
std::atomic<int> numZmqRunning{0};
/** mutex to synchronize main and data processing threads */
mutable std::mutex mp;

319
slsDetectorSoftware/src/HelpDacs.cpp Normal file
View File

@@ -0,0 +1,319 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "sls/sls_detector_defs.h"
#include "sls/string_utils.h"
#include <sstream>
namespace sls {
std::string GetHelpDac(std::string dac) {
if (sls::is_int(dac)) {
return std::string("[dac name] [dac or mV value] [(optional unit) mV] "
"\n\t[Ctb] Use dac index for dac name.");
}
if (dac == "vthreshold") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger][Mythen3] "
"Detector threshold voltage for single photon counters.\n\t[Eiger] "
"Sets vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr and vcp to the same "
"value. \n\t[Mythen3] Sets vth1, vth2 and vth3 to the same value "
"for enabled counters.");
}
if (dac == "vsvp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? ");
}
if (dac == "vsvn") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define "
"feedback resistance of the first shaper");
}
if (dac == "vtrim") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? "
"\n\t[Mythen3] Dac for the voltage defining the trim bit size.");
}
if (dac == "vrpreamp") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define the "
"preamplifier feedback resistance.");
}
if (dac == "vrshaper") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define "
"feedback resistance of the first shaper");
}
if (dac == "vtgstv") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_ll") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_lr") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcal") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_rl") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_rr") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "rxb_rb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "rxb_lb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcn") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vishaper") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "iodelay") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vref_ds") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard][Jungfrau] Dac for ??");
}
if (dac == "vcascn_pb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vcascp_pb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vout_cm") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 5");
}
if (dac == "vcasc_out") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vin_cm") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 2");
}
if (dac == "vref_comp") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard][Jungfrau] Dac for ??");
}
if (dac == "ib_test_c") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vrshaper_n") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] voltage to "
"define feedback resistance of the second shaper.");
}
if (dac == "vipre") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"preamplifier's input transistor current.\n\t[Moench] Dac for 1");
}
if (dac == "vdcsh") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"reference (DC) voltage for the shaper.");
}
if (dac == "vth1") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for first "
"detector threshold voltage. Overwrites even if counter disabled.");
}
if (dac == "vth2") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
"second detector threshold voltage. Overwrites even if counter "
"disabled.");
}
if (dac == "vth3") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for third "
"detector threshold voltage. Overwrites even if counter disabled.");
}
if (dac == "vcal_n") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"low voltage for analog pulsing.");
}
if (dac == "vcal_p") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"high voltage for analog pulsing.");
}
if (dac == "vcassh") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"shaper's cascode voltage.");
}
if (dac == "vcas") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"preamplifier's cascode voltage.");
}
if (dac == "vicin") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"bias current for the comparator.");
}
if (dac == "vipre_out") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
"preamplifier's output transistor current.");
}
if (dac == "vref_h_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage high of ADC.");
}
if (dac == "vb_comp_fe") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"comparator current of analogue front end.");
}
if (dac == "vb_comp_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"comparator current of ADC.");
}
if (dac == "vcom_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of CDS stage.");
}
if (dac == "vref_rstore") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard2] Dac for reference charging voltage "
"of temparory storage cell in high gain.");
}
if (dac == "vb_opa_1st") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] dac dac for "
"opa current for driving the other DACs in chip.");
}
if (dac == "vref_comp_fe") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage of the comparator of analogue front end.");
}
if (dac == "vcom_adc1") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of ADC DAC bank 1.");
}
if (dac == "vref_prech") {
return std::string(
"[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard2][Jungfrau] "
"Dac for reference votlage for precharing the preamplifier.");
}
if (dac == "vref_l_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage low for ADC.");
}
if (dac == "vref_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage of CDS applied to the temporary storage cell in "
"medium and low gain.");
}
if (dac == "vb_cs") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"current injection into preamplifier.");
}
if (dac == "vb_opa_fd") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"current for CDS opa stage.");
}
if (dac == "vcom_adc2") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of ADC DAC bank 2.");
}
if (dac == "vb_ds") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vb_comp") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vb_pixbuf") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vin_com") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vdd_prot") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vbp_colbuf") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 0");
}
if (dac == "vb_sda") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 3");
}
if (dac == "vcasc_sfp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 4");
}
if (dac == "vipre_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 6");
}
if (dac == "ibias_sfp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 7");
}
// clang-format off
if (dac == "vtgstv") { return std::string(""); }
// clang-format on
throw sls::RuntimeError("Unknown dac command");
}
std::string GetHelpDacWrapper(const std::string &cmd,
const std::vector<std::string> &args) {
std::ostringstream os;
os << cmd << ' ';
if (args.size() == 0) {
os << GetHelpDac(std::to_string(0)) << '\n';
} else {
os << args[0] << ' ' << GetHelpDac(args[0]) << '\n';
}
return os.str();
}
} // namespace sls

302
slsDetectorSoftware/src/HelpDacs.h
View File

@@ -1,305 +1,13 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "sls/string_utils.h"
#include <string>
#include <vector>
namespace sls {
std::string GetHelpDac(std::string dac) {
if (sls::is_int(dac)) {
return std::string("[dac name] [dac or mV value] [(optional unit) mV] "
"\n\t[Ctb] Use dac index for dac name.");
}
if (dac == "vthreshold") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger][Mythen3] "
"Detector threshold voltage for single photon counters.\n\t[Eiger] "
"Sets vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr and vcp to the same "
"value. \n\t[Mythen3] Sets vth1, vth2 and vth3 to the same value "
"for enabled counters.");
}
if (dac == "vsvp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? ");
}
if (dac == "vsvn") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define "
"feedback resistance of the first shaper");
}
if (dac == "vtrim") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? "
"\n\t[Mythen3] Dac for the voltage defining the trim bit size.");
}
if (dac == "vrpreamp") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define the "
"preamplifier feedback resistance.");
}
if (dac == "vrshaper") {
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
"Dac for ?? \n\t[Mythen3] voltage to define "
"feedback resistance of the first shaper");
}
if (dac == "vtgstv") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_ll") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_lr") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcal") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_rl") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcmp_rr") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "rxb_rb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "rxb_lb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vcn") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vishaper") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "iodelay") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
}
if (dac == "vref_ds") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard][Jungfrau] Dac for ??");
}
if (dac == "vcascn_pb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vcascp_pb") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vout_cm") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 5");
}
if (dac == "vcasc_out") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vin_cm") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 2");
}
if (dac == "vref_comp") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard][Jungfrau] Dac for ??");
}
if (dac == "ib_test_c") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
}
if (dac == "vrshaper_n") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] voltage to "
"define feedback resistance of the second shaper.");
}
if (dac == "vipre") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"preamplifier's input transistor current.\n\t[Moench] Dac for 1");
}
if (dac == "vdcsh") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"reference (DC) voltage for the shaper.");
}
if (dac == "vth1") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for first "
"detector threshold voltage. Overwrites even if counter disabled.");
}
if (dac == "vth2") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
"second detector threshold voltage. Overwrites even if counter "
"disabled.");
}
if (dac == "vth3") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for third "
"detector threshold voltage. Overwrites even if counter disabled.");
}
if (dac == "vcal_n") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"low voltage for analog pulsing.");
}
if (dac == "vcal_p") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"high voltage for analog pulsing.");
}
if (dac == "vcassh") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"shaper's cascode voltage.");
}
if (dac == "vcas") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"preamplifier's cascode voltage.");
}
if (dac == "vicin") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
"bias current for the comparator.");
}
if (dac == "vipre_out") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
"preamplifier's output transistor current.");
}
if (dac == "vref_h_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage high of ADC.");
}
if (dac == "vb_comp_fe") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"comparator current of analogue front end.");
}
if (dac == "vb_comp_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"comparator current of ADC.");
}
if (dac == "vcom_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of CDS stage.");
}
if (dac == "vref_rstore") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard2] Dac for reference charging voltage "
"of temparory storage cell in high gain.");
}
if (dac == "vb_opa_1st") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] dac dac for "
"opa current for driving the other DACs in chip.");
}
if (dac == "vref_comp_fe") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage of the comparator of analogue front end.");
}
if (dac == "vcom_adc1") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of ADC DAC bank 1.");
}
if (dac == "vref_prech") {
return std::string(
"[dac or mV value][(optional unit) mV] "
"\n\t[Gotthard2][Jungfrau] "
"Dac for reference votlage for precharing the preamplifier.");
}
if (dac == "vref_l_adc") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage low for ADC.");
}
if (dac == "vref_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"reference voltage of CDS applied to the temporary storage cell in "
"medium and low gain.");
}
if (dac == "vb_cs") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"current injection into preamplifier.");
}
if (dac == "vb_opa_fd") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"current for CDS opa stage.");
}
if (dac == "vcom_adc2") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
"common mode voltage of ADC DAC bank 2.");
}
if (dac == "vb_ds") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vb_comp") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vb_pixbuf") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vin_com") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vdd_prot") {
return std::string("[dac or mV value][(optional unit) mV] "
"\n\t[Jungfrau] Dac for ??");
}
if (dac == "vbp_colbuf") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 0");
}
if (dac == "vb_sda") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 3");
}
if (dac == "vcasc_sfp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 4");
}
if (dac == "vipre_cds") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 6");
}
if (dac == "ibias_sfp") {
return std::string(
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 7");
}
std::string GetHelpDac(std::string dac);
// clang-format off
if (dac == "vtgstv") { return std::string(""); }
// clang-format on
throw sls::RuntimeError("Unknown dac command");
}
std::string GetHelpDacWrapper(const std::string &cmd,
const std::vector<std::string> &args);
} // namespace sls

100
slsDetectorSoftware/src/Module.cpp
View File

@@ -53,14 +53,6 @@ Module::Module(int det_id, int module_index, bool verify)
initSharedMemory(type, det_id, verify);
}
Module::~Module() = default;
void Module::freeSharedMemory() {
if (shm.exists()) {
shm.removeSharedMemory();
}
}
bool Module::isFixedPatternSharedMemoryCompatible() const {
return (shm()->shmversion >= MODULE_SHMAPIVERSION);
}
@@ -169,6 +161,7 @@ Module::getTypeFromDetector(const std::string &hostname, uint16_t cport) {
LOG(logDEBUG1) << "Getting Module type ";
ClientSocket socket("Detector", hostname, cport);
socket.Send(F_GET_DETECTOR_TYPE);
socket.setFnum(F_GET_DETECTOR_TYPE);
if (socket.Receive<int>() == FAIL) {
throw RuntimeError("Detector (" + hostname + ", " +
std::to_string(cport) +
@@ -184,7 +177,8 @@ slsDetectorDefs::detectorType Module::getDetectorType() const {
}
void Module::updateNumberOfChannels() {
if (shm()->detType == CHIPTESTBOARD) {
if (shm()->detType == CHIPTESTBOARD ||
shm()->detType == XILINX_CHIPTESTBOARD) {
std::array<int, 2> retvals{};
sendToDetector(F_GET_NUM_CHANNELS, nullptr, retvals);
shm()->nChan.x = retvals[0];
@@ -562,6 +556,7 @@ void Module::setSynchronization(const bool value) {
std::vector<int> Module::getBadChannels() const {
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_GET_BAD_CHANNELS);
client.setFnum(F_GET_BAD_CHANNELS);
if (client.Receive<int>() == FAIL) {
throw DetectorError("Detector " + std::to_string(moduleIndex) +
" returned error: " + client.readErrorMessage());
@@ -583,6 +578,7 @@ void Module::setBadChannels(std::vector<int> list) {
LOG(logDEBUG1) << "Sending bad channels to detector, nch:" << nch;
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_SET_BAD_CHANNELS);
client.setFnum(F_SET_BAD_CHANNELS);
client.Send(nch);
if (nch > 0) {
client.Send(list);
@@ -973,6 +969,7 @@ std::vector<int64_t> Module::getFramesCaughtByReceiver() const {
if (shm()->useReceiverFlag) {
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
client.Send(F_GET_RECEIVER_FRAMES_CAUGHT);
client.setFnum(F_GET_RECEIVER_FRAMES_CAUGHT);
if (client.Receive<int>() == FAIL) {
throw ReceiverError(
"Receiver " + std::to_string(moduleIndex) +
@@ -995,6 +992,7 @@ std::vector<int64_t> Module::getNumMissingPackets() const {
if (shm()->useReceiverFlag) {
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
client.Send(F_GET_NUM_MISSING_PACKETS);
client.setFnum(F_GET_NUM_MISSING_PACKETS);
if (client.Receive<int>() == FAIL) {
throw ReceiverError(
"Receiver " + std::to_string(moduleIndex) +
@@ -1017,6 +1015,7 @@ std::vector<int64_t> Module::getReceiverCurrentFrameIndex() const {
if (shm()->useReceiverFlag) {
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
client.Send(F_GET_RECEIVER_FRAME_INDEX);
client.setFnum(F_GET_RECEIVER_FRAME_INDEX);
if (client.Receive<int>() == FAIL) {
throw ReceiverError(
"Receiver " + std::to_string(moduleIndex) +
@@ -1428,8 +1427,8 @@ void Module::setReceiverHostname(const std::string &hostname,
shm()->numUDPInterfaces = retval.udpInterfaces;
// to use rx_hostname if empty and also update client zmqip
updateReceiverStreamingIP();
// to use rx_hostname if empty
updateClientStreamingIP();
}
uint16_t Module::getReceiverPort() const { return shm()->rxTCPPort; }
@@ -1655,21 +1654,6 @@ void Module::setReceiverStreamingPort(uint16_t port) {
sendToReceiver(F_SET_RECEIVER_STREAMING_PORT, port, nullptr);
}
IpAddr Module::getReceiverStreamingIP() const {
return sendToReceiver<IpAddr>(F_GET_RECEIVER_STREAMING_SRC_IP);
}
void Module::setReceiverStreamingIP(const IpAddr ip) {
if (ip == 0) {
throw RuntimeError("Invalid receiver zmq ip address");
}
// if client zmqip is empty, update it
if (shm()->zmqip == 0) {
shm()->zmqip = ip;
}
sendToReceiver(F_SET_RECEIVER_STREAMING_SRC_IP, ip, nullptr);
}
uint16_t Module::getClientStreamingPort() const { return shm()->zmqport; }
void Module::setClientStreamingPort(uint16_t port) { shm()->zmqport = port; }
@@ -1748,6 +1732,7 @@ void Module::sendReceiverRateCorrections(const std::vector<int64_t> &t) {
<< ']';
auto receiver = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
receiver.Send(F_SET_RECEIVER_RATE_CORRECT);
receiver.setFnum(F_SET_RECEIVER_RATE_CORRECT);
receiver.Send(static_cast<int>(t.size()));
receiver.Send(t);
if (receiver.Receive<int>() == FAIL) {
@@ -1954,6 +1939,22 @@ void Module::setPedestalMode(const defs::pedestalParameters par) {
}
}
defs::timingInfoDecoder Module::getTimingInfoDecoder() const {
return sendToDetector<defs::timingInfoDecoder>(F_GET_TIMING_INFO_DECODER);
}
void Module::setTimingInfoDecoder(const defs::timingInfoDecoder value) {
sendToDetector(F_SET_TIMING_INFO_DECODER, static_cast<int>(value), nullptr);
}
defs::collectionMode Module::getCollectionMode() const {
return sendToDetector<defs::collectionMode>(F_GET_COLLECTION_MODE);
}
void Module::setCollectionMode(const defs::collectionMode value) {
sendToDetector(F_SET_COLLECTION_MODE, static_cast<int>(value), nullptr);
}
// Gotthard Specific
slsDetectorDefs::ROI Module::getROI() const {
@@ -2028,6 +2029,7 @@ void Module::sendVetoPhoton(const int chipIndex,
const int args[]{chipIndex, nch};
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_SET_VETO_PHOTON);
client.setFnum(F_SET_VETO_PHOTON);
client.Send(args);
client.Send(gainIndices);
client.Send(values);
@@ -2042,6 +2044,7 @@ void Module::getVetoPhoton(const int chipIndex,
LOG(logDEBUG1) << "Getting veto photon [" << chipIndex << "]\n";
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_GET_VETO_PHOTON);
client.setFnum(F_GET_VETO_PHOTON);
client.Send(chipIndex);
if (client.Receive<int>() == FAIL) {
throw DetectorError("Detector " + std::to_string(moduleIndex) +
@@ -2461,7 +2464,8 @@ void Module::setReadoutMode(const slsDetectorDefs::readoutMode mode) {
sendToDetector(F_SET_READOUT_MODE, arg, nullptr);
sendToDetectorStop(F_SET_READOUT_MODE, arg, nullptr);
// update #nchan, as it depends on #samples, adcmask,
if (shm()->detType == CHIPTESTBOARD) {
if (shm()->detType == CHIPTESTBOARD ||
shm()->detType == XILINX_CHIPTESTBOARD) {
updateNumberOfChannels();
}
if (shm()->useReceiverFlag) {
@@ -2529,6 +2533,13 @@ void Module::setLEDEnable(bool enable) {
sendToDetector<int>(F_LED, static_cast<int>(enable));
}
// Xilinx Ctb Specific
void Module::configureTransceiver() {
sendToDetector(F_CONFIG_TRANSCEIVER);
LOG(logINFO) << "Module " << moduleIndex << " (" << shm()->hostname
<< "): Transceiver configured successfully!";
}
// Pattern
std::string Module::getPatterFileName() const {
char retval[MAX_STR_LENGTH]{};
@@ -2539,6 +2550,7 @@ std::string Module::getPatterFileName() const {
void Module::setPattern(const Pattern &pat, const std::string &fname) {
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_SET_PATTERN);
client.setFnum(F_SET_PATTERN);
client.Send(pat.data(), pat.size());
char args[MAX_STR_LENGTH]{};
strcpy_safe(args, fname.c_str());
@@ -2649,6 +2661,7 @@ std::map<std::string, std::string> Module::getAdditionalJsonHeader() const {
}
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
client.Send(F_GET_ADDITIONAL_JSON_HEADER);
client.setFnum(F_GET_ADDITIONAL_JSON_HEADER);
if (client.Receive<int>() == FAIL) {
throw ReceiverError("Receiver " + std::to_string(moduleIndex) +
" returned error: " + client.readErrorMessage());
@@ -2694,6 +2707,7 @@ void Module::setAdditionalJsonHeader(
<< ToString(jsonHeader);
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
client.Send(F_SET_ADDITIONAL_JSON_HEADER);
client.setFnum(F_SET_ADDITIONAL_JSON_HEADER);
client.Send(size);
if (size > 0)
client.Send(&buff[0], buff.size());
@@ -2817,18 +2831,20 @@ uint32_t Module::readRegister(uint32_t addr) const {
return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr);
}
uint32_t Module::writeRegister(uint32_t addr, uint32_t val) {
uint32_t args[]{addr, val};
return sendToDetectorStop<uint32_t>(F_WRITE_REGISTER, args);
void Module::writeRegister(uint32_t addr, uint32_t val, bool validate) {
uint32_t args[]{addr, val, static_cast<uint32_t>(validate)};
return sendToDetectorStop(F_WRITE_REGISTER, args, nullptr);
}
void Module::setBit(uint32_t addr, int n) {
uint32_t args[2] = {addr, static_cast<uint32_t>(n)};
void Module::setBit(uint32_t addr, int n, bool validate) {
uint32_t args[] = {addr, static_cast<uint32_t>(n),
static_cast<uint32_t>(validate)};
sendToDetectorStop(F_SET_BIT, args, nullptr);
}
void Module::clearBit(uint32_t addr, int n) {
uint32_t args[2] = {addr, static_cast<uint32_t>(n)};
void Module::clearBit(uint32_t addr, int n, bool validate) {
uint32_t args[] = {addr, static_cast<uint32_t>(n),
static_cast<uint32_t>(validate)};
sendToDetectorStop(F_CLEAR_BIT, args, nullptr);
}
@@ -2887,6 +2903,7 @@ std::string Module::executeCommand(const std::string &cmd) {
<< "): Sending command " << cmd;
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_EXEC_COMMAND);
client.setFnum(F_EXEC_COMMAND);
client.Send(arg);
if (client.Receive<int>() == FAIL) {
std::cout << '\n';
@@ -3413,6 +3430,8 @@ const std::string Module::getDetectorAPI() const {
return APIMYTHEN3;
case GOTTHARD2:
return APIGOTTHARD2;
case XILINX_CHIPTESTBOARD:
return APIXILINXCTB;
default:
throw NotImplementedError(
"Detector type not implemented to get Detector API");
@@ -3497,6 +3516,7 @@ void Module::setModule(sls_detector_module &module, bool trimbits) {
}
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_SET_MODULE);
client.setFnum(F_SET_MODULE);
sendModule(&module, client);
if (client.Receive<int>() == FAIL) {
throw DetectorError("Module " + std::to_string(moduleIndex) +
@@ -3509,6 +3529,7 @@ sls_detector_module Module::getModule() {
sls_detector_module module(shm()->detType);
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.Send(F_GET_MODULE);
client.setFnum(F_GET_MODULE);
if (client.Receive<int>() == FAIL) {
throw DetectorError("Module " + std::to_string(moduleIndex) +
" returned error: " + client.readErrorMessage());
@@ -3601,18 +3622,19 @@ void Module::receiveModule(sls_detector_module *myMod, ClientSocket &client) {
LOG(level) << myMod->nchan << " chans received";
}
void Module::updateReceiverStreamingIP() {
auto ip = getReceiverStreamingIP();
void Module::updateClientStreamingIP() {
auto ip = getClientStreamingIP();
if (ip == 0) {
// Hostname could be ip try to decode otherwise look up the hostname
ip = IpAddr{shm()->rxHostname};
if (ip == 0) {
ip = HostnameToIp(shm()->rxHostname);
}
LOG(logINFO) << "Setting default receiver " << moduleIndex
<< " streaming zmq ip to " << ip;
LOG(logINFO) << "Setting default module " << moduleIndex
<< " zmq ip to " << ip;
setClientStreamingIP(ip);
}
setReceiverStreamingIP(ip);
}
void Module::updateRateCorrection() {

27
slsDetectorSoftware/src/Module.h
View File

@@ -75,12 +75,6 @@ class Module : public virtual slsDetectorDefs {
verify is if shared memory version matches existing one */
explicit Module(int det_id = 0, int module_index = 0, bool verify = true);
virtual ~Module();
/** Frees shared memory and deletes shared memory structure
Safe to call only if detector shm also deleted or its numberOfModules is
updated */
void freeSharedMemory();
bool isFixedPatternSharedMemoryCompatible() const;
std::string getHostname() const;
@@ -351,8 +345,6 @@ class Module : public virtual slsDetectorDefs {
void setReceiverStreamingStartingFrame(int fnum);
uint16_t getReceiverStreamingPort() const;
void setReceiverStreamingPort(uint16_t port);
IpAddr getReceiverStreamingIP() const;
void setReceiverStreamingIP(const IpAddr ip);
uint16_t getClientStreamingPort() const;
void setClientStreamingPort(uint16_t port);
IpAddr getClientStreamingIP() const;
@@ -421,6 +413,10 @@ class Module : public virtual slsDetectorDefs {
void setNumberOfFilterCells(int value);
defs::pedestalParameters getPedestalMode() const;
void setPedestalMode(defs::pedestalParameters par);
defs::timingInfoDecoder getTimingInfoDecoder() const;
void setTimingInfoDecoder(const defs::timingInfoDecoder enable);
defs::collectionMode getCollectionMode() const;
void setCollectionMode(const defs::collectionMode enable);
/**************************************************
* *
@@ -528,6 +524,13 @@ class Module : public virtual slsDetectorDefs {
bool getLEDEnable() const;
void setLEDEnable(bool enable);
/**************************************************
* *
* Xilinx Ctb Specific *
* *
* ************************************************/
void configureTransceiver();
/**************************************************
* *
* Pattern *
@@ -584,9 +587,9 @@ class Module : public virtual slsDetectorDefs {
bool getUpdateMode() const;
void setUpdateMode(const bool updatemode);
uint32_t readRegister(uint32_t addr) const;
uint32_t writeRegister(uint32_t addr, uint32_t val);
void setBit(uint32_t addr, int n);
void clearBit(uint32_t addr, int n);
void writeRegister(uint32_t addr, uint32_t val, bool validate);
void setBit(uint32_t addr, int n, bool validate);
void clearBit(uint32_t addr, int n, bool validate);
int getBit(uint32_t addr, int n);
void executeFirmwareTest();
void executeBusTest();
@@ -759,7 +762,7 @@ class Module : public virtual slsDetectorDefs {
sls_detector_module getModule();
void sendModule(sls_detector_module *myMod, ClientSocket &client);
void receiveModule(sls_detector_module *myMod, ClientSocket &client);
void updateReceiverStreamingIP();
void updateClientStreamingIP();
void updateRateCorrection();
/** Template function to do linear interpolation between two points (Eiger

8
slsDetectorSoftware/src/Pattern.cpp
View File

@@ -149,7 +149,7 @@ void Pattern::load(const std::string &fname) {
level = StringTo<int>(args[iArg++]);
} else {
LOG(logWARNING)
<< "Depreciated command. Please use patloop next time.";
<< "Deprecated command. Please use patloop next time.";
if (nargs != 2) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
@@ -174,7 +174,7 @@ void Pattern::load(const std::string &fname) {
}
level = StringTo<int>(args[iArg++]);
} else {
LOG(logWARNING) << "Depreciated command. Please use "
LOG(logWARNING) << "Deprecated command. Please use "
"patnloop next time.";
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
@@ -198,7 +198,7 @@ void Pattern::load(const std::string &fname) {
level = StringTo<int>(args[iArg++]);
} else {
LOG(logWARNING)
<< "Depreciated command. Please use patwait next time.";
<< "Deprecated command. Please use patwait next time.";
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
@@ -220,7 +220,7 @@ void Pattern::load(const std::string &fname) {
}
level = StringTo<int>(args[iArg++]);
} else {
LOG(logWARNING) << "Depreciated command. Please use "
LOG(logWARNING) << "Deprecated command. Please use "
"patwaittime next time.";
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +

4684
slsDetectorSoftware/src/inferAction.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

689
slsDetectorSoftware/src/inferAction.h Normal file
View File

@@ -0,0 +1,689 @@
#include "CmdParser.h"
#include <iostream>
#include <map>
#include <vector>
namespace sls {
class InferAction {
public:
InferAction() {}
int infer(sls::CmdParser &parser, std::ostream &os = std::cout);
std::vector<std::string> args;
std::string cmd;
// generated functions
int acquire();
int activate();
int adcclk();
int adcenable();
int adcenable10g();
int adcindex();
int adcinvert();
int adclist();
int adcname();
int adcphase();
int adcpipeline();
int adcreg();
int adcvpp();
int apulse();
int asamples();
int autocompdisable();
int badchannels();
int blockingtrigger();
int burstmode();
int burstperiod();
int bursts();
int burstsl();
int bustest();
int cdsgain();
int chipversion();
int clearbit();
int clearbusy();
int clearroi();
int clientversion();
int clkdiv();
int clkfreq();
int clkphase();
int collectionmode();
int column();
int compdisabletime();
int confadc();
int config();
int configtransceiver();
int counters();
int currentsource();
int dac();
int dacindex();
int daclist();
int dacname();
int dacvalues();
int datastream();
int dbitclk();
int dbitphase();
int dbitpipeline();
int defaultdac();
int defaultpattern();
int delay();
int delayl();
int detectorserverversion();
int detsize();
int diodelay();
int dpulse();
int dr();
int drlist();
int dsamples();
int execcommand();
int exptime();
int exptime1();
int exptime2();
int exptime3();
int exptimel();
int extrastoragecells();
int extsampling();
int extsamplingsrc();
int extsig();
int fformat();
int filtercells();
int filterresistor();
int findex();
int firmwaretest();
int firmwareversion();
int fliprows();
int flowcontrol10g();
int fmaster();
int fname();
int foverwrite();
int fpath();
int framecounter();
int frames();
int framesl();
int frametime();
int free();
int fwrite();
int gaincaps();
int gainmode();
int gappixels();
int gatedelay();
int gatedelay1();
int gatedelay2();
int gatedelay3();
int gates();
int getbit();
int hardwareversion();
int highvoltage();
int hostname();
int im_a();
int im_b();
int im_c();
int im_d();
int im_io();
int imagetest();
int initialchecks();
int inj_ch();
int interpolation();
int interruptsubframe();
int kernelversion();
int lastclient();
int led();
int lock();
int master();
int maxadcphaseshift();
int maxclkphaseshift();
int maxdbitphaseshift();
int measuredperiod();
int measuredsubperiod();
int moduleid();
int nextframenumber();
int nmod();
int numinterfaces();
int overflow();
int packageversion();
int parallel();
int parameters();
int partialreset();
int patfname();
int patioctrl();
int patlimits();
int patloop();
int patloop0();
int patloop1();
int patloop2();
int patmask();
int patnloop();
int patnloop0();
int patnloop1();
int patnloop2();
int patsetbit();
int pattern();
int patternstart();
int patwait();
int patwait0();
int patwait1();
int patwait2();
int patwaittime();
int patwaittime0();
int patwaittime1();
int patwaittime2();
int patword();
int pedestalmode();
int period();
int periodl();
int polarity();
int port();
int powerchip();
int powerindex();
int powerlist();
int powername();
int powervalues();
int programfpga();
int pulse();
int pulsechip();
int pulsenmove();
int pumpprobe();
int quad();
int ratecorr();
int readnrows();
int readout();
int readoutspeed();
int readoutspeedlist();
int rebootcontroller();
int reg();
int resetdacs();
int resetfpga();
int roi();
int romode();
int row();
int runclk();
int runtime();
int rx_arping();
int rx_clearroi();
int rx_dbitlist();
int rx_dbitoffset();
int rx_discardpolicy();
int rx_fifodepth();
int rx_frameindex();
int rx_framescaught();
int rx_framesperfile();
int rx_hostname();
int rx_jsonaddheader();
int rx_jsonpara();
int rx_lastclient();
int rx_lock();
int rx_missingpackets();
int rx_padding();
int rx_printconfig();
int rx_realudpsocksize();
int rx_roi();
int rx_silent();
int rx_start();
int rx_status();
int rx_stop();
int rx_tcpport();
int rx_threads();
int rx_udpsocksize();
int rx_version();
int rx_zmqfreq();
int rx_zmqhwm();
int rx_zmqip();
int rx_zmqport();
int rx_zmqstartfnum();
int rx_zmqstream();
int samples();
int savepattern();
int scan();
int scanerrmsg();
int selinterface();
int serialnumber();
int setbit();
int settings();
int settingslist();
int settingspath();
int signalindex();
int signallist();
int signalname();
int sleep();
int slowadc();
int slowadcindex();
int slowadclist();
int slowadcname();
int slowadcvalues();
int start();
int status();
int stop();
int stopport();
int storagecell_delay();
int storagecell_start();
int subdeadtime();
int subexptime();
int sync();
int syncclk();
int temp_10ge();
int temp_adc();
int temp_control();
int temp_dcdc();
int temp_event();
int temp_fpga();
int temp_fpgaext();
int temp_fpgafl();
int temp_fpgafr();
int temp_slowadc();
int temp_sodl();
int temp_sodr();
int temp_threshold();
int templist();
int tempvalues();
int tengiga();
int threshold();
int timing();
int timing_info_decoder();
int timinglist();
int timingsource();
int top();
int transceiverenable();
int trigger();
int triggers();
int triggersl();
int trimbits();
int trimen();
int trimval();
int tsamples();
int txdelay();
int txdelay_frame();
int txdelay_left();
int txdelay_right();
int type();
int udp_cleardst();
int udp_dstip();
int udp_dstip2();
int udp_dstlist();
int udp_dstmac();
int udp_dstmac2();
int udp_dstport();
int udp_dstport2();
int udp_firstdst();
int udp_numdst();
int udp_reconfigure();
int udp_srcip();
int udp_srcip2();
int udp_srcmac();
int udp_srcmac2();
int udp_validate();
int update();
int updatedetectorserver();
int updatekernel();
int updatemode();
int user();
int v_a();
int v_b();
int v_c();
int v_chip();
int v_d();
int v_io();
int v_limit();
int vchip_comp_adc();
int vchip_comp_fe();
int vchip_cs();
int vchip_opa_1st();
int vchip_opa_fd();
int vchip_ref_comp_fe();
int versions();
int veto();
int vetoalg();
int vetofile();
int vetophoton();
int vetoref();
int vetostream();
int virtualFunction();
int vm_a();
int vm_b();
int vm_c();
int vm_d();
int vm_io();
int zmqhwm();
int zmqip();
int zmqport();
// int frames();
private:
using FunctionMap = std::map<std::string, int (InferAction::*)()>;
FunctionMap functions{
// generated functions
{"acquire", &InferAction::acquire},
{"activate", &InferAction::activate},
{"adcclk", &InferAction::adcclk},
{"adcenable", &InferAction::adcenable},
{"adcenable10g", &InferAction::adcenable10g},
{"adcindex", &InferAction::adcindex},
{"adcinvert", &InferAction::adcinvert},
{"adclist", &InferAction::adclist},
{"adcname", &InferAction::adcname},
{"adcphase", &InferAction::adcphase},
{"adcpipeline", &InferAction::adcpipeline},
{"adcreg", &InferAction::adcreg},
{"adcvpp", &InferAction::adcvpp},
{"apulse", &InferAction::apulse},
{"asamples", &InferAction::asamples},
{"autocompdisable", &InferAction::autocompdisable},
{"badchannels", &InferAction::badchannels},
{"blockingtrigger", &InferAction::blockingtrigger},
{"burstmode", &InferAction::burstmode},
{"burstperiod", &InferAction::burstperiod},
{"bursts", &InferAction::bursts},
{"burstsl", &InferAction::burstsl},
{"bustest", &InferAction::bustest},
{"cdsgain", &InferAction::cdsgain},
{"chipversion", &InferAction::chipversion},
{"clearbit", &InferAction::clearbit},
{"clearbusy", &InferAction::clearbusy},
{"clearroi", &InferAction::clearroi},
{"clientversion", &InferAction::clientversion},
{"clkdiv", &InferAction::clkdiv},
{"clkfreq", &InferAction::clkfreq},
{"clkphase", &InferAction::clkphase},
{"collectionmode", &InferAction::collectionmode},
{"column", &InferAction::column},
{"compdisabletime", &InferAction::compdisabletime},
{"confadc", &InferAction::confadc},
{"config", &InferAction::config},
{"configtransceiver", &InferAction::configtransceiver},
{"counters", &InferAction::counters},
{"currentsource", &InferAction::currentsource},
{"dac", &InferAction::dac},
{"dacindex", &InferAction::dacindex},
{"daclist", &InferAction::daclist},
{"dacname", &InferAction::dacname},
{"dacvalues", &InferAction::dacvalues},
{"datastream", &InferAction::datastream},
{"dbitclk", &InferAction::dbitclk},
{"dbitphase", &InferAction::dbitphase},
{"dbitpipeline", &InferAction::dbitpipeline},
{"defaultdac", &InferAction::defaultdac},
{"defaultpattern", &InferAction::defaultpattern},
{"delay", &InferAction::delay},
{"delayl", &InferAction::delayl},
{"detectorserverversion", &InferAction::detectorserverversion},
{"detsize", &InferAction::detsize},
{"diodelay", &InferAction::diodelay},
{"dpulse", &InferAction::dpulse},
{"dr", &InferAction::dr},
{"drlist", &InferAction::drlist},
{"dsamples", &InferAction::dsamples},
{"execcommand", &InferAction::execcommand},
{"exptime", &InferAction::exptime},
{"exptime1", &InferAction::exptime1},
{"exptime2", &InferAction::exptime2},
{"exptime3", &InferAction::exptime3},
{"exptimel", &InferAction::exptimel},
{"extrastoragecells", &InferAction::extrastoragecells},
{"extsampling", &InferAction::extsampling},
{"extsamplingsrc", &InferAction::extsamplingsrc},
{"extsig", &InferAction::extsig},
{"fformat", &InferAction::fformat},
{"filtercells", &InferAction::filtercells},
{"filterresistor", &InferAction::filterresistor},
{"findex", &InferAction::findex},
{"firmwaretest", &InferAction::firmwaretest},
{"firmwareversion", &InferAction::firmwareversion},
{"fliprows", &InferAction::fliprows},
{"flowcontrol10g", &InferAction::flowcontrol10g},
{"fmaster", &InferAction::fmaster},
{"fname", &InferAction::fname},
{"foverwrite", &InferAction::foverwrite},
{"fpath", &InferAction::fpath},
{"framecounter", &InferAction::framecounter},
{"frames", &InferAction::frames},
{"framesl", &InferAction::framesl},
{"frametime", &InferAction::frametime},
{"free", &InferAction::free},
{"fwrite", &InferAction::fwrite},
{"gaincaps", &InferAction::gaincaps},
{"gainmode", &InferAction::gainmode},
{"gappixels", &InferAction::gappixels},
{"gatedelay", &InferAction::gatedelay},
{"gatedelay1", &InferAction::gatedelay1},
{"gatedelay2", &InferAction::gatedelay2},
{"gatedelay3", &InferAction::gatedelay3},
{"gates", &InferAction::gates},
{"getbit", &InferAction::getbit},
{"hardwareversion", &InferAction::hardwareversion},
{"highvoltage", &InferAction::highvoltage},
{"hostname", &InferAction::hostname},
{"im_a", &InferAction::im_a},
{"im_b", &InferAction::im_b},
{"im_c", &InferAction::im_c},
{"im_d", &InferAction::im_d},
{"im_io", &InferAction::im_io},
{"imagetest", &InferAction::imagetest},
{"initialchecks", &InferAction::initialchecks},
{"inj_ch", &InferAction::inj_ch},
{"interpolation", &InferAction::interpolation},
{"interruptsubframe", &InferAction::interruptsubframe},
{"kernelversion", &InferAction::kernelversion},
{"lastclient", &InferAction::lastclient},
{"led", &InferAction::led},
{"lock", &InferAction::lock},
{"master", &InferAction::master},
{"maxadcphaseshift", &InferAction::maxadcphaseshift},
{"maxclkphaseshift", &InferAction::maxclkphaseshift},
{"maxdbitphaseshift", &InferAction::maxdbitphaseshift},
{"measuredperiod", &InferAction::measuredperiod},
{"measuredsubperiod", &InferAction::measuredsubperiod},
{"moduleid", &InferAction::moduleid},
{"nextframenumber", &InferAction::nextframenumber},
{"nmod", &InferAction::nmod},
{"numinterfaces", &InferAction::numinterfaces},
{"overflow", &InferAction::overflow},
{"packageversion", &InferAction::packageversion},
{"parallel", &InferAction::parallel},
{"parameters", &InferAction::parameters},
{"partialreset", &InferAction::partialreset},
{"patfname", &InferAction::patfname},
{"patioctrl", &InferAction::patioctrl},
{"patlimits", &InferAction::patlimits},
{"patloop", &InferAction::patloop},
{"patloop0", &InferAction::patloop0},
{"patloop1", &InferAction::patloop1},
{"patloop2", &InferAction::patloop2},
{"patmask", &InferAction::patmask},
{"patnloop", &InferAction::patnloop},
{"patnloop0", &InferAction::patnloop0},
{"patnloop1", &InferAction::patnloop1},
{"patnloop2", &InferAction::patnloop2},
{"patsetbit", &InferAction::patsetbit},
{"patternX", &InferAction::pattern},
{"patternstart", &InferAction::patternstart},
{"patwait", &InferAction::patwait},
{"patwait0", &InferAction::patwait0},
{"patwait1", &InferAction::patwait1},
{"patwait2", &InferAction::patwait2},
{"patwaittime", &InferAction::patwaittime},
{"patwaittime0", &InferAction::patwaittime0},
{"patwaittime1", &InferAction::patwaittime1},
{"patwaittime2", &InferAction::patwaittime2},
{"patword", &InferAction::patword},
{"pedestalmode", &InferAction::pedestalmode},
{"period", &InferAction::period},
{"periodl", &InferAction::periodl},
{"polarity", &InferAction::polarity},
{"port", &InferAction::port},
{"powerchip", &InferAction::powerchip},
{"powerindex", &InferAction::powerindex},
{"powerlist", &InferAction::powerlist},
{"powername", &InferAction::powername},
{"powervalues", &InferAction::powervalues},
{"programfpga", &InferAction::programfpga},
{"pulse", &InferAction::pulse},
{"pulsechip", &InferAction::pulsechip},
{"pulsenmove", &InferAction::pulsenmove},
{"pumpprobe", &InferAction::pumpprobe},
{"quad", &InferAction::quad},
{"ratecorr", &InferAction::ratecorr},
{"readnrows", &InferAction::readnrows},
{"readout", &InferAction::readout},
{"readoutspeed", &InferAction::readoutspeed},
{"readoutspeedlist", &InferAction::readoutspeedlist},
{"rebootcontroller", &InferAction::rebootcontroller},
{"reg", &InferAction::reg},
{"resetdacs", &InferAction::resetdacs},
{"resetfpga", &InferAction::resetfpga},
{"roi", &InferAction::roi},
{"romode", &InferAction::romode},
{"row", &InferAction::row},
{"runclk", &InferAction::runclk},
{"runtime", &InferAction::runtime},
{"rx_arping", &InferAction::rx_arping},
{"rx_clearroi", &InferAction::rx_clearroi},
{"rx_dbitlist", &InferAction::rx_dbitlist},
{"rx_dbitoffset", &InferAction::rx_dbitoffset},
{"rx_discardpolicy", &InferAction::rx_discardpolicy},
{"rx_fifodepth", &InferAction::rx_fifodepth},
{"rx_frameindex", &InferAction::rx_frameindex},
{"rx_framescaught", &InferAction::rx_framescaught},
{"rx_framesperfile", &InferAction::rx_framesperfile},
{"rx_hostname", &InferAction::rx_hostname},
{"rx_jsonaddheader", &InferAction::rx_jsonaddheader},
{"rx_jsonpara", &InferAction::rx_jsonpara},
{"rx_lastclient", &InferAction::rx_lastclient},
{"rx_lock", &InferAction::rx_lock},
{"rx_missingpackets", &InferAction::rx_missingpackets},
{"rx_padding", &InferAction::rx_padding},
{"rx_printconfig", &InferAction::rx_printconfig},
{"rx_realudpsocksize", &InferAction::rx_realudpsocksize},
{"rx_roi", &InferAction::rx_roi},
{"rx_silent", &InferAction::rx_silent},
{"rx_start", &InferAction::rx_start},
{"rx_status", &InferAction::rx_status},
{"rx_stop", &InferAction::rx_stop},
{"rx_tcpport", &InferAction::rx_tcpport},
{"rx_threads", &InferAction::rx_threads},
{"rx_udpsocksize", &InferAction::rx_udpsocksize},
{"rx_version", &InferAction::rx_version},
{"rx_zmqfreq", &InferAction::rx_zmqfreq},
{"rx_zmqhwm", &InferAction::rx_zmqhwm},
{"rx_zmqip", &InferAction::rx_zmqip},
{"rx_zmqport", &InferAction::rx_zmqport},
{"rx_zmqstartfnum", &InferAction::rx_zmqstartfnum},
{"rx_zmqstream", &InferAction::rx_zmqstream},
{"samples", &InferAction::samples},
{"savepattern", &InferAction::savepattern},
{"scan", &InferAction::scan},
{"scanerrmsg", &InferAction::scanerrmsg},
{"selinterface", &InferAction::selinterface},
{"serialnumber", &InferAction::serialnumber},
{"setbit", &InferAction::setbit},
{"settings", &InferAction::settings},
{"settingslist", &InferAction::settingslist},
{"settingspath", &InferAction::settingspath},
{"signalindex", &InferAction::signalindex},
{"signallist", &InferAction::signallist},
{"signalname", &InferAction::signalname},
{"sleep", &InferAction::sleep},
{"slowadc", &InferAction::slowadc},
{"slowadcindex", &InferAction::slowadcindex},
{"slowadclist", &InferAction::slowadclist},
{"slowadcname", &InferAction::slowadcname},
{"slowadcvalues", &InferAction::slowadcvalues},
{"start", &InferAction::start},
{"status", &InferAction::status},
{"stop", &InferAction::stop},
{"stopport", &InferAction::stopport},
{"storagecell_delay", &InferAction::storagecell_delay},
{"storagecell_start", &InferAction::storagecell_start},
{"subdeadtime", &InferAction::subdeadtime},
{"subexptime", &InferAction::subexptime},
{"sync", &InferAction::sync},
{"syncclk", &InferAction::syncclk},
{"temp_10ge", &InferAction::temp_10ge},
{"temp_adc", &InferAction::temp_adc},
{"temp_control", &InferAction::temp_control},
{"temp_dcdc", &InferAction::temp_dcdc},
{"temp_event", &InferAction::temp_event},
{"temp_fpga", &InferAction::temp_fpga},
{"temp_fpgaext", &InferAction::temp_fpgaext},
{"temp_fpgafl", &InferAction::temp_fpgafl},
{"temp_fpgafr", &InferAction::temp_fpgafr},
{"temp_slowadc", &InferAction::temp_slowadc},
{"temp_sodl", &InferAction::temp_sodl},
{"temp_sodr", &InferAction::temp_sodr},
{"temp_threshold", &InferAction::temp_threshold},
{"templist", &InferAction::templist},
{"tempvalues", &InferAction::tempvalues},
{"tengiga", &InferAction::tengiga},
{"threshold", &InferAction::threshold},
{"thresholdnotb", &InferAction::threshold},
{"timing", &InferAction::timing},
{"timing_info_decoder", &InferAction::timing_info_decoder},
{"timinglist", &InferAction::timinglist},
{"timingsource", &InferAction::timingsource},
{"top", &InferAction::top},
{"transceiverenable", &InferAction::transceiverenable},
{"trigger", &InferAction::trigger},
{"triggers", &InferAction::triggers},
{"triggersl", &InferAction::triggersl},
{"trimbits", &InferAction::trimbits},
{"trimen", &InferAction::trimen},
{"trimval", &InferAction::trimval},
{"tsamples", &InferAction::tsamples},
{"txdelay", &InferAction::txdelay},
{"txdelay_frame", &InferAction::txdelay_frame},
{"txdelay_left", &InferAction::txdelay_left},
{"txdelay_right", &InferAction::txdelay_right},
{"type", &InferAction::type},
{"udp_cleardst", &InferAction::udp_cleardst},
{"udp_dstip", &InferAction::udp_dstip},
{"udp_dstip2", &InferAction::udp_dstip2},
{"udp_dstlist", &InferAction::udp_dstlist},
{"udp_dstmac", &InferAction::udp_dstmac},
{"udp_dstmac2", &InferAction::udp_dstmac2},
{"udp_dstport", &InferAction::udp_dstport},
{"udp_dstport2", &InferAction::udp_dstport2},
{"udp_firstdst", &InferAction::udp_firstdst},
{"udp_numdst", &InferAction::udp_numdst},
{"udp_reconfigure", &InferAction::udp_reconfigure},
{"udp_srcip", &InferAction::udp_srcip},
{"udp_srcip2", &InferAction::udp_srcip2},
{"udp_srcmac", &InferAction::udp_srcmac},
{"udp_srcmac2", &InferAction::udp_srcmac2},
{"udp_validate", &InferAction::udp_validate},
{"update", &InferAction::update},
{"updatedetectorserver", &InferAction::updatedetectorserver},
{"updatekernel", &InferAction::updatekernel},
{"updatemode", &InferAction::updatemode},
{"user", &InferAction::user},
{"v_a", &InferAction::v_a},
{"v_b", &InferAction::v_b},
{"v_c", &InferAction::v_c},
{"v_chip", &InferAction::v_chip},
{"v_d", &InferAction::v_d},
{"v_io", &InferAction::v_io},
{"v_limit", &InferAction::v_limit},
{"vchip_comp_adc", &InferAction::vchip_comp_adc},
{"vchip_comp_fe", &InferAction::vchip_comp_fe},
{"vchip_cs", &InferAction::vchip_cs},
{"vchip_opa_1st", &InferAction::vchip_opa_1st},
{"vchip_opa_fd", &InferAction::vchip_opa_fd},
{"vchip_ref_comp_fe", &InferAction::vchip_ref_comp_fe},
{"versions", &InferAction::versions},
{"veto", &InferAction::veto},
{"vetoalg", &InferAction::vetoalg},
{"vetofile", &InferAction::vetofile},
{"vetophoton", &InferAction::vetophoton},
{"vetoref", &InferAction::vetoref},
{"vetostream", &InferAction::vetostream},
{"virtual", &InferAction::virtualFunction},
{"vm_a", &InferAction::vm_a},
{"vm_b", &InferAction::vm_b},
{"vm_c", &InferAction::vm_c},
{"vm_d", &InferAction::vm_d},
{"vm_io", &InferAction::vm_io},
{"zmqhwm", &InferAction::zmqhwm},
{"zmqip", &InferAction::zmqip},
{"zmqport", &InferAction::zmqport}
// {"frames",&InferAction::frames}
};
};
} // namespace sls

32
slsDetectorSoftware/tests/CMakeLists.txt
View File

@@ -1,29 +1,39 @@
# SPDX-License-Identifier: LGPL-3.0-or-other
# Copyright (C) 2021 Contributors to the SLS Detector Package
target_sources(tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test-SharedMemory.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-slsDetector.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-rx.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-pattern.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-eiger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-jungfrau.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-mythen3.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-gotthard2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-gotthard.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-chiptestboard.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-moench.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-global.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-rx.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-pattern.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-eiger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-jungfrau.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-mythen3.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-gotthard2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-gotthard.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-chiptestboard.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-xilinx-chiptestboard.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-moench.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-global.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-Result.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdParser.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-Module.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-Pattern.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CtbConfig.cpp
)
target_include_directories(tests
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>"
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include/sls>"
PRIVATE
${SLS_INTERNAL_RAPIDJSON_DIR}
)

870
slsDetectorSoftware/tests/test-CmdProxy-chiptestboard.cpp → slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp
View File

File diff suppressed because it is too large Load Diff

426
slsDetectorSoftware/tests/test-CmdProxy-eiger.cpp → slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
@@ -9,7 +9,7 @@
#include <thread>
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
@@ -19,137 +19,143 @@ using test::PUT;
/** temperature */
TEST_CASE("temp_fpgaext", "[.cmd]") {
TEST_CASE("temp_fpgaext", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_fpgaext", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_fpgaext", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_fpgaext "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_fpgaext", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_fpgaext", {}, -1, GET));
}
}
TEST_CASE("temp_10ge", "[.cmd]") {
TEST_CASE("temp_10ge", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_10ge", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_10ge", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_10ge", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_10ge", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_10ge "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_10ge", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_10ge", {}, -1, GET));
}
}
TEST_CASE("temp_dcdc", "[.cmd]") {
TEST_CASE("temp_dcdc", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_dcdc", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_dcdc", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_dcdc "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_dcdc", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_dcdc", {}, -1, GET));
}
}
TEST_CASE("temp_sodl", "[.cmd]") {
TEST_CASE("temp_sodl", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_sodl", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_sodl", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_sodl", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_sodl", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_sodl "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_sodl", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_sodl", {}, -1, GET));
}
}
TEST_CASE("temp_sodr", "[.cmd]") {
TEST_CASE("temp_sodr", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_sodr", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_sodr", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_sodr", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_sodr", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_sodr "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_sodr", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_sodr", {}, -1, GET));
}
}
TEST_CASE("temp_fpgafl", "[.cmd]") {
TEST_CASE("temp_fpgafl", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_fpgafl", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_fpgafl", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_fpgafl "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_fpgafl", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_fpgafl", {}, -1, GET));
}
}
TEST_CASE("temp_fpgafr", "[.cmd]") {
TEST_CASE("temp_fpgafr", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_NOTHROW(proxy.Call("temp_fpgafr", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, -1, GET));
std::ostringstream oss;
REQUIRE_NOTHROW(proxy.Call("temp_fpgafr", {}, 0, GET, oss));
REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, 0, GET, oss));
std::string s = (oss.str()).erase(0, strlen("temp_fpgafr "));
REQUIRE(std::stoi(s) != -1);
} else {
REQUIRE_THROWS(proxy.Call("temp_fpgafr", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_fpgafr", {}, -1, GET));
}
}
/* dacs */
TEST_CASE("Setting and reading back EIGER dacs", "[.cmd][.dacs]") {
TEST_CASE("Setting and reading back EIGER dacs", "[.cmdcall][.dacs]") {
// vsvp, vtr, vrf, vrs, vsvn, vtgstv, vcmp_ll, vcmp_lr, vcal, vcmp_rl,
// rxb_rb, rxb_lb, vcmp_rr, vcp, vcn, vis, vthreshold
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
SECTION("vsvp") { test_dac(defs::VSVP, "vsvp", 5); }
SECTION("vtrim") { test_dac(defs::VTRIM, "vtrim", 1200); }
SECTION("vrpreamp") { test_dac(defs::VRPREAMP, "vrpreamp", 1500); }
SECTION("vrshaper") { test_dac(defs::VRSHAPER, "vrshaper", 1510); }
SECTION("vsvn") { test_dac(defs::VSVN, "vsvn", 3800); }
SECTION("vtgstv") { test_dac(defs::VTGSTV, "vtgstv", 2550); }
SECTION("vcmp_ll") { test_dac(defs::VCMP_LL, "vcmp_ll", 1400); }
SECTION("vcmp_lr") { test_dac(defs::VCMP_LR, "vcmp_lr", 1400); }
SECTION("vcal") { test_dac(defs::VCAL, "vcal", 1400); }
SECTION("vcmp_rl") { test_dac(defs::VCMP_RL, "vcmp_rl", 1400); }
SECTION("rxb_rb") { test_dac(defs::RXB_RB, "rxb_rb", 1400); }
SECTION("rxb_lb") { test_dac(defs::RXB_LB, "rxb_lb", 1400); }
SECTION("vcmp_rr") { test_dac(defs::VCMP_RR, "vcmp_rr", 1400); }
SECTION("vcp") { test_dac(defs::VCP, "vcp", 1400); }
SECTION("vcn") { test_dac(defs::VCN, "vcn", 1400); }
SECTION("vishaper") { test_dac(defs::VISHAPER, "vishaper", 1400); }
SECTION("iodelay") { test_dac(defs::IO_DELAY, "iodelay", 1400); }
SECTION("vsvp") { test_dac_caller(defs::VSVP, "vsvp", 5); }
SECTION("vtrim") { test_dac_caller(defs::VTRIM, "vtrim", 1200); }
SECTION("vrpreamp") {
test_dac_caller(defs::VRPREAMP, "vrpreamp", 1500);
}
SECTION("vrshaper") {
test_dac_caller(defs::VRSHAPER, "vrshaper", 1510);
}
SECTION("vsvn") { test_dac_caller(defs::VSVN, "vsvn", 3800); }
SECTION("vtgstv") { test_dac_caller(defs::VTGSTV, "vtgstv", 2550); }
SECTION("vcmp_ll") { test_dac_caller(defs::VCMP_LL, "vcmp_ll", 1400); }
SECTION("vcmp_lr") { test_dac_caller(defs::VCMP_LR, "vcmp_lr", 1400); }
SECTION("vcal") { test_dac_caller(defs::VCAL, "vcal", 1400); }
SECTION("vcmp_rl") { test_dac_caller(defs::VCMP_RL, "vcmp_rl", 1400); }
SECTION("rxb_rb") { test_dac_caller(defs::RXB_RB, "rxb_rb", 1400); }
SECTION("rxb_lb") { test_dac_caller(defs::RXB_LB, "rxb_lb", 1400); }
SECTION("vcmp_rr") { test_dac_caller(defs::VCMP_RR, "vcmp_rr", 1400); }
SECTION("vcp") { test_dac_caller(defs::VCP, "vcp", 1400); }
SECTION("vcn") { test_dac_caller(defs::VCN, "vcn", 1400); }
SECTION("vishaper") {
test_dac_caller(defs::VISHAPER, "vishaper", 1400);
}
SECTION("iodelay") { test_dac_caller(defs::IO_DELAY, "iodelay", 1400); }
SECTION("vthreshold") {
// Read out individual vcmp to be able to reset after
// the test is done
@@ -161,12 +167,12 @@ TEST_CASE("Setting and reading back EIGER dacs", "[.cmd][.dacs]") {
{
std::ostringstream oss;
proxy.Call("vthreshold", {"1234"}, -1, PUT, oss);
caller.call("dac", {"vthreshold", "1234"}, -1, PUT, oss);
REQUIRE(oss.str() == "dac vthreshold 1234\n");
}
{
std::ostringstream oss;
proxy.Call("vthreshold", {}, -1, GET, oss);
caller.call("dac", {"vthreshold"}, -1, GET, oss);
REQUIRE(oss.str() == "dac vthreshold 1234\n");
}
@@ -180,54 +186,54 @@ TEST_CASE("Setting and reading back EIGER dacs", "[.cmd][.dacs]") {
}
}
// gotthard
REQUIRE_THROWS(proxy.Call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascp_pb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcasc_out", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vin_cm", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("ib_test_c", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascp_pb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcasc_out", {}, -1, GET));
REQUIRE_THROWS(caller.call("vin_cm", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("ib_test_c", {}, -1, GET));
// mythen3
// REQUIRE_THROWS(proxy.Call("vrpreamp", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper_n", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vipre", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vishaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth2", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth3", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_p", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vtrim", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcassh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcas", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vicin", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vipre_out", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vrpreamp", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper_n", {}, -1, GET));
REQUIRE_THROWS(caller.call("vipre", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vishaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth2", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth3", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_p", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vtrim", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcassh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcas", {}, -1, GET));
REQUIRE_THROWS(caller.call("vicin", {}, -1, GET));
REQUIRE_THROWS(caller.call("vipre_out", {}, -1, GET));
// gotthard2
REQUIRE_THROWS(proxy.Call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc2", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc2", {}, -1, GET));
// jungfrau
REQUIRE_THROWS(proxy.Call("vb_comp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vdd_prot", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vin_com", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_prech", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_pixbuf", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vdd_prot", {}, -1, GET));
REQUIRE_THROWS(caller.call("vin_com", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_prech", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_pixbuf", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp", {}, -1, GET));
}
}
@@ -235,116 +241,116 @@ TEST_CASE("Setting and reading back EIGER dacs", "[.cmd][.dacs]") {
/* Network Configuration (Detector<->Receiver) */
TEST_CASE("txdelay_left", "[.cmd]") {
TEST_CASE("txdelay_left", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getTransmissionDelayLeft();
{
std::ostringstream oss1, oss2;
proxy.Call("txdelay_left", {"5000"}, -1, PUT, oss1);
caller.call("txdelay_left", {"5000"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "txdelay_left 5000\n");
proxy.Call("txdelay_left", {}, -1, GET, oss2);
caller.call("txdelay_left", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "txdelay_left 5000\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTransmissionDelayLeft(prev_val[i]);
}
} else {
REQUIRE_THROWS(proxy.Call("txdelay_left", {}, -1, GET));
REQUIRE_THROWS(caller.call("txdelay_left", {}, -1, GET));
}
}
TEST_CASE("txdelay_right", "[.cmd]") {
TEST_CASE("txdelay_right", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getTransmissionDelayRight();
{
std::ostringstream oss1, oss2;
proxy.Call("txdelay_right", {"5000"}, -1, PUT, oss1);
caller.call("txdelay_right", {"5000"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "txdelay_right 5000\n");
proxy.Call("txdelay_right", {}, -1, GET, oss2);
caller.call("txdelay_right", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "txdelay_right 5000\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTransmissionDelayRight(prev_val[i]);
}
} else {
REQUIRE_THROWS(proxy.Call("txdelay_right", {}, -1, GET));
REQUIRE_THROWS(caller.call("txdelay_right", {}, -1, GET));
}
}
/* Eiger Specific */
TEST_CASE("subexptime", "[.cmd]") {
TEST_CASE("subexptime", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto time = det.getSubExptime();
std::ostringstream oss1, oss2;
proxy.Call("subexptime", {"2.5us"}, -1, PUT, oss1);
caller.call("subexptime", {"2.5us"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "subexptime 2.5us\n");
proxy.Call("subexptime", {}, -1, GET, oss2);
caller.call("subexptime", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "subexptime 2.5us\n");
for (int i = 0; i != det.size(); ++i) {
det.setSubExptime(time[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("subexptime", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("subexptime", {"2.13"}, -1, PUT));
REQUIRE_THROWS(caller.call("subexptime", {}, -1, GET));
REQUIRE_THROWS(caller.call("subexptime", {"2.13"}, -1, PUT));
}
}
TEST_CASE("subdeadtime", "[.cmd]") {
TEST_CASE("subdeadtime", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto time = det.getSubDeadTime();
std::ostringstream oss1, oss2;
proxy.Call("subdeadtime", {"500us"}, -1, PUT, oss1);
caller.call("subdeadtime", {"500us"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "subdeadtime 500us\n");
proxy.Call("subdeadtime", {}, -1, GET, oss2);
caller.call("subdeadtime", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "subdeadtime 500us\n");
for (int i = 0; i != det.size(); ++i) {
det.setSubDeadTime(time[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("subdeadtime", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("subdeadtime", {"2.13"}, -1, PUT));
REQUIRE_THROWS(caller.call("subdeadtime", {}, -1, GET));
REQUIRE_THROWS(caller.call("subdeadtime", {"2.13"}, -1, PUT));
}
}
TEST_CASE("overflow", "[.cmd]") {
TEST_CASE("overflow", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto previous = det.getOverFlowMode();
std::ostringstream oss1, oss2, oss3;
proxy.Call("overflow", {"1"}, -1, PUT, oss1);
caller.call("overflow", {"1"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "overflow 1\n");
proxy.Call("overflow", {}, -1, GET, oss2);
caller.call("overflow", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "overflow 1\n");
proxy.Call("overflow", {"0"}, -1, PUT, oss3);
caller.call("overflow", {"0"}, -1, PUT, oss3);
REQUIRE(oss3.str() == "overflow 0\n");
for (int i = 0; i != det.size(); ++i) {
det.setOverFlowMode(previous[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("overflow", {}, -1, GET));
REQUIRE_THROWS(caller.call("overflow", {}, -1, GET));
}
}
TEST_CASE("ratecorr", "[.cmd]") {
TEST_CASE("ratecorr", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_dr = det.getDynamicRange().tsquash("inconsistent dr to test");
@@ -352,19 +358,19 @@ TEST_CASE("ratecorr", "[.cmd]") {
det.setDynamicRange(16);
{
std::ostringstream oss;
proxy.Call("ratecorr", {"120"}, -1, PUT, oss);
caller.call("ratecorr", {"120"}, -1, PUT, oss);
REQUIRE(oss.str() == "ratecorr 120ns\n");
}
{
std::ostringstream oss;
proxy.Call("ratecorr", {}, -1, GET, oss);
caller.call("ratecorr", {}, -1, GET, oss);
REQUIRE(oss.str() == "ratecorr 120ns\n");
}
// may fail if default settings not loaded
// REQUIRE_NOTHROW(proxy.Call("ratecorr", {"-1"}, -1, PUT));
// REQUIRE_NOTHROW(caller.call("ratecorr", {"-1"}, -1, PUT));
{
std::ostringstream oss;
proxy.Call("ratecorr", {"0"}, -1, PUT, oss);
caller.call("ratecorr", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "ratecorr 0ns\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -372,37 +378,37 @@ TEST_CASE("ratecorr", "[.cmd]") {
}
det.setDynamicRange(prev_dr);
} else {
REQUIRE_THROWS(proxy.Call("ratecorr", {}, -1, GET));
REQUIRE_THROWS(caller.call("ratecorr", {}, -1, GET));
}
}
TEST_CASE("interruptsubframe", "[.cmd]") {
TEST_CASE("interruptsubframe", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getInterruptSubframe();
std::ostringstream oss1, oss2, oss3;
proxy.Call("interruptsubframe", {"1"}, -1, PUT, oss1);
caller.call("interruptsubframe", {"1"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "interruptsubframe 1\n");
proxy.Call("interruptsubframe", {}, -1, GET, oss2);
caller.call("interruptsubframe", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "interruptsubframe 1\n");
proxy.Call("interruptsubframe", {"0"}, -1, PUT, oss3);
caller.call("interruptsubframe", {"0"}, -1, PUT, oss3);
REQUIRE(oss3.str() == "interruptsubframe 0\n");
for (int i = 0; i != det.size(); ++i) {
det.setInterruptSubframe(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("interruptsubframe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("interruptsubframe", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("interruptsubframe", {}, -1, GET));
REQUIRE_THROWS(caller.call("interruptsubframe", {"1"}, -1, PUT));
}
}
TEST_CASE("measuredperiod", "[.cmd]") {
TEST_CASE("measuredperiod", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_frames = det.getNumberOfFrames().tsquash(
@@ -416,7 +422,7 @@ TEST_CASE("measuredperiod", "[.cmd]") {
det.startDetector();
std::this_thread::sleep_for(std::chrono::seconds(3));
std::ostringstream oss;
proxy.Call("measuredperiod", {}, -1, GET, oss);
caller.call("measuredperiod", {}, -1, GET, oss);
std::string st = oss.str();
std::string s;
if (st.find('[') != std::string::npos) {
@@ -433,13 +439,13 @@ TEST_CASE("measuredperiod", "[.cmd]") {
det.setNumberOfFrames(prev_frames);
det.setTimingMode(prev_timing);
} else {
REQUIRE_THROWS(proxy.Call("measuredperiod", {}, -1, GET));
REQUIRE_THROWS(caller.call("measuredperiod", {}, -1, GET));
}
}
TEST_CASE("measuredsubperiod", "[.cmd]") {
TEST_CASE("measuredsubperiod", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_frames = det.getNumberOfFrames().tsquash(
@@ -455,7 +461,7 @@ TEST_CASE("measuredsubperiod", "[.cmd]") {
det.startDetector();
std::this_thread::sleep_for(std::chrono::seconds(3));
std::ostringstream oss;
proxy.Call("measuredsubperiod", {}, -1, GET, oss);
caller.call("measuredsubperiod", {}, -1, GET, oss);
std::string st = oss.str();
std::string s;
if (st.find('[') != std::string::npos) {
@@ -473,29 +479,29 @@ TEST_CASE("measuredsubperiod", "[.cmd]") {
det.setTimingMode(prev_timing);
det.setDynamicRange(prev_dr);
} else {
REQUIRE_THROWS(proxy.Call("measuredsubperiod", {}, -1, GET));
REQUIRE_THROWS(caller.call("measuredsubperiod", {}, -1, GET));
}
}
TEST_CASE("activate", "[.cmd]") {
TEST_CASE("activate", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getActive();
{
std::ostringstream oss;
proxy.Call("activate", {"1"}, -1, PUT, oss);
caller.call("activate", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "activate 1\n");
}
{
std::ostringstream oss;
proxy.Call("activate", {}, -1, GET, oss);
caller.call("activate", {}, -1, GET, oss);
REQUIRE(oss.str() == "activate 1\n");
}
{
std::ostringstream oss;
proxy.Call("activate", {"0"}, -1, PUT, oss);
caller.call("activate", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "activate 0\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -503,137 +509,137 @@ TEST_CASE("activate", "[.cmd]") {
}
} else {
REQUIRE_THROWS(proxy.Call("activate", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("activate", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("activate", {}, -1, GET));
REQUIRE_THROWS(caller.call("activate", {"1"}, -1, PUT));
}
}
TEST_CASE("partialreset", "[.cmd]") {
TEST_CASE("partialreset", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getPartialReset();
std::ostringstream oss1, oss2, oss3;
proxy.Call("partialreset", {"1"}, -1, PUT, oss1);
caller.call("partialreset", {"1"}, -1, PUT, oss1);
REQUIRE(oss1.str() == "partialreset 1\n");
proxy.Call("partialreset", {}, -1, GET, oss2);
caller.call("partialreset", {}, -1, GET, oss2);
REQUIRE(oss2.str() == "partialreset 1\n");
proxy.Call("partialreset", {"0"}, -1, PUT, oss3);
caller.call("partialreset", {"0"}, -1, PUT, oss3);
REQUIRE(oss3.str() == "partialreset 0\n");
for (int i = 0; i != det.size(); ++i) {
det.setPartialReset(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("partialreset", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("partialreset", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("partialreset", {}, -1, GET));
REQUIRE_THROWS(caller.call("partialreset", {"1"}, -1, PUT));
}
}
TEST_CASE("pulse", "[.cmd]") {
TEST_CASE("pulse", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_THROWS(proxy.Call("pulse", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulse", {}, -1, GET));
std::ostringstream oss;
proxy.Call("pulse", {"1", "1", "5"}, -1, PUT, oss);
caller.call("pulse", {"1", "1", "5"}, -1, PUT, oss);
REQUIRE(oss.str() == "pulse [1, 1, 5]\n");
} else {
REQUIRE_THROWS(proxy.Call("pulse", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("pulse", {"1", "1", "5"}, -1, PUT));
REQUIRE_THROWS(caller.call("pulse", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulse", {"1", "1", "5"}, -1, PUT));
}
}
TEST_CASE("pulsenmove", "[.cmd]") {
TEST_CASE("pulsenmove", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_THROWS(proxy.Call("pulsenmove", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulsenmove", {}, -1, GET));
std::ostringstream oss;
proxy.Call("pulsenmove", {"1", "1", "5"}, -1, PUT, oss);
caller.call("pulsenmove", {"1", "1", "5"}, -1, PUT, oss);
REQUIRE(oss.str() == "pulsenmove [1, 1, 5]\n");
} else {
REQUIRE_THROWS(proxy.Call("pulsenmove", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("pulsenmove", {"1", "1", "5"}, -1, PUT));
REQUIRE_THROWS(caller.call("pulsenmove", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulsenmove", {"1", "1", "5"}, -1, PUT));
}
}
TEST_CASE("pulsechip", "[.cmd]") {
TEST_CASE("pulsechip", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
REQUIRE_THROWS(proxy.Call("pulsechip", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulsechip", {}, -1, GET));
std::ostringstream oss;
proxy.Call("pulsechip", {"1"}, -1, PUT, oss);
caller.call("pulsechip", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "pulsechip 1\n");
} else {
REQUIRE_THROWS(proxy.Call("pulsechip", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("pulsechip", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("pulsechip", {}, -1, GET));
REQUIRE_THROWS(caller.call("pulsechip", {"1"}, -1, PUT));
}
}
TEST_CASE("quad", "[.cmd]") {
TEST_CASE("quad", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getQuad().tsquash("inconsistent quad to test");
// Quad only works with a single half module EIGER
std::ostringstream oss;
proxy.Call("quad", {}, -1, GET, oss);
caller.call("quad", {}, -1, GET, oss);
REQUIRE(oss.str() == "quad 0\n");
det.setQuad(prev_val);
} else {
REQUIRE_THROWS(proxy.Call("quad", {}, -1, GET));
REQUIRE_THROWS(caller.call("quad", {}, -1, GET));
}
}
TEST_CASE("datastream", "[.cmd]") {
TEST_CASE("datastream", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val_left = det.getDataStream(defs::LEFT);
auto prev_val_right = det.getDataStream(defs::RIGHT);
// no "left" or "right"
REQUIRE_THROWS(proxy.Call("datastream", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("datastream", {"1"}, -1, PUT));
{
std::ostringstream oss;
proxy.Call("datastream", {"left", "0"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream left 0\n");
caller.call("datastream", {"left", "0"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream [left, 0]\n");
}
{
std::ostringstream oss;
proxy.Call("datastream", {"right", "0"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream right 0\n");
caller.call("datastream", {"right", "0"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream [right, 0]\n");
}
{
std::ostringstream oss;
proxy.Call("datastream", {"left", "1"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream left 1\n");
caller.call("datastream", {"left", "1"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream [left, 1]\n");
}
{
std::ostringstream oss;
proxy.Call("datastream", {"right", "1"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream right 1\n");
caller.call("datastream", {"right", "1"}, -1, PUT, oss);
REQUIRE(oss.str() == "datastream [right, 1]\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setDataStream(defs::LEFT, prev_val_left[i], {i});
det.setDataStream(defs::RIGHT, prev_val_right[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("datastream", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("datastream", {"1"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("datastream", {"left", "1"}, -1, PUT));
REQUIRE_THROWS(caller.call("datastream", {}, -1, GET));
REQUIRE_THROWS(caller.call("datastream", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("datastream", {"left", "1"}, -1, PUT));
}
}
TEST_CASE("top", "[.cmd]") {
TEST_CASE("top", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::EIGER) {
auto prev_val = det.getTop();
@@ -643,19 +649,19 @@ TEST_CASE("top", "[.cmd]") {
}
for (int i = 0; i != numModulesTested; ++i) {
std::ostringstream oss1, oss2, oss3;
proxy.Call("top", {"1"}, i, PUT, oss1);
caller.call("top", {"1"}, i, PUT, oss1);
REQUIRE(oss1.str() == "top 1\n");
proxy.Call("top", {}, i, GET, oss2);
caller.call("top", {}, i, GET, oss2);
REQUIRE(oss2.str() == "top 1\n");
proxy.Call("top", {"0"}, i, PUT, oss3);
caller.call("top", {"0"}, i, PUT, oss3);
REQUIRE(oss3.str() == "top 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTop(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("top", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("top", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("top", {}, -1, GET));
REQUIRE_THROWS(caller.call("top", {"1"}, -1, PUT));
}
}

44
slsDetectorSoftware/tests/test-CmdProxy-global.cpp → slsDetectorSoftware/tests/Caller/test-Caller-global.cpp
View File

@@ -1,7 +1,7 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "test-CmdProxy-global.h"
#include "CmdProxy.h"
#include "test-Caller-global.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "tests/globals.h"
@@ -10,12 +10,11 @@ namespace sls {
using test::GET;
using test::PUT;
void test_valid_port(const std::string &command,
const std::vector<std::string> &arguments, int detector_id,
int action) {
void test_valid_port_caller(const std::string &command,
const std::vector<std::string> &arguments,
int detector_id, int action) {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
std::vector<std::string> arg(arguments);
if (arg.empty())
@@ -25,33 +24,34 @@ void test_valid_port(const std::string &command,
for (int i = 0; i != 3; ++i) {
int port_number = test_values[i];
arg[arg.size() - 1] = std::to_string(port_number);
REQUIRE_THROWS(proxy.Call(command, arg, detector_id, action));
REQUIRE_THROWS(caller.call(command, arg, detector_id, action));
/*REQUIRE_THROWS_WITH(proxy.Call(command, arguments, detector_id,
action), "Invalid port range. Must be between 1 - 65535.");*/
}
}
void test_dac(defs::dacIndex index, const std::string &dacname, int dacvalue) {
void test_dac_caller(defs::dacIndex index, const std::string &dacname,
int dacvalue) {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
std::ostringstream oss_set, oss_get;
auto dacstr = std::to_string(dacvalue);
auto previous = det.getDAC(index, false);
// chip test board
if (dacname == "dac") {
auto dacIndexstr = std::to_string(static_cast<int>(index));
proxy.Call(dacname, {dacIndexstr, dacstr}, -1, PUT, oss_set);
caller.call(dacname, {dacIndexstr, dacstr}, -1, PUT, oss_set);
REQUIRE(oss_set.str() ==
dacname + " " + dacIndexstr + " " + dacstr + "\n");
proxy.Call(dacname, {dacIndexstr}, -1, GET, oss_get);
caller.call(dacname, {dacIndexstr}, -1, GET, oss_get);
REQUIRE(oss_get.str() ==
dacname + " " + dacIndexstr + " " + dacstr + "\n");
}
// other detectors
else {
proxy.Call("dac", {dacname, dacstr}, -1, PUT, oss_set);
caller.call("dac", {dacname, dacstr}, -1, PUT, oss_set);
REQUIRE(oss_set.str() == "dac " + dacname + " " + dacstr + "\n");
proxy.Call("dac", {dacname}, -1, GET, oss_get);
caller.call("dac", {dacname}, -1, GET, oss_get);
REQUIRE(oss_get.str() == "dac " + dacname + " " + dacstr + "\n");
}
// Reset all dacs to previous value
@@ -60,25 +60,25 @@ void test_dac(defs::dacIndex index, const std::string &dacname, int dacvalue) {
}
}
void test_onchip_dac(defs::dacIndex index, const std::string &dacname,
int dacvalue) {
void test_onchip_dac_caller(defs::dacIndex index, const std::string &dacname,
int dacvalue) {
Detector det;
CmdProxy proxy(&det);
REQUIRE_THROWS(proxy.Call(dacname, {}, -1, GET));
Caller caller(&det);
REQUIRE_THROWS(caller.call(dacname, {}, -1, GET));
REQUIRE_THROWS(
proxy.Call(dacname, {"10", "0x0"}, -1, PUT)); // chip index (-1 to 9)
caller.call(dacname, {"10", "0x0"}, -1, PUT)); // chip index (-1 to 9)
REQUIRE_THROWS(
proxy.Call(dacname, {"-1", "0x400"}, -1, PUT)); // max val is 0x3ff
caller.call(dacname, {"-1", "0x400"}, -1, PUT)); // max val is 0x3ff
int chipIndex = -1; // for now, it is -1 only
auto prev_val = det.getOnChipDAC(index, chipIndex);
auto dacValueStr = ToStringHex(dacvalue);
auto chipIndexStr = std::to_string(chipIndex);
std::ostringstream oss_set, oss_get;
proxy.Call(dacname, {chipIndexStr, dacValueStr}, -1, PUT, oss_set);
caller.call(dacname, {chipIndexStr, dacValueStr}, -1, PUT, oss_set);
REQUIRE(oss_set.str() ==
dacname + " " + chipIndexStr + " " + dacValueStr + "\n");
proxy.Call(dacname, {chipIndexStr}, -1, GET, oss_get);
caller.call(dacname, {chipIndexStr}, -1, GET, oss_get);
REQUIRE(oss_get.str() ==
dacname + " " + chipIndexStr + " " + dacValueStr + "\n");

16
slsDetectorSoftware/tests/Caller/test-Caller-global.h Normal file
View File

@@ -0,0 +1,16 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#pragma once
#include "sls/sls_detector_defs.h"
namespace sls {
void test_valid_port_caller(const std::string &command,
const std::vector<std::string> &arguments,
int detector_id, int action);
void test_dac_caller(slsDetectorDefs::dacIndex index,
const std::string &dacname, int dacvalue);
void test_onchip_dac_caller(slsDetectorDefs::dacIndex index,
const std::string &dacname, int dacvalue);
} // namespace sls

174
slsDetectorSoftware/tests/Caller/test-Caller-gotthard.cpp Normal file
View File

@@ -0,0 +1,174 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
using test::GET;
using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back GOTTHARD dacs", "[.cmdcall][.dacs]") {
// vref_ds, vcascn_pb, vcascp_pb, vout_cm, vcasc_out, vin_cm, vref_comp,
// ib_test_c
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
SECTION("vref_ds") { test_dac_caller(defs::VREF_DS, "vref_ds", 660); }
SECTION("vcascn_pb") {
test_dac_caller(defs::VCASCN_PB, "vcascn_pb", 650);
}
SECTION("vcascp_pb") {
test_dac_caller(defs::VCASCP_PB, "vcascp_pb", 1480);
}
SECTION("vout_cm") { test_dac_caller(defs::VOUT_CM, "vout_cm", 1520); }
SECTION("vcasc_out") {
test_dac_caller(defs::VCASC_OUT, "vcasc_out", 1320);
}
SECTION("vin_cm") { test_dac_caller(defs::VIN_CM, "vin_cm", 1350); }
SECTION("vref_comp") {
test_dac_caller(defs::VREF_COMP, "vref_comp", 350);
}
SECTION("ib_test_c") {
test_dac_caller(defs::IB_TESTC, "ib_test_c", 2001);
}
// eiger
REQUIRE_THROWS(caller.call("dac", {"vthreshold"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvn"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcn"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"iodelay"}, -1, GET));
// jungfrau
REQUIRE_THROWS(caller.call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vdd_prot"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vin_com"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_ds"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vref_ds"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vref_comp"}, -1, GET));
// mythen3
REQUIRE_THROWS(caller.call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper_n"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vipre"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vdcsh"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth1"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth2"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth3"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal_n"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal_p"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcassh"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcas"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vicin"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vipre_out"}, -1, GET));
// gotthard2
REQUIRE_THROWS(caller.call("dac", {"vref_h_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp_fe"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_cds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_rstore"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_opa_1st"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_comp_fe"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_adc1"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_l_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_cds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_cs"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_opa_fd"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_adc2"}, -1, GET));
}
}
/* Gotthard Specific */
TEST_CASE("roi", "[.cmdcall]") {
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
if (det.size() > 1) {
REQUIRE_THROWS(caller.call("roi", {"0", "255"}, -1, PUT));
REQUIRE_NOTHROW(caller.call("roi", {}, -1, GET));
} else {
auto prev_val = det.getROI();
{
std::ostringstream oss;
caller.call("roi", {"0", "255"}, -1, PUT, oss);
REQUIRE(oss.str() == "roi [0, 255]\n");
}
{
std::ostringstream oss;
caller.call("roi", {"256", "511"}, -1, PUT, oss);
REQUIRE(oss.str() == "roi [256, 511]\n");
}
REQUIRE_THROWS(caller.call("roi", {"0", "256"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setROI(prev_val[i], i);
}
}
} else {
REQUIRE_THROWS(caller.call("roi", {}, -1, GET));
}
}
TEST_CASE("clearroi", "[.cmdcall]") {
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
auto prev_val = det.getROI();
{
std::ostringstream oss;
caller.call("clearroi", {}, -1, PUT, oss);
REQUIRE(oss.str() == "clearroi successful\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setROI(prev_val[i], i);
}
} else {
REQUIRE_THROWS(caller.call("clearroi", {}, -1, PUT));
}
}
TEST_CASE("exptimel", "[.cmdcall]") {
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
REQUIRE_NOTHROW(caller.call("exptimel", {}, -1, GET));
} else {
REQUIRE_THROWS(caller.call("exptimel", {}, -1, GET));
}
}
} // namespace sls

459
slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp → slsDetectorSoftware/tests/Caller/test-Caller-gotthard2.cpp
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
@@ -9,7 +9,7 @@
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
@@ -18,21 +18,21 @@ using test::GET;
using test::PUT;
// time specific measurements for gotthard2
TEST_CASE("timegotthard2", "[.cmd]") {
TEST_CASE("timegotthard2", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
// exptime
auto prev_val = det.getExptime();
{
std::ostringstream oss;
proxy.Call("exptime", {"220ns"}, -1, PUT, oss);
caller.call("exptime", {"220ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime 220ns\n");
}
{
std::ostringstream oss;
proxy.Call("exptime", {}, -1, GET, oss);
caller.call("exptime", {}, -1, GET, oss);
REQUIRE(oss.str() == "exptime 221ns\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -42,12 +42,12 @@ TEST_CASE("timegotthard2", "[.cmd]") {
prev_val = det.getBurstPeriod();
{
std::ostringstream oss;
proxy.Call("burstperiod", {"220ns"}, -1, PUT, oss);
caller.call("burstperiod", {"220ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "burstperiod 220ns\n");
}
{
std::ostringstream oss;
proxy.Call("burstperiod", {}, -1, GET, oss);
caller.call("burstperiod", {}, -1, GET, oss);
REQUIRE(oss.str() == "burstperiod 221ns\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -57,12 +57,12 @@ TEST_CASE("timegotthard2", "[.cmd]") {
prev_val = det.getDelayAfterTrigger();
{
std::ostringstream oss;
proxy.Call("delay", {"220ns"}, -1, PUT, oss);
caller.call("delay", {"220ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "delay 220ns\n");
}
{
std::ostringstream oss;
proxy.Call("delay", {}, -1, GET, oss);
caller.call("delay", {}, -1, GET, oss);
REQUIRE(oss.str() == "delay 221ns\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -74,28 +74,28 @@ TEST_CASE("timegotthard2", "[.cmd]") {
prev_val = det.getPeriod();
{
std::ostringstream oss;
proxy.Call("period", {"220ns"}, -1, PUT, oss);
caller.call("period", {"220ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "period 220ns\n");
}
{
std::ostringstream oss;
proxy.Call("period", {}, -1, GET, oss);
caller.call("period", {}, -1, GET, oss);
REQUIRE(oss.str() == "period 221ns\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPeriod(prev_val[i], {i});
}
// period in continuous mode
det.setBurstMode(defs::CONTINUOUS_INTERNAL, {});
det.setBurstMode(defs::CONTINUOUS_EXTERNAL, {});
prev_val = det.getPeriod();
{
std::ostringstream oss;
proxy.Call("period", {"220ns"}, -1, PUT, oss);
caller.call("period", {"220ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "period 220ns\n");
}
{
std::ostringstream oss;
proxy.Call("period", {}, -1, GET, oss);
caller.call("period", {}, -1, GET, oss);
REQUIRE(oss.str() == "period 221ns\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -106,180 +106,199 @@ TEST_CASE("timegotthard2", "[.cmd]") {
}
/* dacs */
TEST_CASE("Setting and reading back GOTTHARD2 dacs", "[.cmd][.dacs]") {
TEST_CASE("Setting and reading back GOTTHARD2 dacs", "[.cmdcall][.dacs]") {
// vref_h_adc, vb_comp_fe, vb_comp_adc, vcom_cds,
// vref_restore, vb_opa_1st, vref_comp_fe, vcom_adc1,
// vref_prech, vref_l_adc, vref_cds, vb_cs,
// vb_opa_fd, vcom_adc2
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vref_h_adc") {
test_dac(defs::VREF_H_ADC, "vref_h_adc", 2099);
test_dac_caller(defs::VREF_H_ADC, "vref_h_adc", 2099);
}
SECTION("vb_comp_fe") {
test_dac_caller(defs::VB_COMP_FE, "vb_comp_fe", 0);
}
SECTION("vb_comp_fe") { test_dac(defs::VB_COMP_FE, "vb_comp_fe", 0); }
SECTION("vb_comp_adc") {
test_dac(defs::VB_COMP_ADC, "vb_comp_adc", 0);
test_dac_caller(defs::VB_COMP_ADC, "vb_comp_adc", 0);
}
SECTION("vcom_cds") {
test_dac_caller(defs::VCOM_CDS, "vcom_cds", 1400);
}
SECTION("vcom_cds") { test_dac(defs::VCOM_CDS, "vcom_cds", 1400); }
SECTION("vref_rstore") {
test_dac(defs::VREF_RSTORE, "vref_rstore", 640);
test_dac_caller(defs::VREF_RSTORE, "vref_rstore", 640);
}
SECTION("vb_opa_1st") {
test_dac_caller(defs::VB_OPA_1ST, "vb_opa_1st", 0);
}
SECTION("vb_opa_1st") { test_dac(defs::VB_OPA_1ST, "vb_opa_1st", 0); }
SECTION("vref_comp_fe") {
test_dac(defs::VREF_COMP_FE, "vref_comp_fe", 0);
test_dac_caller(defs::VREF_COMP_FE, "vref_comp_fe", 0);
}
SECTION("vcom_adc1") {
test_dac_caller(defs::VCOM_ADC1, "vcom_adc1", 1400);
}
SECTION("vcom_adc1") { test_dac(defs::VCOM_ADC1, "vcom_adc1", 1400); }
SECTION("vref_prech") {
test_dac(defs::VREF_PRECH, "vref_prech", 1720);
test_dac_caller(defs::VREF_PRECH, "vref_prech", 1720);
}
SECTION("vref_l_adc") {
test_dac_caller(defs::VREF_L_ADC, "vref_l_adc", 700);
}
SECTION("vref_cds") {
test_dac_caller(defs::VREF_CDS, "vref_cds", 1200);
}
SECTION("vb_cs") { test_dac_caller(defs::VB_CS, "vb_cs", 2799); }
SECTION("vb_opa_fd") {
test_dac_caller(defs::VB_OPA_FD, "vb_opa_fd", 0);
}
SECTION("vcom_adc2") {
test_dac_caller(defs::VCOM_ADC2, "vcom_adc2", 1400);
}
SECTION("vref_l_adc") { test_dac(defs::VREF_L_ADC, "vref_l_adc", 700); }
SECTION("vref_cds") { test_dac(defs::VREF_CDS, "vref_cds", 1200); }
SECTION("vb_cs") { test_dac(defs::VB_CS, "vb_cs", 2799); }
SECTION("vb_opa_fd") { test_dac(defs::VB_OPA_FD, "vb_opa_fd", 0); }
SECTION("vcom_adc2") { test_dac(defs::VCOM_ADC2, "vcom_adc2", 1400); }
// eiger
REQUIRE_THROWS(proxy.Call("dac", {"vthreshold"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vsvn"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcn"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"iodelay"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vthreshold"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvn"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcn"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"iodelay"}, -1, GET));
// gotthard
REQUIRE_THROWS(proxy.Call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcascn_pb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcascp_pb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vout_cm"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcasc_out"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vin_cm"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_comp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"ib_test_c"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcascn_pb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcascp_pb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vout_cm"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcasc_out"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vin_cm"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"ib_test_c"}, -1, GET));
// jungfrau
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vdd_prot"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vin_com"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_ds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vdd_prot"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vin_com"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_ds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_comp"}, -1, GET));
// mythen3
REQUIRE_THROWS(proxy.Call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper_n"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vipre"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vdcsh"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth1"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth2"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth3"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal_n"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal_p"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcassh"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcas"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vicin"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vipre_out"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vrshaper_n"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vipre"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vdcsh"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth1"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth2"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vth3"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal_n"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal_p"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcassh"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcas"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vicin"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vipre_out"}, -1, GET));
}
}
/* on chip dacs */
TEST_CASE("vchip_comp_fe", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_comp_fe", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_comp_fe") {
test_onchip_dac(defs::VB_COMP_FE, "vchip_comp_fe", 0x137);
test_onchip_dac_caller(defs::VB_COMP_FE, "vchip_comp_fe", 0x137);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_comp_fe", {}, -1, GET));
}
}
TEST_CASE("vchip_opa_1st", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_opa_1st", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_opa_1st") {
test_onchip_dac(defs::VB_OPA_1ST, "vchip_opa_1st", 0x000);
test_onchip_dac_caller(defs::VB_OPA_1ST, "vchip_opa_1st", 0x000);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_opa_1st", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_opa_1st", {}, -1, GET));
}
}
TEST_CASE("vchip_opa_fd", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_opa_fd", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_opa_fd") {
test_onchip_dac(defs::VB_OPA_FD, "vchip_opa_fd", 0x134);
test_onchip_dac_caller(defs::VB_OPA_FD, "vchip_opa_fd", 0x134);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_opa_fd", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_opa_fd", {}, -1, GET));
}
}
TEST_CASE("vchip_comp_adc", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_comp_adc", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_comp_adc") {
test_onchip_dac(defs::VB_COMP_ADC, "vchip_comp_adc", 0x3FF);
test_onchip_dac_caller(defs::VB_COMP_ADC, "vchip_comp_adc", 0x3FF);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_comp_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_comp_adc", {}, -1, GET));
}
}
TEST_CASE("vchip_ref_comp_fe", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_ref_comp_fe", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_ref_comp_fe") {
test_onchip_dac(defs::VREF_COMP_FE, "vchip_ref_comp_fe", 0x100);
test_onchip_dac_caller(defs::VREF_COMP_FE, "vchip_ref_comp_fe",
0x100);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_ref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_ref_comp_fe", {}, -1, GET));
}
}
TEST_CASE("vchip_cs", "[.cmd][.onchipdacs]") {
TEST_CASE("vchip_cs", "[.cmdcall][.onchipdacs]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
SECTION("vchip_cs") { test_onchip_dac(defs::VB_CS, "vchip_cs", 0x0D0); }
SECTION("vchip_cs") {
test_onchip_dac_caller(defs::VB_CS, "vchip_cs", 0x0D0);
}
} else {
REQUIRE_THROWS(proxy.Call("vchip_cs", {}, -1, GET));
REQUIRE_THROWS(caller.call("vchip_cs", {}, -1, GET));
}
}
/* Gotthard2 Specific */
TEST_CASE("bursts", "[.cmd]") {
TEST_CASE("bursts", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_burst =
@@ -295,47 +314,47 @@ TEST_CASE("bursts", "[.cmd]") {
det.setTimingMode(defs::AUTO_TIMING);
{
std::ostringstream oss;
proxy.Call("bursts", {"3"}, -1, PUT, oss);
caller.call("bursts", {"3"}, -1, PUT, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
REQUIRE_THROWS(proxy.Call("bursts", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("bursts", {"0"}, -1, PUT));
// trigger mode: reg set to 1, but bursts must be same
det.setTimingMode(defs::TRIGGER_EXPOSURE);
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
det.setTimingMode(defs::AUTO_TIMING);
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
// continuous mode: reg set to #frames,
// but bursts should return same value
det.setBurstMode(defs::CONTINUOUS_INTERNAL);
det.setBurstMode(defs::CONTINUOUS_EXTERNAL);
det.setNumberOfFrames(2);
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
det.setTimingMode(defs::TRIGGER_EXPOSURE);
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
det.setBurstMode(defs::BURST_INTERNAL);
{
std::ostringstream oss;
proxy.Call("bursts", {}, -1, GET, oss);
caller.call("bursts", {}, -1, GET, oss);
REQUIRE(oss.str() == "bursts 3\n");
}
// set to previous values
@@ -347,122 +366,122 @@ TEST_CASE("bursts", "[.cmd]") {
det.setBurstMode(prev_burstMode[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("bursts", {}, -1, GET));
REQUIRE_THROWS(caller.call("bursts", {}, -1, GET));
}
}
TEST_CASE("burstperiod", "[.cmd]") {
TEST_CASE("burstperiod", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto previous = det.getBurstPeriod();
std::ostringstream oss_set, oss_get;
proxy.Call("burstperiod", {"30ms"}, -1, PUT, oss_set);
caller.call("burstperiod", {"30ms"}, -1, PUT, oss_set);
REQUIRE(oss_set.str() == "burstperiod 30ms\n");
proxy.Call("burstperiod", {}, -1, GET, oss_get);
caller.call("burstperiod", {}, -1, GET, oss_get);
REQUIRE(oss_get.str() == "burstperiod 30ms\n");
// Reset to previous value
for (int i = 0; i != det.size(); ++i) {
det.setBurstPeriod(previous[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("burstperiod", {}, -1, GET));
REQUIRE_THROWS(caller.call("burstperiod", {}, -1, GET));
}
}
TEST_CASE("burstsl", "[.cmd]") {
TEST_CASE("burstsl", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_NOTHROW(proxy.Call("burstsl", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("burstsl", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("burstsl", {}, -1, GET));
REQUIRE_THROWS(caller.call("burstsl", {}, -1, GET));
}
}
TEST_CASE("inj_ch", "[.cmd]") {
TEST_CASE("inj_ch", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_THROWS(
proxy.Call("inj_ch", {"-1", "1"}, -1, PUT)); // invalid offset
caller.call("inj_ch", {"-1", "1"}, -1, PUT)); // invalid offset
REQUIRE_THROWS(
proxy.Call("inj_ch", {"0", "0"}, -1, PUT)); // invalid increment
caller.call("inj_ch", {"0", "0"}, -1, PUT)); // invalid increment
{
std::ostringstream oss;
proxy.Call("inj_ch", {"0", "1"}, -1, PUT, oss);
caller.call("inj_ch", {"0", "1"}, -1, PUT, oss);
REQUIRE(oss.str() == "inj_ch [0, 1]\n");
}
{
std::ostringstream oss;
proxy.Call("inj_ch", {}, -1, GET, oss);
caller.call("inj_ch", {}, -1, GET, oss);
REQUIRE(oss.str() == "inj_ch [0, 1]\n");
}
} else {
REQUIRE_THROWS(proxy.Call("inj_ch", {}, -1, GET));
REQUIRE_THROWS(caller.call("inj_ch", {}, -1, GET));
}
}
TEST_CASE("vetophoton", "[.cmd]") {
TEST_CASE("vetophoton", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_THROWS(proxy.Call("vetophoton", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetophoton", {"-1"}, -1, GET));
REQUIRE_THROWS(caller.call("vetophoton", {}, -1, GET));
REQUIRE_THROWS(caller.call("vetophoton", {"-1"}, -1, GET));
REQUIRE_NOTHROW(
proxy.Call("vetophoton", {"-1", "/tmp/bla.txt"}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetophoton", {"12", "1", "39950"}, -1,
PUT)); // invalid chip index
REQUIRE_THROWS(proxy.Call("vetophoton", {"-1", "0"}, -1,
PUT)); // invalid photon number
REQUIRE_THROWS(proxy.Call("vetophoton", {"-1", "1", "39950"}, -1,
PUT)); // invald file
caller.call("vetophoton", {"-1", "/tmp/bla.txt"}, -1, GET));
REQUIRE_THROWS(caller.call("vetophoton", {"12", "1", "39950"}, -1,
PUT)); // invalid chip index
REQUIRE_THROWS(caller.call("vetophoton", {"-1", "0"}, -1,
PUT)); // invalid photon number
REQUIRE_THROWS(caller.call("vetophoton", {"-1", "1", "39950"}, -1,
PUT)); // invald file
} else {
REQUIRE_THROWS(
proxy.Call("vetophoton", {"-1", "/tmp/bla.txt"}, -1, GET));
caller.call("vetophoton", {"-1", "/tmp/bla.txt"}, -1, GET));
}
}
TEST_CASE("vetoref", "[.cmd]") {
TEST_CASE("vetoref", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_THROWS(proxy.Call("vetoref", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetoref", {"3", "0x3ff"}, -1,
PUT)); // invalid chip index
REQUIRE_NOTHROW(proxy.Call("vetoref", {"1", "0x010"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetoref", {}, -1, GET));
REQUIRE_THROWS(caller.call("vetoref", {"3", "0x3ff"}, -1,
PUT)); // invalid chip index
REQUIRE_NOTHROW(caller.call("vetoref", {"1", "0x010"}, -1, PUT));
} else {
REQUIRE_THROWS(proxy.Call("vetoref", {"3", "0x0"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetoref", {"3", "0x0"}, -1, PUT));
}
}
TEST_CASE("vetofile", "[.cmd]") {
TEST_CASE("vetofile", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
REQUIRE_THROWS(proxy.Call("vetofile", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetofile", {"12", "/tmp/bla.txt"}, -1,
PUT)); // invalid chip index
REQUIRE_THROWS(caller.call("vetofile", {}, -1, GET));
REQUIRE_THROWS(caller.call("vetofile", {"12", "/tmp/bla.txt"}, -1,
PUT)); // invalid chip index
} else {
REQUIRE_THROWS(proxy.Call("vetofile", {"-1"}, -1, GET));
REQUIRE_THROWS(caller.call("vetofile", {"-1"}, -1, GET));
}
}
TEST_CASE("burstmode", "[.cmd]") {
TEST_CASE("burstmode", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
@@ -470,166 +489,166 @@ TEST_CASE("burstmode", "[.cmd]") {
auto burststr = ToString(burst);
{
std::ostringstream oss;
proxy.Call("burstmode", {"burst_internal"}, -1, PUT, oss);
caller.call("burstmode", {"burst_internal"}, -1, PUT, oss);
REQUIRE(oss.str() == "burstmode burst_internal\n");
}
{
std::ostringstream oss;
proxy.Call("burstmode", {"cw_internal"}, -1, PUT, oss);
REQUIRE(oss.str() == "burstmode cw_internal\n");
caller.call("burstmode", {"cw_external"}, -1, PUT, oss);
REQUIRE(oss.str() == "burstmode cw_external\n");
}
{
std::ostringstream oss;
proxy.Call("burstmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "burstmode cw_internal\n");
caller.call("burstmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "burstmode cw_external\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setBurstMode(burst[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("burstmode", {}, -1, GET));
REQUIRE_THROWS(caller.call("burstmode", {}, -1, GET));
}
}
TEST_CASE("cdsgain", "[.cmd]") {
TEST_CASE("cdsgain", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val = det.getCDSGain();
{
std::ostringstream oss;
proxy.Call("cdsgain", {"1"}, -1, PUT, oss);
caller.call("cdsgain", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "cdsgain 1\n");
}
{
std::ostringstream oss;
proxy.Call("cdsgain", {"0"}, -1, PUT, oss);
caller.call("cdsgain", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "cdsgain 0\n");
}
{
std::ostringstream oss;
proxy.Call("cdsgain", {}, -1, GET, oss);
caller.call("cdsgain", {}, -1, GET, oss);
REQUIRE(oss.str() == "cdsgain 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setCDSGain(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("cdsgain", {}, -1, GET));
REQUIRE_THROWS(caller.call("cdsgain", {}, -1, GET));
}
}
TEST_CASE("timingsource", "[.cmd]") {
TEST_CASE("timingsource", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val = det.getTimingSource();
/* { until its activated in fpga
std::ostringstream oss;
proxy.Call("timingsource", {"external"}, -1, PUT, oss);
caller.call("timingsource", {"external"}, -1, PUT, oss);
REQUIRE(oss.str() == "timingsource external\n");
}*/
{
std::ostringstream oss;
proxy.Call("timingsource", {"internal"}, -1, PUT, oss);
caller.call("timingsource", {"internal"}, -1, PUT, oss);
REQUIRE(oss.str() == "timingsource internal\n");
}
{
std::ostringstream oss;
proxy.Call("timingsource", {}, -1, GET, oss);
caller.call("timingsource", {}, -1, GET, oss);
REQUIRE(oss.str() == "timingsource internal\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTimingSource(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("timingsource", {}, -1, GET));
REQUIRE_THROWS(caller.call("timingsource", {}, -1, GET));
}
}
TEST_CASE("veto", "[.cmd]") {
TEST_CASE("veto", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val = det.getVeto();
{
std::ostringstream oss;
proxy.Call("veto", {"1"}, -1, PUT, oss);
caller.call("veto", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "veto 1\n");
}
{
std::ostringstream oss;
proxy.Call("veto", {"0"}, -1, PUT, oss);
caller.call("veto", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "veto 0\n");
}
{
std::ostringstream oss;
proxy.Call("veto", {}, -1, GET, oss);
caller.call("veto", {}, -1, GET, oss);
REQUIRE(oss.str() == "veto 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setVeto(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("veto", {}, -1, GET));
REQUIRE_THROWS(caller.call("veto", {}, -1, GET));
}
}
TEST_CASE("vetostream", "[.cmd]") {
TEST_CASE("vetostream", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val =
det.getVetoStream().tsquash("inconsistent veto stream to test");
{
std::ostringstream oss;
proxy.Call("vetostream", {"none"}, -1, PUT, oss);
caller.call("vetostream", {"none"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream none\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {}, -1, GET, oss);
caller.call("vetostream", {}, -1, GET, oss);
REQUIRE(oss.str() == "vetostream none\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {"lll"}, -1, PUT, oss);
caller.call("vetostream", {"lll"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {}, -1, GET, oss);
caller.call("vetostream", {}, -1, GET, oss);
REQUIRE(oss.str() == "vetostream lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {"lll", "10gbe"}, -1, PUT, oss);
caller.call("vetostream", {"lll", "10gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {}, -1, GET, oss);
caller.call("vetostream", {}, -1, GET, oss);
REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
}
REQUIRE_THROWS(proxy.Call("vetostream", {"lll", "none"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetostream", {"lll", "none"}, -1, PUT));
det.setVetoStream(prev_val);
} else {
REQUIRE_THROWS(proxy.Call("vetostream", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetostream", {"none"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetostream", {}, -1, GET));
REQUIRE_THROWS(caller.call("vetostream", {"none"}, -1, PUT));
}
REQUIRE_THROWS(proxy.Call("vetostream", {"dfgd"}, -1, GET));
REQUIRE_THROWS(caller.call("vetostream", {"dfgd"}, -1, GET));
}
TEST_CASE("vetoalg", "[.cmd]") {
TEST_CASE("vetoalg", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val_lll =
@@ -638,37 +657,37 @@ TEST_CASE("vetoalg", "[.cmd]") {
det.getVetoAlgorithm(defs::streamingInterface::ETHERNET_10GB);
{
std::ostringstream oss;
proxy.Call("vetoalg", {"hits", "lll"}, -1, PUT, oss);
caller.call("vetoalg", {"hits", "lll"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg hits lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"lll"}, -1, GET, oss);
caller.call("vetoalg", {"lll"}, -1, GET, oss);
REQUIRE(oss.str() == "vetoalg hits lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"hits", "10gbe"}, -1, PUT, oss);
caller.call("vetoalg", {"hits", "10gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg hits 10gbe\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"10gbe"}, -1, GET, oss);
caller.call("vetoalg", {"10gbe"}, -1, GET, oss);
REQUIRE(oss.str() == "vetoalg hits 10gbe\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"raw", "lll"}, -1, PUT, oss);
caller.call("vetoalg", {"raw", "lll"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg raw lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"raw", "10gbe"}, -1, PUT, oss);
caller.call("vetoalg", {"raw", "10gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg raw 10gbe\n");
}
REQUIRE_THROWS(
proxy.Call("vetoalg", {"default", "lll", "10gbe"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("vetoalg", {"hits", "none"}, -1, PUT));
caller.call("vetoalg", {"default", "lll", "10gbe"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetoalg", {"hits", "none"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setVetoAlgorithm(prev_val_lll[i],
defs::streamingInterface::LOW_LATENCY_LINK,
@@ -677,15 +696,15 @@ TEST_CASE("vetoalg", "[.cmd]") {
defs::streamingInterface::ETHERNET_10GB, {i});
}
} else {
REQUIRE_THROWS(proxy.Call("vetoalg", {"lll"}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetoalg", {"none"}, -1, PUT));
REQUIRE_THROWS(caller.call("vetoalg", {"lll"}, -1, GET));
REQUIRE_THROWS(caller.call("vetoalg", {"none"}, -1, PUT));
}
REQUIRE_THROWS(proxy.Call("vetoalg", {"dfgd"}, -1, GET));
REQUIRE_THROWS(caller.call("vetoalg", {"dfgd"}, -1, GET));
}
TEST_CASE("confadc", "[.cmd]") {
TEST_CASE("confadc", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
@@ -703,20 +722,20 @@ TEST_CASE("confadc", "[.cmd]") {
}
}
REQUIRE_THROWS(proxy.Call("confadc", {"11", "2", "0x7f"}, -1,
PUT)); // invalid chip index
REQUIRE_THROWS(proxy.Call("confadc", {"-1", "32", "0x7f"}, -1,
PUT)); // invalid adc index
REQUIRE_THROWS(proxy.Call("confadc", {"-1", "10", "0x80"}, -1,
PUT)); // invalid value
REQUIRE_THROWS(caller.call("confadc", {"11", "2", "0x7f"}, -1,
PUT)); // invalid chip index
REQUIRE_THROWS(caller.call("confadc", {"-1", "32", "0x7f"}, -1,
PUT)); // invalid adc index
REQUIRE_THROWS(caller.call("confadc", {"-1", "10", "0x80"}, -1,
PUT)); // invalid value
{
std::ostringstream oss;
proxy.Call("confadc", {"-1", "-1", "0x11"}, -1, PUT, oss);
caller.call("confadc", {"-1", "-1", "0x11"}, -1, PUT, oss);
REQUIRE(oss.str() == "confadc [-1, -1, 0x11]\n");
}
{
std::ostringstream oss;
proxy.Call("confadc", {"2", "3"}, -1, GET, oss);
caller.call("confadc", {"2", "3"}, -1, GET, oss);
REQUIRE(oss.str() == "confadc 0x11\n");
}
@@ -728,7 +747,7 @@ TEST_CASE("confadc", "[.cmd]") {
}
}
} else {
REQUIRE_THROWS(proxy.Call("confadc", {}, -1, GET));
REQUIRE_THROWS(caller.call("confadc", {}, -1, GET));
}
}

490
slsDetectorSoftware/tests/test-CmdProxy-jungfrau.cpp → slsDetectorSoftware/tests/Caller/test-Caller-jungfrau.cpp
View File

@@ -1,13 +1,13 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
@@ -17,275 +17,281 @@ using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back Jungfrau dacs", "[.cmd][.dacs]") {
TEST_CASE("Setting and reading back Jungfrau dacs", "[.cmdcall][.dacs]") {
// vb_comp, vdd_prot, vin_com, vref_prech, vb_pixbuf, vb_ds, vref_ds,
// vref_comp
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
SECTION("vb_comp") { test_dac(defs::VB_COMP, "vb_comp", 1220); }
SECTION("vdd_prot") { test_dac(defs::VDD_PROT, "vdd_prot", 3000); }
SECTION("vin_com") { test_dac(defs::VIN_COM, "vin_com", 1053); }
SECTION("vref_prech") {
test_dac(defs::VREF_PRECH, "vref_prech", 1450);
SECTION("vb_comp") { test_dac_caller(defs::VB_COMP, "vb_comp", 1220); }
SECTION("vdd_prot") {
test_dac_caller(defs::VDD_PROT, "vdd_prot", 3000);
}
SECTION("vin_com") { test_dac_caller(defs::VIN_COM, "vin_com", 1053); }
SECTION("vref_prech") {
test_dac_caller(defs::VREF_PRECH, "vref_prech", 1450);
}
SECTION("vb_pixbuf") {
test_dac_caller(defs::VB_PIXBUF, "vb_pixbuf", 750);
}
SECTION("vb_ds") { test_dac_caller(defs::VB_DS, "vb_ds", 1000); }
SECTION("vref_ds") { test_dac_caller(defs::VREF_DS, "vref_ds", 480); }
SECTION("vref_comp") {
test_dac_caller(defs::VREF_COMP, "vref_comp", 420);
}
SECTION("vb_pixbuf") { test_dac(defs::VB_PIXBUF, "vb_pixbuf", 750); }
SECTION("vb_ds") { test_dac(defs::VB_DS, "vb_ds", 1000); }
SECTION("vref_ds") { test_dac(defs::VREF_DS, "vref_ds", 480); }
SECTION("vref_comp") { test_dac(defs::VREF_COMP, "vref_comp", 420); }
// eiger
REQUIRE_THROWS(proxy.Call("vthreshold", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vsvp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vsvn", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtrim", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtgstv", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_ll", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_lr", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_rl", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_rr", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("rxb_rb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("rxb_lb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcn", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vishaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("iodelay", {}, -1, GET));
REQUIRE_THROWS(caller.call("vthreshold", {}, -1, GET));
REQUIRE_THROWS(caller.call("vsvp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vsvn", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtrim", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtgstv", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_ll", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_lr", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_rl", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_rr", {}, -1, GET));
REQUIRE_THROWS(caller.call("rxb_rb", {}, -1, GET));
REQUIRE_THROWS(caller.call("rxb_lb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcn", {}, -1, GET));
REQUIRE_THROWS(caller.call("vishaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("iodelay", {}, -1, GET));
// gotthard
// REQUIRE_THROWS(proxy.Call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascp_pb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcasc_out", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vin_cm", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("ib_test_c", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascp_pb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcasc_out", {}, -1, GET));
REQUIRE_THROWS(caller.call("vin_cm", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("ib_test_c", {}, -1, GET));
// mythen3
REQUIRE_THROWS(proxy.Call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper_n", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vipre", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vishaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth2", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth3", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_p", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtrim", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcassh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcas", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vicin", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vipre_out", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper_n", {}, -1, GET));
REQUIRE_THROWS(caller.call("vipre", {}, -1, GET));
REQUIRE_THROWS(caller.call("vishaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth2", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth3", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_p", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtrim", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcassh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcas", {}, -1, GET));
REQUIRE_THROWS(caller.call("vicin", {}, -1, GET));
REQUIRE_THROWS(caller.call("vipre_out", {}, -1, GET));
// gotthard2
REQUIRE_THROWS(proxy.Call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc2", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc2", {}, -1, GET));
}
}
/* Network Configuration (Detector<->Receiver) */
TEST_CASE("selinterface", "[.cmd]") {
TEST_CASE("selinterface", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
auto prev_val = det.getSelectedUDPInterface().tsquash(
"inconsistent selected interface to test");
{
std::ostringstream oss;
proxy.Call("selinterface", {"1"}, -1, PUT, oss);
caller.call("selinterface", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "selinterface 1\n");
}
{
std::ostringstream oss;
proxy.Call("selinterface", {"0"}, -1, PUT, oss);
caller.call("selinterface", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "selinterface 0\n");
}
{
std::ostringstream oss;
proxy.Call("selinterface", {}, -1, GET, oss);
caller.call("selinterface", {}, -1, GET, oss);
REQUIRE(oss.str() == "selinterface 0\n");
}
det.selectUDPInterface(prev_val);
REQUIRE_THROWS(proxy.Call("selinterface", {"2"}, -1, PUT));
REQUIRE_THROWS(caller.call("selinterface", {"2"}, -1, PUT));
} else {
REQUIRE_THROWS(proxy.Call("selinterface", {}, -1, GET));
REQUIRE_THROWS(caller.call("selinterface", {}, -1, GET));
}
}
/* Jungfrau/moench Specific */
TEST_CASE("temp_threshold", "[.cmd]") {
TEST_CASE("temp_threshold", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
auto prev_val = det.getThresholdTemperature();
{
std::ostringstream oss;
proxy.Call("temp_threshold", {"65"}, -1, PUT, oss);
caller.call("temp_threshold", {"65"}, -1, PUT, oss);
REQUIRE(oss.str() == "temp_threshold 65\n");
}
{
std::ostringstream oss;
proxy.Call("temp_threshold", {"70"}, -1, PUT, oss);
caller.call("temp_threshold", {"70"}, -1, PUT, oss);
REQUIRE(oss.str() == "temp_threshold 70\n");
}
{
std::ostringstream oss;
proxy.Call("temp_threshold", {}, -1, GET, oss);
caller.call("temp_threshold", {}, -1, GET, oss);
REQUIRE(oss.str() == "temp_threshold 70\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setThresholdTemperature(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("temp_threshold", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("temp_threshold", {"70"}, -1, PUT));
REQUIRE_THROWS(caller.call("temp_threshold", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_threshold", {"70"}, -1, PUT));
}
}
TEST_CASE("chipversion", "[.cmd]") {
TEST_CASE("chipversion", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
REQUIRE_NOTHROW(proxy.Call("chipversion", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("chipversion", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("chipversion", {}, -1, GET));
REQUIRE_THROWS(caller.call("chipversion", {}, -1, GET));
}
REQUIRE_THROWS(proxy.Call("chipversion", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("chipversion", {"0"}, -1, PUT));
}
TEST_CASE("temp_control", "[.cmd]") {
TEST_CASE("temp_control", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
auto prev_val = det.getTemperatureControl();
{
std::ostringstream oss;
proxy.Call("temp_control", {"0"}, -1, PUT, oss);
caller.call("temp_control", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "temp_control 0\n");
}
{
std::ostringstream oss;
proxy.Call("temp_control", {"1"}, -1, PUT, oss);
caller.call("temp_control", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "temp_control 1\n");
}
{
std::ostringstream oss;
proxy.Call("temp_control", {}, -1, GET, oss);
caller.call("temp_control", {}, -1, GET, oss);
REQUIRE(oss.str() == "temp_control 1\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTemperatureControl(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("temp_control", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("temp_control", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("temp_control", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_control", {"0"}, -1, PUT));
}
}
TEST_CASE("temp_event", "[.cmd]") {
TEST_CASE("temp_event", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
{
std::ostringstream oss;
proxy.Call("temp_event", {"0"}, -1, PUT, oss);
caller.call("temp_event", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "temp_event cleared\n");
}
{
std::ostringstream oss;
proxy.Call("temp_event", {}, -1, GET, oss);
caller.call("temp_event", {}, -1, GET, oss);
REQUIRE(oss.str() == "temp_event 0\n");
}
} else {
REQUIRE_THROWS(proxy.Call("temp_event", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("temp_event", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("temp_event", {}, -1, GET));
REQUIRE_THROWS(caller.call("temp_event", {"0"}, -1, PUT));
}
}
TEST_CASE("autocompdisable", "[.cmd]") {
TEST_CASE("autocompdisable", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
auto prev_val = det.getAutoComparatorDisable();
{
std::ostringstream oss;
proxy.Call("autocompdisable", {"0"}, -1, PUT, oss);
caller.call("autocompdisable", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "autocompdisable 0\n");
}
{
std::ostringstream oss;
proxy.Call("autocompdisable", {"1"}, -1, PUT, oss);
caller.call("autocompdisable", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "autocompdisable 1\n");
}
{
std::ostringstream oss;
proxy.Call("autocompdisable", {}, -1, GET, oss);
caller.call("autocompdisable", {}, -1, GET, oss);
REQUIRE(oss.str() == "autocompdisable 1\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setAutoComparatorDisable(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("autocompdisable", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("autocompdisable", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("autocompdisable", {}, -1, GET));
REQUIRE_THROWS(caller.call("autocompdisable", {"0"}, -1, PUT));
}
}
TEST_CASE("compdisabletime", "[.cmd]") {
TEST_CASE("compdisabletime", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU &&
det.getChipVersion().squash() * 10 == 11) {
auto prev_val = det.getComparatorDisableTime();
{
std::ostringstream oss;
proxy.Call("compdisabletime", {"125ns"}, -1, PUT, oss);
caller.call("compdisabletime", {"125ns"}, -1, PUT, oss);
REQUIRE(oss.str() == "compdisabletime 125ns\n");
}
{
std::ostringstream oss;
proxy.Call("compdisabletime", {}, -1, GET, oss);
caller.call("compdisabletime", {}, -1, GET, oss);
REQUIRE(oss.str() == "compdisabletime 125ns\n");
}
{
std::ostringstream oss;
proxy.Call("compdisabletime", {"0"}, -1, PUT, oss);
caller.call("compdisabletime", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "compdisabletime 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setComparatorDisableTime(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("compdisabletime", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("compdisabletime", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("compdisabletime", {}, -1, GET));
REQUIRE_THROWS(caller.call("compdisabletime", {"0"}, -1, PUT));
}
}
TEST_CASE("extrastoragecells", "[.cmd]") {
TEST_CASE("extrastoragecells", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
// chip version 1.0
@@ -294,86 +300,86 @@ TEST_CASE("extrastoragecells", "[.cmd]") {
"inconsistent #additional storage cells to test");
{
std::ostringstream oss;
proxy.Call("extrastoragecells", {"1"}, -1, PUT, oss);
caller.call("extrastoragecells", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "extrastoragecells 1\n");
}
{
std::ostringstream oss;
proxy.Call("extrastoragecells", {"15"}, -1, PUT, oss);
caller.call("extrastoragecells", {"15"}, -1, PUT, oss);
REQUIRE(oss.str() == "extrastoragecells 15\n");
}
{
std::ostringstream oss;
proxy.Call("extrastoragecells", {"0"}, -1, PUT, oss);
caller.call("extrastoragecells", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "extrastoragecells 0\n");
}
{
std::ostringstream oss;
proxy.Call("extrastoragecells", {}, -1, GET, oss);
caller.call("extrastoragecells", {}, -1, GET, oss);
REQUIRE(oss.str() == "extrastoragecells 0\n");
}
REQUIRE_THROWS(proxy.Call("extrastoragecells", {"16"}, -1, PUT));
REQUIRE_THROWS(caller.call("extrastoragecells", {"16"}, -1, PUT));
det.setNumberOfAdditionalStorageCells(prev_val);
}
// chip version 1.1
else {
// cannot set number of addl. storage cells
REQUIRE_THROWS(proxy.Call("extrastoragecells", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("extrastoragecells", {"1"}, -1, PUT));
}
} else {
REQUIRE_THROWS(proxy.Call("extrastoragecells", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("extrastoragecells", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("extrastoragecells", {}, -1, GET));
REQUIRE_THROWS(caller.call("extrastoragecells", {"0"}, -1, PUT));
}
}
TEST_CASE("storagecell_start", "[.cmd]") {
TEST_CASE("storagecell_start", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
auto prev_val = det.getStorageCellStart();
{
std::ostringstream oss;
proxy.Call("storagecell_start", {"1"}, -1, PUT, oss);
caller.call("storagecell_start", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_start 1\n");
}
// chip version 1.0
if (det.getChipVersion().squash() * 10 == 10) {
std::ostringstream oss;
proxy.Call("storagecell_start", {"15"}, -1, PUT, oss);
caller.call("storagecell_start", {"15"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_start 15\n");
}
// chip version 1.1
else {
// max is 3
REQUIRE_THROWS(proxy.Call("storagecell_start", {"15"}, -1, PUT));
REQUIRE_THROWS(caller.call("storagecell_start", {"15"}, -1, PUT));
std::ostringstream oss;
proxy.Call("storagecell_start", {"3"}, -1, PUT, oss);
caller.call("storagecell_start", {"3"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_start 3\n");
}
{
std::ostringstream oss;
proxy.Call("storagecell_start", {"0"}, -1, PUT, oss);
caller.call("storagecell_start", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_start 0\n");
}
{
std::ostringstream oss;
proxy.Call("storagecell_start", {}, -1, GET, oss);
caller.call("storagecell_start", {}, -1, GET, oss);
REQUIRE(oss.str() == "storagecell_start 0\n");
}
REQUIRE_THROWS(proxy.Call("storagecell_start", {"16"}, -1, PUT));
REQUIRE_THROWS(caller.call("storagecell_start", {"16"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setStorageCellStart(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("storagecell_start", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("storagecell_start", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("storagecell_start", {}, -1, GET));
REQUIRE_THROWS(caller.call("storagecell_start", {"0"}, -1, PUT));
}
}
TEST_CASE("storagecell_delay", "[.cmd]") {
TEST_CASE("storagecell_delay", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
// chip version 1.0
@@ -381,21 +387,21 @@ TEST_CASE("storagecell_delay", "[.cmd]") {
auto prev_val = det.getStorageCellDelay();
{
std::ostringstream oss;
proxy.Call("storagecell_delay", {"1.62ms"}, -1, PUT, oss);
caller.call("storagecell_delay", {"1.62ms"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_delay 1.62ms\n");
}
{
std::ostringstream oss;
proxy.Call("storagecell_delay", {}, -1, GET, oss);
caller.call("storagecell_delay", {}, -1, GET, oss);
REQUIRE(oss.str() == "storagecell_delay 1.62ms\n");
}
{
std::ostringstream oss;
proxy.Call("storagecell_delay", {"0"}, -1, PUT, oss);
caller.call("storagecell_delay", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "storagecell_delay 0\n");
}
REQUIRE_THROWS(
proxy.Call("storagecell_delay", {"1638376ns"}, -1, PUT));
caller.call("storagecell_delay", {"1638376ns"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setStorageCellDelay(prev_val[i], {i});
}
@@ -404,66 +410,66 @@ TEST_CASE("storagecell_delay", "[.cmd]") {
else {
// cannot set storage cell delay
REQUIRE_THROWS(
proxy.Call("storagecell_delay", {"1.62ms"}, -1, PUT));
caller.call("storagecell_delay", {"1.62ms"}, -1, PUT));
}
} else {
REQUIRE_THROWS(proxy.Call("storagecell_delay", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("storagecell_delay", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("storagecell_delay", {}, -1, GET));
REQUIRE_THROWS(caller.call("storagecell_delay", {"0"}, -1, PUT));
}
}
TEST_CASE("gainmode", "[.cmd]") {
TEST_CASE("gainmode", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
auto prev_val = det.getGainMode();
{
std::ostringstream oss;
proxy.Call("gainmode", {"forceswitchg1"}, -1, PUT, oss);
caller.call("gainmode", {"forceswitchg1"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode forceswitchg1\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {}, -1, GET, oss);
caller.call("gainmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "gainmode forceswitchg1\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {"dynamic"}, -1, PUT, oss);
caller.call("gainmode", {"dynamic"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode dynamic\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {"forceswitchg2"}, -1, PUT, oss);
caller.call("gainmode", {"forceswitchg2"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode forceswitchg2\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {"fixg1"}, -1, PUT, oss);
caller.call("gainmode", {"fixg1"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode fixg1\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {"fixg2"}, -1, PUT, oss);
caller.call("gainmode", {"fixg2"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode fixg2\n");
}
{
std::ostringstream oss;
proxy.Call("gainmode", {"fixg0"}, -1, PUT, oss);
caller.call("gainmode", {"fixg0"}, -1, PUT, oss);
REQUIRE(oss.str() == "gainmode fixg0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setGainMode(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("gainmode", {}, -1, GET));
REQUIRE_THROWS(caller.call("gainmode", {}, -1, GET));
}
}
TEST_CASE("filtercells", "[.cmd]") {
TEST_CASE("filtercells", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
// chip version 1.1
@@ -471,25 +477,25 @@ TEST_CASE("filtercells", "[.cmd]") {
auto prev_val = det.getNumberOfFilterCells();
{
std::ostringstream oss;
proxy.Call("filtercells", {"1"}, -1, PUT, oss);
caller.call("filtercells", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "filtercells 1\n");
}
{
std::ostringstream oss;
proxy.Call("filtercells", {"12"}, -1, PUT, oss);
caller.call("filtercells", {"12"}, -1, PUT, oss);
REQUIRE(oss.str() == "filtercells 12\n");
}
{
std::ostringstream oss;
proxy.Call("filtercells", {"0"}, -1, PUT, oss);
caller.call("filtercells", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "filtercells 0\n");
}
{
std::ostringstream oss;
proxy.Call("filtercells", {}, -1, GET, oss);
caller.call("filtercells", {}, -1, GET, oss);
REQUIRE(oss.str() == "filtercells 0\n");
}
REQUIRE_THROWS(proxy.Call("filtercells", {"13"}, -1, PUT));
REQUIRE_THROWS(caller.call("filtercells", {"13"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setNumberOfFilterCells(prev_val[i], {i});
}
@@ -497,18 +503,17 @@ TEST_CASE("filtercells", "[.cmd]") {
// chip version 1.0
else {
// cannot set/get filter cell
REQUIRE_THROWS(proxy.Call("filtercells", {"1"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("filtercells", {}, -1, GET));
REQUIRE_THROWS(caller.call("filtercells", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("filtercells", {}, -1, GET));
}
} else {
REQUIRE_THROWS(proxy.Call("filtercells", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("filtercells", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("filtercells", {}, -1, GET));
REQUIRE_THROWS(caller.call("filtercells", {"0"}, -1, PUT));
}
}
TEST_CASE("pedestalmode", "[.cmd]") {
TEST_CASE("pedestalmode", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU) {
auto prev_val = det.getPedestalMode();
@@ -519,80 +524,81 @@ TEST_CASE("pedestalmode", "[.cmd]") {
auto prev_timingmode =
det.getTimingMode().tsquash("Inconsistent timing mode to test");
REQUIRE_NOTHROW(proxy.Call("pedestalmode", {}, 0, GET));
REQUIRE_NOTHROW(proxy.Call("pedestalmode", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"0"}, -1, GET));
REQUIRE_NOTHROW(caller.call("pedestalmode", {}, 0, GET));
REQUIRE_NOTHROW(caller.call("pedestalmode", {}, -1, GET));
REQUIRE_THROWS(caller.call("pedestalmode", {"0"}, -1, GET));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"256", "10"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"-1", "10"}, 0, PUT));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"20", "65536"}, 0, PUT));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"20", "-1"}, 0, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {"256", "10"}, -1, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {"-1", "10"}, 0, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {"20", "1000"}, 0, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {"2000", "100"}, 0, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {"20", "-1"}, 0, PUT));
{
std::ostringstream oss;
proxy.Call("pedestalmode", {"30", "1000"}, -1, PUT, oss);
REQUIRE(oss.str() == "pedestalmode [30, 1000]\n");
caller.call("pedestalmode", {"30", "100"}, -1, PUT, oss);
REQUIRE(oss.str() == "pedestalmode [30, 100]\n");
}
// cannot change any of these in pedestal mode
REQUIRE_THROWS_WITH(proxy.Call("frames", {"200"}, -1, PUT),
REQUIRE_THROWS_WITH(caller.call("frames", {"200"}, -1, PUT),
"Detector returned: Cannot set frames in pedestal "
"mode. It is overwritten anyway.\n");
REQUIRE_THROWS_WITH(proxy.Call("triggers", {"200"}, -1, PUT),
REQUIRE_THROWS_WITH(caller.call("triggers", {"200"}, -1, PUT),
"Detector returned: Cannot set triggers in "
"pedestal mode. It is overwritten anyway.\n");
REQUIRE_THROWS_WITH(
proxy.Call("timing", {"auto"}, -1, PUT),
caller.call("timing", {"auto"}, -1, PUT),
"Detector returned: Cannot set timing mode in pedestal mode. "
"Switch off pedestal mode to change timing mode.\n");
REQUIRE_THROWS_WITH(
proxy.Call("scan", {"vb_comp", "500", "1500", "10"}, -1, PUT),
caller.call("scan", {"vb_comp", "500", "1500", "10"}, -1, PUT),
"Detector returned: Cannot set scan when in pedestal mode.\n");
REQUIRE_THROWS_WITH(
proxy.Call("scan", {"0"}, -1, PUT),
caller.call("scan", {"0"}, -1, PUT),
"Detector returned: Cannot set scan when in pedestal mode.\n");
// should not throw to get these values though
REQUIRE_NOTHROW(proxy.Call("frames", {}, -1, GET));
REQUIRE_NOTHROW(proxy.Call("triggers", {}, -1, GET));
REQUIRE_NOTHROW(proxy.Call("timing", {}, -1, GET));
REQUIRE_NOTHROW(proxy.Call("scan", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("frames", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("triggers", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("timing", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("scan", {}, -1, GET));
{
std::ostringstream oss;
proxy.Call("pedestalmode", {"50", "500"}, -1, PUT, oss);
REQUIRE(oss.str() == "pedestalmode [50, 500]\n");
caller.call("pedestalmode", {"50", "100"}, -1, PUT, oss);
REQUIRE(oss.str() == "pedestalmode [50, 100]\n");
}
{
std::ostringstream oss;
proxy.Call("pedestalmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "pedestalmode [enabled, 50, 500]\n");
caller.call("pedestalmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "pedestalmode [enabled, 50, 100]\n");
}
{
auto pedemode = det.getPedestalMode().tsquash(
"Inconsistent pedestal mode to test");
REQUIRE(pedemode.enable == true);
REQUIRE(pedemode.frames == 50);
REQUIRE(pedemode.loops == 500);
REQUIRE(pedemode.loops == 100);
}
{
std::ostringstream oss;
proxy.Call("pedestalmode", {"0"}, -1, PUT, oss);
caller.call("pedestalmode", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "pedestalmode [0]\n");
}
{
std::ostringstream oss;
proxy.Call("pedestalmode", {}, -1, GET, oss);
caller.call("pedestalmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "pedestalmode [disabled]\n");
}
uint8_t pedestalFrames = 50;
uint16_t pedestalLoops = 1000;
uint16_t pedestalLoops = 100;
int64_t expNumFrames = pedestalFrames * pedestalLoops * 2;
auto origFrames = det.getNumberOfFrames().squash(-1);
auto origTriggers = det.getNumberOfTriggers().squash(-1);
// auto mode
det.setTimingMode(defs::AUTO_TIMING);
REQUIRE_NOTHROW(proxy.Call(
REQUIRE_NOTHROW(caller.call(
"pedestalmode",
{std::to_string(pedestalFrames), std::to_string(pedestalLoops)}, -1,
PUT));
@@ -602,7 +608,7 @@ TEST_CASE("pedestalmode", "[.cmd]") {
REQUIRE(numTriggers == 1);
// pedestal mode off
REQUIRE_NOTHROW(proxy.Call("pedestalmode", {"0"}, -1, PUT));
REQUIRE_NOTHROW(caller.call("pedestalmode", {"0"}, -1, PUT));
numTriggers = det.getNumberOfTriggers().squash(-1);
numFrames = det.getNumberOfFrames().squash(-1);
REQUIRE(numFrames == origFrames);
@@ -612,7 +618,7 @@ TEST_CASE("pedestalmode", "[.cmd]") {
REQUIRE_NOTHROW(det.setTimingMode(defs::TRIGGER_EXPOSURE));
origFrames = 5;
REQUIRE_NOTHROW(det.setNumberOfFrames(origFrames));
REQUIRE_NOTHROW(proxy.Call(
REQUIRE_NOTHROW(caller.call(
"pedestalmode",
{std::to_string(pedestalFrames), std::to_string(pedestalLoops)}, -1,
PUT));
@@ -622,7 +628,7 @@ TEST_CASE("pedestalmode", "[.cmd]") {
REQUIRE(numTriggers == 1);
// pedestal mode off
REQUIRE_NOTHROW(proxy.Call("pedestalmode", {"0"}, -1, PUT));
REQUIRE_NOTHROW(caller.call("pedestalmode", {"0"}, -1, PUT));
numTriggers = det.getNumberOfTriggers().squash(-1);
numFrames = det.getNumberOfFrames().squash(-1);
REQUIRE(numFrames == origFrames);
@@ -633,7 +639,7 @@ TEST_CASE("pedestalmode", "[.cmd]") {
REQUIRE_NOTHROW(det.setNumberOfFrames(origFrames));
origTriggers = 10;
REQUIRE_NOTHROW(det.setNumberOfTriggers(origTriggers));
REQUIRE_NOTHROW(proxy.Call(
REQUIRE_NOTHROW(caller.call(
"pedestalmode",
{std::to_string(pedestalFrames), std::to_string(pedestalLoops)}, -1,
PUT));
@@ -643,7 +649,7 @@ TEST_CASE("pedestalmode", "[.cmd]") {
REQUIRE(numTriggers == expNumFrames);
// pedestal mode off
REQUIRE_NOTHROW(proxy.Call("pedestalmode", {"0"}, -1, PUT));
REQUIRE_NOTHROW(caller.call("pedestalmode", {"0"}, -1, PUT));
numTriggers = det.getNumberOfTriggers().squash(-1);
numFrames = det.getNumberOfFrames().squash(-1);
REQUIRE(numFrames == origFrames);
@@ -656,26 +662,82 @@ TEST_CASE("pedestalmode", "[.cmd]") {
det.setPedestalMode(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("pedestalmode", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("pedestalmode", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("pedestalmode", {}, -1, GET));
REQUIRE_THROWS(caller.call("pedestalmode", {"0"}, -1, PUT));
}
}
TEST_CASE("sync", "[.cmd]") {
TEST_CASE("timing_info_decoder", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::JUNGFRAU) {
auto prev_val = det.getTimingInfoDecoder();
/*{
std::ostringstream oss;
caller.call("timing_info_decoder", {"shine"}, -1, PUT, oss);
REQUIRE(oss.str() == "timing_info_decoder shine\n");
}*/
{
std::ostringstream oss;
caller.call("timing_info_decoder", {"swissfel"}, -1, PUT, oss);
REQUIRE(oss.str() == "timing_info_decoder swissfel\n");
}
{
std::ostringstream oss;
caller.call("timing_info_decoder", {}, -1, GET, oss);
REQUIRE(oss.str() == "timing_info_decoder swissfel\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setTimingInfoDecoder(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(caller.call("timing_info_decoder", {}, -1, GET));
}
}
TEST_CASE("collectionmode", "[.cmdcall]") {
Detector det;
Caller caller(&det);
if (det.getDetectorType().squash() == defs::JUNGFRAU) {
auto prev_val = det.getCollectionMode();
{
std::ostringstream oss;
caller.call("collectionmode", {"electron"}, -1, PUT, oss);
REQUIRE(oss.str() == "collectionmode electron\n");
}
{
std::ostringstream oss;
caller.call("collectionmode", {"hole"}, -1, PUT, oss);
REQUIRE(oss.str() == "collectionmode hole\n");
}
{
std::ostringstream oss;
caller.call("collectionmode", {}, -1, GET, oss);
REQUIRE(oss.str() == "collectionmode hole\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setCollectionMode(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(caller.call("collectionmode", {}, -1, GET));
}
}
TEST_CASE("sync", "[.cmdcall]") {
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
auto prev_val = det.getSynchronization().tsquash(
"inconsistent synchronization to test");
{
std::ostringstream oss;
proxy.Call("sync", {"0"}, -1, PUT, oss);
caller.call("sync", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "sync 0\n");
}
{
std::ostringstream oss;
proxy.Call("sync", {"1"}, -1, PUT, oss);
caller.call("sync", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "sync 1\n");
}
// setting to master or slave when synced
@@ -689,10 +751,10 @@ TEST_CASE("sync", "[.cmd]") {
break;
}
}
proxy.Call("master", {"1"}, 0, PUT);
proxy.Call("master", {"0"}, 0, PUT);
caller.call("master", {"1"}, 0, PUT);
caller.call("master", {"0"}, 0, PUT);
std::ostringstream oss;
proxy.Call("status", {}, -1, GET, oss);
caller.call("status", {}, -1, GET, oss);
REQUIRE(oss.str() != "status running\n");
// set all to slaves, and then master
for (int i = 0; i != det.size(); ++i) {
@@ -702,7 +764,7 @@ TEST_CASE("sync", "[.cmd]") {
}
{
std::ostringstream oss;
proxy.Call("sync", {}, -1, GET, oss);
caller.call("sync", {}, -1, GET, oss);
REQUIRE(oss.str() == "sync 1\n");
}
// setting sync when running
@@ -721,10 +783,10 @@ TEST_CASE("sync", "[.cmd]") {
det.setPeriod(std::chrono::milliseconds(1000));
det.setSynchronization(1);
det.startDetector();
REQUIRE_THROWS(proxy.Call("sync", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("sync", {"0"}, -1, PUT));
{
std::ostringstream oss;
proxy.Call("sync", {}, -1, GET, oss);
caller.call("sync", {}, -1, GET, oss);
REQUIRE(oss.str() == "sync 1\n");
}
det.stopDetector();
@@ -735,8 +797,8 @@ TEST_CASE("sync", "[.cmd]") {
}
det.setSynchronization(prev_val);
} else {
REQUIRE_THROWS(proxy.Call("sync", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("sync", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("sync", {}, -1, GET));
REQUIRE_THROWS(caller.call("sync", {"0"}, -1, PUT));
}
}

114
slsDetectorSoftware/tests/Caller/test-Caller-moench.cpp Normal file
View File

@@ -0,0 +1,114 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/versionAPI.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
using test::GET;
using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back moench dacs", "[.cmdcall][.dacs]") {
// vbp_colbuf, vipre, vin_cm, vb_sda, vcasc_sfp, vout_cm, vipre_cds,
// ibias_sfp
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MOENCH) {
SECTION("vbp_colbuf") {
test_dac_caller(defs::VBP_COLBUF, "vbp_colbuf", 1300);
}
SECTION("vipre") { test_dac_caller(defs::VIPRE, "vipre", 1000); }
SECTION("vin_cm") { test_dac_caller(defs::VIN_CM, "vin_cm", 1400); }
SECTION("vb_sda") { test_dac_caller(defs::VB_SDA, "vb_sda", 680); }
SECTION("vcasc_sfp") {
test_dac_caller(defs::VCASC_SFP, "vcasc_sfp", 1428);
}
SECTION("vout_cm") { test_dac_caller(defs::VOUT_CM, "vout_cm", 1200); }
SECTION("vipre_cds") {
test_dac_caller(defs::VIPRE_CDS, "vipre_cds", 800);
}
SECTION("ibias_sfp") {
test_dac_caller(defs::IBIAS_SFP, "ibias_sfp", 900);
}
// eiger
REQUIRE_THROWS(caller.call("vthreshold", {}, -1, GET));
REQUIRE_THROWS(caller.call("vsvp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vsvn", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtrim", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtgstv", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_ll", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_lr", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_rl", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcmp_rr", {}, -1, GET));
REQUIRE_THROWS(caller.call("rxb_rb", {}, -1, GET));
REQUIRE_THROWS(caller.call("rxb_lb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcn", {}, -1, GET));
REQUIRE_THROWS(caller.call("vishaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("iodelay", {}, -1, GET));
// gotthard
REQUIRE_THROWS(caller.call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcascp_pb", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcasc_out", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vin_cm", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("ib_test_c", {}, -1, GET));
// mythen3
REQUIRE_THROWS(caller.call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vrshaper_n", {}, -1, GET));
// REQUIRE_THROWS(caller.call("vipre", {}, -1, GET));
REQUIRE_THROWS(caller.call("vishaper", {}, -1, GET));
REQUIRE_THROWS(caller.call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth2", {}, -1, GET));
REQUIRE_THROWS(caller.call("vth3", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcal_p", {}, -1, GET));
REQUIRE_THROWS(caller.call("vtrim", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcassh", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcas", {}, -1, GET));
REQUIRE_THROWS(caller.call("vicin", {}, -1, GET));
REQUIRE_THROWS(caller.call("vipre_out", {}, -1, GET));
// gotthard2
REQUIRE_THROWS(caller.call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(caller.call("vcom_adc2", {}, -1, GET));
// jungfrau
REQUIRE_THROWS(caller.call("vb_comp", {}, -1, GET));
REQUIRE_THROWS(caller.call("vdd_prot", {}, -1, GET));
REQUIRE_THROWS(caller.call("vin_com", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_prech", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_pixbuf", {}, -1, GET));
REQUIRE_THROWS(caller.call("vb_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(caller.call("vref_comp", {}, -1, GET));
}
}
} // namespace sls

375
slsDetectorSoftware/tests/test-CmdProxy-mythen3.cpp → slsDetectorSoftware/tests/Caller/test-Caller-mythen3.cpp
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
@@ -9,7 +9,7 @@
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
@@ -19,32 +19,40 @@ using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmd][.dacs]") {
TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmdcall][.dacs]") {
// vcassh, vth2, vshaper, vshaperneg, vipre_out, vth3, vth1,
// vicin, vcas, vpreamp, vpl, vipre, viinsh, vph, vtrim, vdcsh,
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
SECTION("vcassh") { test_dac(defs::VCASSH, "vcassh", 1200); }
SECTION("vth2") { test_dac(defs::VTH2, "vth2", 2800); }
SECTION("vrshaper") { test_dac(defs::VRSHAPER, "vrshaper", 1280); }
SECTION("vrshaper_n") {
test_dac(defs::VRSHAPER_N, "vrshaper_n", 2800);
SECTION("vcassh") { test_dac_caller(defs::VCASSH, "vcassh", 1200); }
SECTION("vth2") { test_dac_caller(defs::VTH2, "vth2", 2800); }
SECTION("vrshaper") {
test_dac_caller(defs::VRSHAPER, "vrshaper", 1280);
}
SECTION("vipre_out") { test_dac(defs::VIPRE_OUT, "vipre_out", 1220); }
SECTION("vth3") { test_dac(defs::VTH3, "vth3", 2800); }
SECTION("vth1") { test_dac(defs::VTH1, "vth1", 2880); }
SECTION("vicin") { test_dac(defs::VICIN, "vicin", 1708); }
SECTION("vcas") { test_dac(defs::VCAS, "vcas", 1800); }
SECTION("vrpreamp") { test_dac(defs::VRPREAMP, "vrpreamp", 1100); }
SECTION("vcal_n") { test_dac(defs::VCAL_N, "vcal_n", 1100); }
SECTION("vipre") { test_dac(defs::VIPRE, "vipre", 2624); }
SECTION("vishaper") { test_dac(defs::VISHAPER, "vishaper", 1708); }
SECTION("vcal_p") { test_dac(defs::VCAL_P, "vcal_p", 1712); }
SECTION("vtrim") { test_dac(defs::VTRIM, "vtrim", 2800); }
SECTION("vdcsh") { test_dac(defs::VDCSH, "vdcsh", 800); }
SECTION("vrshaper_n") {
test_dac_caller(defs::VRSHAPER_N, "vrshaper_n", 2800);
}
SECTION("vipre_out") {
test_dac_caller(defs::VIPRE_OUT, "vipre_out", 1220);
}
SECTION("vth3") { test_dac_caller(defs::VTH3, "vth3", 2800); }
SECTION("vth1") { test_dac_caller(defs::VTH1, "vth1", 2880); }
SECTION("vicin") { test_dac_caller(defs::VICIN, "vicin", 1708); }
SECTION("vcas") { test_dac_caller(defs::VCAS, "vcas", 1800); }
SECTION("vrpreamp") {
test_dac_caller(defs::VRPREAMP, "vrpreamp", 1100);
}
SECTION("vcal_n") { test_dac_caller(defs::VCAL_N, "vcal_n", 1100); }
SECTION("vipre") { test_dac_caller(defs::VIPRE, "vipre", 2624); }
SECTION("vishaper") {
test_dac_caller(defs::VISHAPER, "vishaper", 1708);
}
SECTION("vcal_p") { test_dac_caller(defs::VCAL_P, "vcal_p", 1712); }
SECTION("vtrim") { test_dac_caller(defs::VTRIM, "vtrim", 2800); }
SECTION("vdcsh") { test_dac_caller(defs::VDCSH, "vdcsh", 800); }
SECTION("vthreshold") {
// Read out individual vcmp to be able to reset after
// the test is done
@@ -55,67 +63,68 @@ TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmd][.dacs]") {
{
std::ostringstream oss;
proxy.Call("dac", {"vthreshold", "1234"}, -1, PUT, oss);
caller.call("dac", {"vthreshold", "1234"}, -1, PUT, oss);
REQUIRE(oss.str() == "dac vthreshold 1234\n");
}
{
std::ostringstream oss;
proxy.Call("dac", {"vthreshold"}, -1, GET, oss);
caller.call("dac", {"vthreshold"}, -1, GET, oss);
REQUIRE(oss.str() == "dac vthreshold 1234\n");
}
// disabling counters change vth values
proxy.Call("counters", {"0"}, -1, PUT);
caller.call("counters", {"0"}, -1, PUT);
{
std::ostringstream oss1, oss2, oss3;
proxy.Call("dac", {"vth1"}, -1, GET, oss1);
caller.call("dac", {"vth1"}, -1, GET, oss1);
REQUIRE(oss1.str() == "dac vth1 1234\n");
proxy.Call("dac", {"vth2"}, -1, GET, oss2);
caller.call("dac", {"vth2"}, -1, GET, oss2);
REQUIRE(oss2.str() == "dac vth2 2800\n");
proxy.Call("dac", {"vth3"}, -1, GET, oss3);
caller.call("dac", {"vth3"}, -1, GET, oss3);
REQUIRE(oss3.str() == "dac vth3 2800\n");
}
// vthreshold changes vth for only enabled counters
REQUIRE_NOTHROW(proxy.Call("dac", {"vthreshold", "2100"}, -1, PUT));
REQUIRE_NOTHROW(
caller.call("dac", {"vthreshold", "2100"}, -1, PUT));
{
std::ostringstream oss;
proxy.Call("dac", {"vthreshold"}, -1, GET, oss);
caller.call("dac", {"vthreshold"}, -1, GET, oss);
REQUIRE(oss.str() == "dac vthreshold 2100\n");
std::ostringstream oss1, oss2, oss3;
proxy.Call("dac", {"vth1"}, -1, GET, oss1);
caller.call("dac", {"vth1"}, -1, GET, oss1);
REQUIRE(oss1.str() == "dac vth1 2100\n");
proxy.Call("dac", {"vth2"}, -1, GET, oss2);
caller.call("dac", {"vth2"}, -1, GET, oss2);
REQUIRE(oss2.str() == "dac vth2 2800\n");
proxy.Call("dac", {"vth3"}, -1, GET, oss3);
caller.call("dac", {"vth3"}, -1, GET, oss3);
REQUIRE(oss3.str() == "dac vth3 2800\n");
}
// vth overwrite vth even if counter disabled
{
std::ostringstream oss;
proxy.Call("dac", {"vth2", "2200"}, -1, PUT);
proxy.Call("dac", {"vth2"}, -1, GET, oss);
caller.call("dac", {"vth2", "2200"}, -1, PUT);
caller.call("dac", {"vth2"}, -1, GET, oss);
REQUIRE(oss.str() == "dac vth2 2200\n");
}
// counters enabled, sets remembered values
proxy.Call("counters", {"0", "1", "2"}, -1, PUT);
caller.call("counters", {"0", "1", "2"}, -1, PUT);
{
std::ostringstream oss1, oss2, oss3;
proxy.Call("dac", {"vth1"}, -1, GET, oss1);
caller.call("dac", {"vth1"}, -1, GET, oss1);
REQUIRE(oss1.str() == "dac vth1 2100\n");
proxy.Call("dac", {"vth2"}, -1, GET, oss2);
caller.call("dac", {"vth2"}, -1, GET, oss2);
REQUIRE(oss2.str() == "dac vth2 2200\n");
proxy.Call("dac", {"vth3"}, -1, GET, oss3);
caller.call("dac", {"vth3"}, -1, GET, oss3);
REQUIRE(oss3.str() == "dac vth3 2100\n");
}
// counters enabled, sets remembered values
proxy.Call("counters", {"0", "1"}, -1, PUT);
caller.call("counters", {"0", "1"}, -1, PUT);
{
std::ostringstream oss1, oss2, oss3;
proxy.Call("dac", {"vth1"}, -1, GET, oss1);
caller.call("dac", {"vth1"}, -1, GET, oss1);
REQUIRE(oss1.str() == "dac vth1 2100\n");
proxy.Call("dac", {"vth2"}, -1, GET, oss2);
caller.call("dac", {"vth2"}, -1, GET, oss2);
REQUIRE(oss2.str() == "dac vth2 2200\n");
proxy.Call("dac", {"vth3"}, -1, GET, oss3);
caller.call("dac", {"vth3"}, -1, GET, oss3);
REQUIRE(oss3.str() == "dac vth3 2800\n");
}
// Reset dacs after test
@@ -126,81 +135,81 @@ TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmd][.dacs]") {
det.setDAC(defs::VTH3, vth3[i], false, {i});
}
}
REQUIRE_THROWS(proxy.Call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vsvn"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vtrim"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vrpreamp"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcn"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"iodelay"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcascn_pb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcascp_pb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vout_cm"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcasc_out"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vin_cm"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_comp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"ib_test_c"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_h_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp_fe"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_cds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_rstore"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_opa_1st"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_comp_fe"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_adc1"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_l_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_cds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_cs"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_opa_fd"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_adc2"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_ds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vin_com"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vdd_prot"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vsvn"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vtrim"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vrpreamp"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcn"}, -1, GET));
// REQUIRE_THROWS(caller.call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"iodelay"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_ds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcascn_pb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcascp_pb"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vout_cm"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcasc_out"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vin_cm"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"ib_test_c"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_h_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp_fe"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_cds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_rstore"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_opa_1st"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_comp_fe"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_adc1"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_l_adc"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vref_cds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_cs"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_opa_fd"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vcom_adc2"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_ds"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vin_com"}, -1, GET));
REQUIRE_THROWS(caller.call("dac", {"vdd_prot"}, -1, GET));
}
}
/* acquisition */
TEST_CASE("readout", "[.cmd]") {
TEST_CASE("readout", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
// PUT only command
REQUIRE_THROWS(proxy.Call("readout", {}, -1, GET));
REQUIRE_THROWS(caller.call("readout", {}, -1, GET));
auto det_type = det.getDetectorType().squash();
if (det_type != defs::MYTHEN3) {
REQUIRE_THROWS(proxy.Call("readout", {}, -1, GET));
REQUIRE_THROWS(caller.call("readout", {}, -1, GET));
} else {
std::ostringstream oss;
proxy.Call("readout", {}, -1, PUT, oss);
caller.call("readout", {}, -1, PUT, oss);
REQUIRE(oss.str() == "readout successful\n");
}
}
/* Mythen3 Specific */
TEST_CASE("counters", "[.cmd]") {
TEST_CASE("counters", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
REQUIRE_THROWS(proxy.Call("counters", {}, -1, PUT));
REQUIRE_THROWS(proxy.Call("counters", {"3"}, -1, GET));
REQUIRE_THROWS(proxy.Call("counters", {"0", "-1"}, -1, GET));
REQUIRE_THROWS(proxy.Call("counters", {"0", "1", "1"}, -1, GET));
REQUIRE_THROWS(caller.call("counters", {}, -1, PUT));
REQUIRE_THROWS(caller.call("counters", {"3"}, -1, GET));
REQUIRE_THROWS(caller.call("counters", {"0", "-1"}, -1, GET));
REQUIRE_THROWS(caller.call("counters", {"0", "1", "1"}, -1, GET));
auto mask = det.getCounterMask({0}).squash(-1);
std::vector<std::string> list_str;
@@ -210,140 +219,140 @@ TEST_CASE("counters", "[.cmd]") {
}
}
std::ostringstream oss_set, oss_set2, oss_set3, oss_get;
proxy.Call("counters", {"0", "2", "1"}, -1, PUT, oss_set);
caller.call("counters", {"0", "2", "1"}, -1, PUT, oss_set);
REQUIRE(oss_set.str() == "counters [0, 2, 1]\n");
proxy.Call("counters", {"0", "2"}, -1, PUT, oss_set2);
caller.call("counters", {"0", "2"}, -1, PUT, oss_set2);
REQUIRE(oss_set2.str() == "counters [0, 2]\n");
// put back old value
proxy.Call("counters", list_str, -1, PUT, oss_set3);
caller.call("counters", list_str, -1, PUT, oss_set3);
REQUIRE(oss_set3.str() == "counters " + ToString(list_str) + "\n");
proxy.Call("counters", {}, -1, GET, oss_get);
caller.call("counters", {}, -1, GET, oss_get);
REQUIRE(oss_get.str() == "counters " + ToString(list_str) + "\n");
} else {
REQUIRE_THROWS(proxy.Call("counters", {}, -1, GET));
REQUIRE_THROWS(caller.call("counters", {}, -1, GET));
}
}
TEST_CASE("gates", "[.cmd]") {
TEST_CASE("gates", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getNumberOfGates();
{
std::ostringstream oss;
proxy.Call("gates", {"1000"}, -1, PUT, oss);
caller.call("gates", {"1000"}, -1, PUT, oss);
REQUIRE(oss.str() == "gates 1000\n");
}
{
std::ostringstream oss;
proxy.Call("gates", {}, -1, GET, oss);
caller.call("gates", {}, -1, GET, oss);
REQUIRE(oss.str() == "gates 1000\n");
}
{
std::ostringstream oss;
proxy.Call("gates", {"1"}, -1, PUT, oss);
caller.call("gates", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "gates 1\n");
}
REQUIRE_THROWS(proxy.Call("gates", {"0"}, -1, PUT));
REQUIRE_THROWS(caller.call("gates", {"0"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setNumberOfGates(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("gates", {}, -1, GET));
REQUIRE_THROWS(caller.call("gates", {}, -1, GET));
}
}
TEST_CASE("exptime1", "[.cmd]") {
TEST_CASE("exptime1", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getExptime(0);
{
std::ostringstream oss;
proxy.Call("exptime1", {"1.25s"}, -1, PUT, oss);
caller.call("exptime1", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime1 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime1", {}, -1, GET, oss);
caller.call("exptime1", {}, -1, GET, oss);
REQUIRE(oss.str() == "exptime1 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime1", {"0"}, -1, PUT, oss);
caller.call("exptime1", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime1 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setExptime(0, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("exptime1", {}, -1, GET));
REQUIRE_THROWS(caller.call("exptime1", {}, -1, GET));
}
}
TEST_CASE("exptime2", "[.cmd]") {
TEST_CASE("exptime2", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getExptime(1);
{
std::ostringstream oss;
proxy.Call("exptime2", {"1.25s"}, -1, PUT, oss);
caller.call("exptime2", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime2 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime2", {}, -1, GET, oss);
caller.call("exptime2", {}, -1, GET, oss);
REQUIRE(oss.str() == "exptime2 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime2", {"0"}, -1, PUT, oss);
caller.call("exptime2", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime2 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setExptime(1, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("exptime2", {}, -1, GET));
REQUIRE_THROWS(caller.call("exptime2", {}, -1, GET));
}
}
TEST_CASE("exptime3", "[.cmd]") {
TEST_CASE("exptime3", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getExptime(2);
{
std::ostringstream oss;
proxy.Call("exptime3", {"1.25s"}, -1, PUT, oss);
caller.call("exptime3", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime3 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime3", {}, -1, GET, oss);
caller.call("exptime3", {}, -1, GET, oss);
REQUIRE(oss.str() == "exptime3 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("exptime3", {"0"}, -1, PUT, oss);
caller.call("exptime3", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "exptime3 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setExptime(2, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("exptime3", {}, -1, GET));
REQUIRE_THROWS(caller.call("exptime3", {}, -1, GET));
}
}
TEST_CASE("gatedelay", "[.cmd]") {
TEST_CASE("gatedelay", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getExptimeForAllGates().tsquash(
@@ -353,148 +362,148 @@ TEST_CASE("gatedelay", "[.cmd]") {
}
{
std::ostringstream oss;
proxy.Call("gatedelay", {"0.05"}, -1, PUT, oss);
caller.call("gatedelay", {"0.05"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay 0.05\n");
}
if (det_type != defs::MYTHEN3) {
std::ostringstream oss;
proxy.Call("gatedelay", {}, -1, GET, oss);
caller.call("gatedelay", {}, -1, GET, oss);
REQUIRE(oss.str() == "gatedelay 50ms\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay", {"1s"}, -1, PUT, oss);
caller.call("gatedelay", {"1s"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay 1s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay", {"0"}, -1, PUT, oss);
caller.call("gatedelay", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay 0\n");
}
det.setGateDelay(-1, prev_val[0]);
} else {
REQUIRE_THROWS(proxy.Call("gatedelay", {}, -1, GET));
REQUIRE_THROWS(caller.call("gatedelay", {}, -1, GET));
}
}
TEST_CASE("gatedelay1", "[.cmd]") {
TEST_CASE("gatedelay1", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getGateDelay(0);
{
std::ostringstream oss;
proxy.Call("gatedelay1", {"1.25s"}, -1, PUT, oss);
caller.call("gatedelay1", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay1 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay1", {}, -1, GET, oss);
caller.call("gatedelay1", {}, -1, GET, oss);
REQUIRE(oss.str() == "gatedelay1 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay1", {"0"}, -1, PUT, oss);
caller.call("gatedelay1", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay1 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setGateDelay(0, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("gatedelay1", {}, -1, GET));
REQUIRE_THROWS(caller.call("gatedelay1", {}, -1, GET));
}
}
TEST_CASE("gatedelay2", "[.cmd]") {
TEST_CASE("gatedelay2", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getGateDelay(1);
{
std::ostringstream oss;
proxy.Call("gatedelay2", {"1.25s"}, -1, PUT, oss);
caller.call("gatedelay2", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay2 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay2", {}, -1, GET, oss);
caller.call("gatedelay2", {}, -1, GET, oss);
REQUIRE(oss.str() == "gatedelay2 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay2", {"0"}, -1, PUT, oss);
caller.call("gatedelay2", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay2 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setGateDelay(1, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("gatedelay2", {}, -1, GET));
REQUIRE_THROWS(caller.call("gatedelay2", {}, -1, GET));
}
}
TEST_CASE("gatedelay3", "[.cmd]") {
TEST_CASE("gatedelay3", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
auto prev_val = det.getGateDelay(2);
{
std::ostringstream oss;
proxy.Call("gatedelay3", {"1.25s"}, -1, PUT, oss);
caller.call("gatedelay3", {"1.25s"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay3 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay3", {}, -1, GET, oss);
caller.call("gatedelay3", {}, -1, GET, oss);
REQUIRE(oss.str() == "gatedelay3 1.25s\n");
}
{
std::ostringstream oss;
proxy.Call("gatedelay3", {"0"}, -1, PUT, oss);
caller.call("gatedelay3", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "gatedelay3 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setGateDelay(2, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("gatedelay3", {}, -1, GET));
REQUIRE_THROWS(caller.call("gatedelay3", {}, -1, GET));
}
}
TEST_CASE("polarity", "[.cmd]") {
TEST_CASE("polarity", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::MYTHEN3) {
auto prev_val = det.getPolarity();
{
std::ostringstream oss;
proxy.Call("polarity", {"pos"}, -1, PUT, oss);
caller.call("polarity", {"pos"}, -1, PUT, oss);
REQUIRE(oss.str() == "polarity pos\n");
}
{
std::ostringstream oss;
proxy.Call("polarity", {"neg"}, -1, PUT, oss);
caller.call("polarity", {"neg"}, -1, PUT, oss);
REQUIRE(oss.str() == "polarity neg\n");
}
{
std::ostringstream oss;
proxy.Call("polarity", {}, -1, GET, oss);
caller.call("polarity", {}, -1, GET, oss);
REQUIRE(oss.str() == "polarity neg\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPolarity(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("polarity", {}, -1, GET));
REQUIRE_THROWS(caller.call("polarity", {}, -1, GET));
}
}
TEST_CASE("interpolation", "[.cmd]") {
TEST_CASE("interpolation", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::MYTHEN3) {
auto prev_interpolation = det.getInterpolation();
auto prev_mask = det.getCounterMask();
@@ -509,7 +518,7 @@ TEST_CASE("interpolation", "[.cmd]") {
det.setCounterMask(fixedMask[i]);
{
std::ostringstream oss;
proxy.Call("interpolation", {"1"}, -1, PUT, oss);
caller.call("interpolation", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "interpolation 1\n");
REQUIRE(det.getCounterMask().tsquash(
"inconsistent counter mask") == 7);
@@ -519,7 +528,7 @@ TEST_CASE("interpolation", "[.cmd]") {
}
{
std::ostringstream oss;
proxy.Call("interpolation", {"0"}, -1, PUT, oss);
caller.call("interpolation", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "interpolation 0\n");
REQUIRE(det.getCounterMask().tsquash(
"inconsistent counter mask") == fixedMask[i]);
@@ -533,7 +542,7 @@ TEST_CASE("interpolation", "[.cmd]") {
{
std::ostringstream oss;
proxy.Call("interpolation", {}, -1, GET, oss);
caller.call("interpolation", {}, -1, GET, oss);
REQUIRE(oss.str() == "interpolation 0\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -542,13 +551,13 @@ TEST_CASE("interpolation", "[.cmd]") {
det.setDAC(defs::VTH3, prev_vth3DacVal[i], 0, {i});
}
} else {
REQUIRE_THROWS(proxy.Call("interpolation", {}, -1, GET));
REQUIRE_THROWS(caller.call("interpolation", {}, -1, GET));
}
}
TEST_CASE("pumpprobe", "[.cmd]") {
TEST_CASE("pumpprobe", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::MYTHEN3) {
auto prev_val = det.getPumpProbe();
auto prev_interpolation = det.getInterpolation();
@@ -570,7 +579,7 @@ TEST_CASE("pumpprobe", "[.cmd]") {
{
// pump probe
std::ostringstream oss;
proxy.Call("pumpprobe", {"1"}, -1, PUT, oss);
caller.call("pumpprobe", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "pumpprobe 1\n");
REQUIRE(det.getDAC(defs::VTH1, 0, {0})
.tsquash("inconsistent vth2 dac value") ==
@@ -583,11 +592,11 @@ TEST_CASE("pumpprobe", "[.cmd]") {
disabledDacValue);
}
// interpolation and pump probe
REQUIRE_THROWS(proxy.Call("interpolation", {"1"}, -1, PUT));
REQUIRE_THROWS(caller.call("interpolation", {"1"}, -1, PUT));
{
// none
std::ostringstream oss;
proxy.Call("pumpprobe", {"0"}, -1, PUT, oss);
caller.call("pumpprobe", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "pumpprobe 0\n");
REQUIRE(det.getCounterMask().tsquash(
"inconsistent counter mask") == fixedMask[i]);
@@ -607,7 +616,7 @@ TEST_CASE("pumpprobe", "[.cmd]") {
}
{
std::ostringstream oss;
proxy.Call("pumpprobe", {}, -1, GET, oss);
caller.call("pumpprobe", {}, -1, GET, oss);
REQUIRE(oss.str() == "pumpprobe 0\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -619,63 +628,63 @@ TEST_CASE("pumpprobe", "[.cmd]") {
det.setDAC(defs::VTH3, prev_vth3DacVal[i], 0, {i});
}
} else {
REQUIRE_THROWS(proxy.Call("pumpprobe", {}, -1, GET));
REQUIRE_THROWS(caller.call("pumpprobe", {}, -1, GET));
}
}
TEST_CASE("apulse", "[.cmd]") {
TEST_CASE("apulse", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::MYTHEN3) {
auto prev_val = det.getAnalogPulsing();
{
std::ostringstream oss;
proxy.Call("apulse", {"1"}, -1, PUT, oss);
caller.call("apulse", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "apulse 1\n");
}
{
std::ostringstream oss;
proxy.Call("apulse", {"0"}, -1, PUT, oss);
caller.call("apulse", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "apulse 0\n");
}
{
std::ostringstream oss;
proxy.Call("apulse", {}, -1, GET, oss);
caller.call("apulse", {}, -1, GET, oss);
REQUIRE(oss.str() == "apulse 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setAnalogPulsing(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("apulse", {}, -1, GET));
REQUIRE_THROWS(caller.call("apulse", {}, -1, GET));
}
}
TEST_CASE("dpulse", "[.cmd]") {
TEST_CASE("dpulse", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
if (det.getDetectorType().squash() == defs::MYTHEN3) {
auto prev_val = det.getDigitalPulsing();
{
std::ostringstream oss;
proxy.Call("dpulse", {"1"}, -1, PUT, oss);
caller.call("dpulse", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "dpulse 1\n");
}
{
std::ostringstream oss;
proxy.Call("dpulse", {"0"}, -1, PUT, oss);
caller.call("dpulse", {"0"}, -1, PUT, oss);
REQUIRE(oss.str() == "dpulse 0\n");
}
{
std::ostringstream oss;
proxy.Call("dpulse", {}, -1, GET, oss);
caller.call("dpulse", {}, -1, GET, oss);
REQUIRE(oss.str() == "dpulse 0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setDigitalPulsing(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("dpulse", {}, -1, GET));
REQUIRE_THROWS(caller.call("dpulse", {}, -1, GET));
}
}

224
slsDetectorSoftware/tests/test-CmdProxy-pattern.cpp → slsDetectorSoftware/tests/Caller/test-Caller-pattern.cpp
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
@@ -9,7 +9,7 @@
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
@@ -19,114 +19,125 @@ using test::PUT;
/* Pattern */
TEST_CASE("patfname", "[.cmd]") {
TEST_CASE("patfname", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
REQUIRE_THROWS(proxy.Call("patfname", {}, -1, PUT));
REQUIRE_NOTHROW(proxy.Call("patfname", {}, -1, GET));
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
REQUIRE_THROWS(caller.call("patfname", {}, -1, PUT));
REQUIRE_NOTHROW(caller.call("patfname", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("patfname", {}, -1, GET));
REQUIRE_THROWS(caller.call("patfname", {}, -1, GET));
}
}
TEST_CASE("pattern", "[.cmd]") {
TEST_CASE("pattern", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
// no proper test for put
REQUIRE_THROWS(proxy.Call("pattern", {}, -1, GET));
REQUIRE_THROWS(caller.call("pattern", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("pattern", {}, -1, GET));
REQUIRE_THROWS(caller.call("pattern", {}, -1, GET));
}
}
TEST_CASE("savepattern", "[.cmd]") {
TEST_CASE("savepattern", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
REQUIRE_THROWS(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, GET));
caller.call("savepattern", {"/tmp/pattern.txt"}, -1, GET));
if (det.size() == 1) {
REQUIRE_NOTHROW(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
caller.call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
}
} else {
REQUIRE_THROWS(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
caller.call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
}
}
TEST_CASE("defaultpattern", "[.cmd]") {
TEST_CASE("defaultpattern", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
REQUIRE_THROWS(proxy.Call("defaultpattern", {}, -1, GET));
REQUIRE_NOTHROW(proxy.Call("defaultpattern", {}, -1, PUT));
REQUIRE_THROWS(caller.call("defaultpattern", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("defaultpattern", {}, -1, PUT));
} else {
REQUIRE_THROWS(proxy.Call("defaultpattern", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("defaultpattern", {}, -1, PUT));
REQUIRE_THROWS(caller.call("defaultpattern", {}, -1, GET));
REQUIRE_THROWS(caller.call("defaultpattern", {}, -1, PUT));
}
}
TEST_CASE("patioctrl", "[.cmd]") {
TEST_CASE("patioctrl", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD) {
auto prev_val = det.getPatternIOControl();
{
if (det_type == defs::CHIPTESTBOARD) {
std::ostringstream oss;
proxy.Call("patioctrl", {"0xc15004808d0a21a4"}, -1, PUT, oss);
caller.call("patioctrl", {"0xc15004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() == "patioctrl 0xc15004808d0a21a4\n");
}
{
std::ostringstream oss;
proxy.Call("patioctrl", {"0xaadf0"}, -1, PUT, oss);
caller.call("patioctrl", {"0xaadf0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patioctrl 0x00000000000aadf0\n");
}
{
std::ostringstream oss;
proxy.Call("patioctrl", {}, -1, GET, oss);
caller.call("patioctrl", {}, -1, GET, oss);
REQUIRE(oss.str() == "patioctrl 0x00000000000aadf0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternIOControl(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patioctrl", {}, -1, GET));
REQUIRE_THROWS(caller.call("patioctrl", {}, -1, GET));
}
}
TEST_CASE("patword", "[.cmd]") {
TEST_CASE("patword", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
int addr = 0x23;
std::string saddr = ToStringHex(addr, 4);
auto prev_val = det.getPatternWord(addr);
{
std::ostringstream oss;
proxy.Call("patword", {saddr, "0xc15004808d0a21a4"}, -1, PUT, oss);
caller.call("patword", {saddr, "0xc15004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() ==
"patword [" + saddr + ", 0xc15004808d0a21a4]\n");
}
{
std::ostringstream oss;
proxy.Call("patword", {saddr, "0xaadf0"}, -1, PUT, oss);
caller.call("patword", {saddr, "0x815004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() ==
"patword [" + saddr + ", 0x815004808d0a21a4]\n");
}
{
std::ostringstream oss;
caller.call("patword", {saddr, "0xaadf0"}, -1, PUT, oss);
REQUIRE(oss.str() ==
"patword [" + saddr + ", 0x00000000000aadf0]\n");
}
{
std::ostringstream oss;
proxy.Call("patword", {saddr}, -1, GET, oss);
caller.call("patword", {saddr}, -1, GET, oss);
REQUIRE(oss.str() ==
"patword [" + saddr + ", 0x00000000000aadf0]\n");
}
@@ -134,25 +145,26 @@ TEST_CASE("patword", "[.cmd]") {
det.setPatternWord(addr, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patword", {"0x23"}, -1, GET));
REQUIRE_THROWS(caller.call("patword", {"0x23"}, -1, GET));
}
}
TEST_CASE("patlimits", "[.cmd]") {
TEST_CASE("patlimits", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopAddresses(-1);
{
std::ostringstream oss;
proxy.Call("patlimits", {"0x20", "0x5c"}, -1, PUT, oss);
caller.call("patlimits", {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patlimits [0x0020, 0x005c]\n");
}
{
std::ostringstream oss;
proxy.Call("patlimits", {}, -1, GET, oss);
caller.call("patlimits", {}, -1, GET, oss);
REQUIRE(oss.str() == "patlimits [0x0020, 0x005c]\n");
}
for (int i = 0; i != det.size(); ++i) {
@@ -160,16 +172,17 @@ TEST_CASE("patlimits", "[.cmd]") {
{i});
}
} else {
REQUIRE_THROWS(proxy.Call("patlimits", {}, -1, GET));
REQUIRE_THROWS(caller.call("patlimits", {}, -1, GET));
}
}
TEST_CASE("patloop", "[.cmd]") {
TEST_CASE("patloop", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
// m3 only has 3 levels
if (det_type == defs::MYTHEN3 && iLoop >= 3) {
@@ -179,26 +192,26 @@ TEST_CASE("patloop", "[.cmd]") {
std::string sLoop = ToString(iLoop);
if (iLoop < 3) {
std::string deprecatedCmd = "patloop" + sLoop;
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {"0x20", "0x5c"}, -1, PUT, oss);
caller.call(deprecatedCmd, {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == deprecatedCmd + " [0x0020, 0x005c]\n");
}
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {}, -1, GET, oss);
caller.call(deprecatedCmd, {}, -1, GET, oss);
REQUIRE(oss.str() == deprecatedCmd + " [0x0020, 0x005c]\n");
}
}
{
std::ostringstream oss;
proxy.Call("patloop", {sLoop, "0x20", "0x5c"}, -1, PUT, oss);
caller.call("patloop", {sLoop, "0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() ==
"patloop " + sLoop + " [0x0020, 0x005c]\n");
}
{
std::ostringstream oss;
proxy.Call("patloop", {sLoop}, -1, GET, oss);
caller.call("patloop", {sLoop}, -1, GET, oss);
REQUIRE(oss.str() ==
"patloop " + sLoop + " [0x0020, 0x005c]\n");
}
@@ -208,16 +221,17 @@ TEST_CASE("patloop", "[.cmd]") {
}
}
} else {
REQUIRE_THROWS(proxy.Call("patloop", {"0"}, -1, GET));
REQUIRE_THROWS(caller.call("patloop", {"0"}, -1, GET));
}
}
TEST_CASE("patnloop", "[.cmd]") {
TEST_CASE("patnloop", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
// m3 only has 3 levels
if (det_type == defs::MYTHEN3 && iLoop >= 3) {
@@ -227,25 +241,25 @@ TEST_CASE("patnloop", "[.cmd]") {
std::string sLoop = ToString(iLoop);
if (iLoop < 3) {
std::string deprecatedCmd = "patnloop" + sLoop;
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {"5"}, -1, PUT, oss);
caller.call(deprecatedCmd, {"5"}, -1, PUT, oss);
REQUIRE(oss.str() == deprecatedCmd + " 5\n");
}
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {}, -1, GET, oss);
caller.call(deprecatedCmd, {}, -1, GET, oss);
REQUIRE(oss.str() == deprecatedCmd + " 5\n");
}
}
{
std::ostringstream oss;
proxy.Call("patnloop", {sLoop, "5"}, -1, PUT, oss);
caller.call("patnloop", {sLoop, "5"}, -1, PUT, oss);
REQUIRE(oss.str() == "patnloop " + sLoop + " 5\n");
}
{
std::ostringstream oss;
proxy.Call("patnloop", {sLoop}, -1, GET, oss);
caller.call("patnloop", {sLoop}, -1, GET, oss);
REQUIRE(oss.str() == "patnloop " + sLoop + " 5\n");
}
for (int iDet = 0; iDet != det.size(); ++iDet) {
@@ -253,16 +267,17 @@ TEST_CASE("patnloop", "[.cmd]") {
}
}
} else {
REQUIRE_THROWS(proxy.Call("patnloop", {"0"}, -1, GET));
REQUIRE_THROWS(caller.call("patnloop", {"0"}, -1, GET));
}
}
TEST_CASE("patwait", "[.cmd]") {
TEST_CASE("patwait", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
// m3 only has 3 levels
if (det_type == defs::MYTHEN3 && iLoop >= 3) {
@@ -272,25 +287,25 @@ TEST_CASE("patwait", "[.cmd]") {
std::string sLoop = ToString(iLoop);
if (iLoop < 3) {
std::string deprecatedCmd = "patwait" + sLoop;
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {"0x5c"}, -1, PUT, oss);
caller.call(deprecatedCmd, {"0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == deprecatedCmd + " 0x005c\n");
}
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {}, -1, GET, oss);
caller.call(deprecatedCmd, {}, -1, GET, oss);
REQUIRE(oss.str() == deprecatedCmd + " 0x005c\n");
}
}
{
std::ostringstream oss;
proxy.Call("patwait", {sLoop, "0x5c"}, -1, PUT, oss);
caller.call("patwait", {sLoop, "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwait " + sLoop + " 0x005c\n");
}
{
std::ostringstream oss;
proxy.Call("patwait", {sLoop}, -1, GET, oss);
caller.call("patwait", {sLoop}, -1, GET, oss);
REQUIRE(oss.str() == "patwait " + sLoop + " 0x005c\n");
}
for (int iDet = 0; iDet != det.size(); ++iDet) {
@@ -298,16 +313,17 @@ TEST_CASE("patwait", "[.cmd]") {
}
}
} else {
REQUIRE_THROWS(proxy.Call("patwait", {"0"}, -1, GET));
REQUIRE_THROWS(caller.call("patwait", {"0"}, -1, GET));
}
}
TEST_CASE("patwaittime", "[.cmd]") {
TEST_CASE("patwaittime", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
// m3 only has 3 levels
if (det_type == defs::MYTHEN3 && iLoop >= 3) {
@@ -317,25 +333,25 @@ TEST_CASE("patwaittime", "[.cmd]") {
std::string sLoop = ToString(iLoop);
if (iLoop < 3) {
std::string deprecatedCmd = "patwaittime" + sLoop;
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {"8589936640"}, -1, PUT, oss);
caller.call(deprecatedCmd, {"8589936640"}, -1, PUT, oss);
REQUIRE(oss.str() == deprecatedCmd + " 8589936640\n");
}
{ // depreciated
{ // deprecated
std::ostringstream oss;
proxy.Call(deprecatedCmd, {}, -1, GET, oss);
caller.call(deprecatedCmd, {}, -1, GET, oss);
REQUIRE(oss.str() == deprecatedCmd + " 8589936640\n");
}
}
{
std::ostringstream oss;
proxy.Call("patwaittime", {sLoop, "8589936640"}, -1, PUT, oss);
caller.call("patwaittime", {sLoop, "8589936640"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwaittime " + sLoop + " 8589936640\n");
}
{
std::ostringstream oss;
proxy.Call("patwaittime", {sLoop}, -1, GET, oss);
caller.call("patwaittime", {sLoop}, -1, GET, oss);
REQUIRE(oss.str() == "patwaittime " + sLoop + " 8589936640\n");
}
for (int iDet = 0; iDet != det.size(); ++iDet) {
@@ -343,69 +359,71 @@ TEST_CASE("patwaittime", "[.cmd]") {
}
}
} else {
REQUIRE_THROWS(proxy.Call("patwaittime", {"0"}, -1, GET));
REQUIRE_THROWS(caller.call("patwaittime", {"0"}, -1, GET));
}
}
TEST_CASE("patmask", "[.cmd]") {
TEST_CASE("patmask", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternMask();
{
std::ostringstream oss;
proxy.Call("patmask", {"0x842f020204200dc0"}, -1, PUT, oss);
caller.call("patmask", {"0x842f020204200dc0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patmask 0x842f020204200dc0\n");
}
{
std::ostringstream oss;
proxy.Call("patmask", {}, -1, GET, oss);
caller.call("patmask", {}, -1, GET, oss);
REQUIRE(oss.str() == "patmask 0x842f020204200dc0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternMask(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patmask", {}, -1, GET));
REQUIRE_THROWS(caller.call("patmask", {}, -1, GET));
}
}
TEST_CASE("patsetbit", "[.cmd]") {
TEST_CASE("patsetbit", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MYTHEN3) {
if (det_type == defs::CHIPTESTBOARD ||
det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternBitMask();
{
std::ostringstream oss;
proxy.Call("patsetbit", {"0x842f020204200dc0"}, -1, PUT, oss);
caller.call("patsetbit", {"0x842f020204200dc0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patsetbit 0x842f020204200dc0\n");
}
{
std::ostringstream oss;
proxy.Call("patsetbit", {}, -1, GET, oss);
caller.call("patsetbit", {}, -1, GET, oss);
REQUIRE(oss.str() == "patsetbit 0x842f020204200dc0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternBitMask(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patsetbit", {}, -1, GET));
REQUIRE_THROWS(caller.call("patsetbit", {}, -1, GET));
}
}
TEST_CASE("patternstart", "[.cmd]") {
TEST_CASE("patternstart", "[.cmdcall]") {
Detector det;
CmdProxy proxy(&det);
REQUIRE_THROWS(proxy.Call("patternstart", {}, -1, GET));
Caller caller(&det);
REQUIRE_THROWS(caller.call("patternstart", {}, -1, GET));
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
REQUIRE_NOTHROW(proxy.Call("patternstart", {}, -1, PUT));
REQUIRE_NOTHROW(caller.call("patternstart", {}, -1, PUT));
} else {
REQUIRE_THROWS(proxy.Call("patternstart", {}, -1, PUT));
REQUIRE_THROWS(caller.call("patternstart", {}, -1, PUT));
}
}

478
slsDetectorSoftware/tests/test-CmdProxy-rx.cpp → slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp
View File

File diff suppressed because it is too large Load Diff

35
slsDetectorSoftware/tests/Caller/test-Caller-xilinx-chiptestboard.cpp Normal file
View File

@@ -0,0 +1,35 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "Caller.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-Caller-global.h"
#include "tests/globals.h"
namespace sls {
using test::GET;
using test::PUT;
/* dacs */
TEST_CASE("configtransceiver", "[.cmdcall]") {
Detector det;
Caller caller(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::XILINX_CHIPTESTBOARD) {
REQUIRE_THROWS(caller.call("configtransceiver", {}, -1, GET));
REQUIRE_NOTHROW(caller.call("configtransceiver", {}, -1, PUT));
} else {
REQUIRE_THROWS(caller.call("configtransceiver", {}, -1, PUT));
REQUIRE_THROWS(caller.call("configtransceiver", {}, -1, GET));
}
}
} // namespace sls

2190
slsDetectorSoftware/tests/test-CmdProxy.cpp → slsDetectorSoftware/tests/Caller/test-Caller.cpp
View File

File diff suppressed because it is too large Load Diff

2
slsDetectorSoftware/tests/test-CmdParser.cpp
View File

@@ -7,7 +7,7 @@
// tests to add
// help for all docs
// command for all depreciated commands
// command for all deprecated commands
namespace sls {

17
slsDetectorSoftware/tests/test-CmdProxy-global.h
View File

@@ -1,17 +0,0 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#pragma once
#include "sls/sls_detector_defs.h"
namespace sls {
void test_valid_port(const std::string &command,
const std::vector<std::string> &arguments, int detector_id,
int action);
void test_dac(slsDetectorDefs::dacIndex index, const std::string &dacname,
int dacvalue);
void test_onchip_dac(slsDetectorDefs::dacIndex index,
const std::string &dacname, int dacvalue);
} // namespace sls

164
slsDetectorSoftware/tests/test-CmdProxy-gotthard.cpp
View File

@@ -1,164 +0,0 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "tests/globals.h"
namespace sls {
using test::GET;
using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back GOTTHARD dacs", "[.cmd][.dacs]") {
// vref_ds, vcascn_pb, vcascp_pb, vout_cm, vcasc_out, vin_cm, vref_comp,
// ib_test_c
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
SECTION("vref_ds") { test_dac(defs::VREF_DS, "vref_ds", 660); }
SECTION("vcascn_pb") { test_dac(defs::VCASCN_PB, "vcascn_pb", 650); }
SECTION("vcascp_pb") { test_dac(defs::VCASCP_PB, "vcascp_pb", 1480); }
SECTION("vout_cm") { test_dac(defs::VOUT_CM, "vout_cm", 1520); }
SECTION("vcasc_out") { test_dac(defs::VCASC_OUT, "vcasc_out", 1320); }
SECTION("vin_cm") { test_dac(defs::VIN_CM, "vin_cm", 1350); }
SECTION("vref_comp") { test_dac(defs::VREF_COMP, "vref_comp", 350); }
SECTION("ib_test_c") { test_dac(defs::IB_TESTC, "ib_test_c", 2001); }
// eiger
REQUIRE_THROWS(proxy.Call("dac", {"vthreshold"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vsvp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vsvn"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtgstv"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_ll"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_lr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rl"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcmp_rr"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_rb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"rxb_lb"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcn"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"iodelay"}, -1, GET));
// jungfrau
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vdd_prot"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vin_com"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_prech"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_pixbuf"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_ds"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vref_ds"}, -1, GET));
// REQUIRE_THROWS(proxy.Call("dac", {"vref_comp"}, -1, GET));
// mythen3
REQUIRE_THROWS(proxy.Call("dac", {"vrpreamp"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vrshaper_n"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vipre"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vishaper"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vdcsh"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth1"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth2"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vth3"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal_n"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcal_p"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vtrim"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcassh"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcas"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vicin"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vipre_out"}, -1, GET));
// gotthard2
REQUIRE_THROWS(proxy.Call("dac", {"vref_h_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp_fe"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_comp_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_cds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_rstore"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_opa_1st"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_comp_fe"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_adc1"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_l_adc"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vref_cds"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_cs"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vb_opa_fd"}, -1, GET));
REQUIRE_THROWS(proxy.Call("dac", {"vcom_adc2"}, -1, GET));
}
}
/* Gotthard Specific */
TEST_CASE("roi", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
if (det.size() > 1) {
REQUIRE_THROWS(proxy.Call("roi", {"0", "255"}, -1, PUT));
REQUIRE_NOTHROW(proxy.Call("roi", {}, -1, GET));
} else {
auto prev_val = det.getROI();
{
std::ostringstream oss;
proxy.Call("roi", {"0", "255"}, -1, PUT, oss);
REQUIRE(oss.str() == "roi [0, 255]\n");
}
{
std::ostringstream oss;
proxy.Call("roi", {"256", "511"}, -1, PUT, oss);
REQUIRE(oss.str() == "roi [256, 511]\n");
}
REQUIRE_THROWS(proxy.Call("roi", {"0", "256"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setROI(prev_val[i], i);
}
}
} else {
REQUIRE_THROWS(proxy.Call("roi", {}, -1, GET));
}
}
TEST_CASE("clearroi", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
auto prev_val = det.getROI();
{
std::ostringstream oss;
proxy.Call("clearroi", {}, -1, PUT, oss);
REQUIRE(oss.str() == "clearroi successful\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setROI(prev_val[i], i);
}
} else {
REQUIRE_THROWS(proxy.Call("clearroi", {}, -1, PUT));
}
}
TEST_CASE("exptimel", "[.cmd]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD) {
REQUIRE_NOTHROW(proxy.Call("exptimel", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("exptimel", {}, -1, GET));
}
}
} // namespace sls

109
slsDetectorSoftware/tests/test-CmdProxy-moench.cpp
View File

@@ -1,109 +0,0 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "CmdProxy.h"
#include "catch.hpp"
#include "sls/Detector.h"
#include "sls/sls_detector_defs.h"
#include <sstream>
#include "sls/Result.h"
#include "sls/ToString.h"
#include "sls/versionAPI.h"
#include "test-CmdProxy-global.h"
#include "tests/globals.h"
namespace sls {
using test::GET;
using test::PUT;
/* dacs */
TEST_CASE("Setting and reading back moench dacs", "[.cmd][.dacs]") {
// vbp_colbuf, vipre, vin_cm, vb_sda, vcasc_sfp, vout_cm, vipre_cds,
// ibias_sfp
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MOENCH) {
SECTION("vbp_colbuf") {
test_dac(defs::VBP_COLBUF, "vbp_colbuf", 1300);
}
SECTION("vipre") { test_dac(defs::VIPRE, "vipre", 1000); }
SECTION("vin_cm") { test_dac(defs::VIN_CM, "vin_cm", 1400); }
SECTION("vb_sda") { test_dac(defs::VB_SDA, "vb_sda", 680); }
SECTION("vcasc_sfp") { test_dac(defs::VCASC_SFP, "vcasc_sfp", 1428); }
SECTION("vout_cm") { test_dac(defs::VOUT_CM, "vout_cm", 1200); }
SECTION("vipre_cds") { test_dac(defs::VIPRE_CDS, "vipre_cds", 800); }
SECTION("ibias_sfp") { test_dac(defs::IBIAS_SFP, "ibias_sfp", 900); }
// eiger
REQUIRE_THROWS(proxy.Call("vthreshold", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vsvp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vsvn", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtrim", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtgstv", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_ll", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_lr", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_rl", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcmp_rr", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("rxb_rb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("rxb_lb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcn", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vishaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("iodelay", {}, -1, GET));
// gotthard
REQUIRE_THROWS(proxy.Call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascn_pb", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcascp_pb", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vout_cm", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcasc_out", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vin_cm", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("ib_test_c", {}, -1, GET));
// mythen3
REQUIRE_THROWS(proxy.Call("vrpreamp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vrshaper_n", {}, -1, GET));
// REQUIRE_THROWS(proxy.Call("vipre", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vishaper", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vdcsh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth2", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vth3", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_n", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcal_p", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vtrim", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcassh", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcas", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vicin", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vipre_out", {}, -1, GET));
// gotthard2
REQUIRE_THROWS(proxy.Call("vref_h_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_comp_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_rstore", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_1st", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp_fe", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc1", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_l_adc", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_cds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_cs", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_opa_fd", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vcom_adc2", {}, -1, GET));
// jungfrau
REQUIRE_THROWS(proxy.Call("vb_comp", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vdd_prot", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vin_com", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_prech", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_pixbuf", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vb_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_ds", {}, -1, GET));
REQUIRE_THROWS(proxy.Call("vref_comp", {}, -1, GET));
}
}
} // namespace sls

25
slsDetectorSoftware/tests/test-Module.cpp
View File

@@ -1,5 +1,6 @@
// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#include "Detector.h"
#include "Module.h"
#include "SharedMemory.h"
#include "catch.hpp"
@@ -10,7 +11,9 @@ using dt = slsDetectorDefs::detectorType;
TEST_CASE("Construction with a defined detector type") {
Module m(dt::EIGER);
REQUIRE(m.getDetectorType() == dt::EIGER);
m.freeSharedMemory(); // clean up
freeSharedMemory(0, 0); // clean up
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
TEST_CASE("Read back detector type from shm") {
@@ -23,7 +26,9 @@ TEST_CASE("Read back detector type from shm") {
// Now both objects point to the same shm so we can only
// free one!
m2.freeSharedMemory();
freeSharedMemory(0, 0);
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
TEST_CASE("Is shm fixed pattern shm compatible") {
@@ -41,25 +46,33 @@ TEST_CASE("Is shm fixed pattern shm compatible") {
// Should fail since version is set to 0
REQUIRE(m.isFixedPatternSharedMemoryCompatible() == false);
m.freeSharedMemory();
freeSharedMemory(0, 0);
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
TEST_CASE("Get default control port") {
Module m(dt::MYTHEN3);
REQUIRE(m.getControlPort() == 1952);
m.freeSharedMemory();
freeSharedMemory(0, 0);
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
TEST_CASE("Get default stop port") {
Module m(dt::GOTTHARD2);
REQUIRE(m.getStopPort() == 1953);
m.freeSharedMemory();
freeSharedMemory(0, 0);
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
TEST_CASE("Get default receiver TCP port") {
Module m(dt::MYTHEN3);
REQUIRE(m.getReceiverPort() == 1954);
m.freeSharedMemory();
freeSharedMemory(0, 0);
SharedMemory<sharedModule> moduleShm(0, 0);
REQUIRE(moduleShm.exists() == false);
}
} // namespace sls