Filip Leonarski
224cc8b89c
This is an UNSTABLE release. * jfjoch_broker: Add auto-contrast option for preview images * Frontend: Add logo image * jfjoch_viewer: Add logo image * jfjoch_viewer: For image chart allow to set min value to zero * jfjoch_viewer: For resolution estimation plots, visualization uses 1/d^2 as measure * jfjoch_viewer: Add 3D unit cell visualization (experimental/WIP/not really there) * Documentation: Add logo image Reviewed-on: #16 Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch> Co-committed-by: Filip Leonarski <filip.leonarski@psi.ch>
120 KiB
jfjoch_client.DefaultApi
All URIs are relative to http://localhost:5232
| Method | HTTP request | Description |
|---|---|---|
| cancel_post | POST /cancel | Cancel running data collection |
| config_azim_int_get | GET /config/azim_int | Get azimuthal integration configuration |
| config_azim_int_put | PUT /config/azim_int | Configure azimuthal integration |
| config_dark_mask_get | GET /config/dark_mask | Get settings for dark data collection to calculate mask |
| config_dark_mask_put | PUT /config/dark_mask | Set configuration for dark data collection to calculate mask |
| config_detector_get | GET /config/detector | Get detector configuration |
| config_detector_put | PUT /config/detector | Change detector configuration |
| config_file_writer_get | GET /config/file_writer | Get file writer settings |
| config_file_writer_put | PUT /config/file_writer | Change file writer settings |
| config_image_format_conversion_post | POST /config/image_format/conversion | Configure format for data collection with full conversion |
| config_image_format_get | GET /config/image_format | Get image output format |
| config_image_format_put | PUT /config/image_format | Change image output format |
| config_image_format_raw_post | POST /config/image_format/raw | Configure format for raw data collection |
| config_indexing_get | GET /config/indexing | Get indexing configuration |
| config_indexing_put | PUT /config/indexing | Change indexing algorithm settings |
| config_instrument_get | GET /config/instrument | Get instrument metadata |
| config_instrument_put | PUT /config/instrument | Change instrument metadata |
| config_internal_generator_image_put | PUT /config/internal_generator_image | Load binary image for internal FPGA generator |
| config_internal_generator_image_tiff_put | PUT /config/internal_generator_image.tiff | Load TIFF image for internal FPGA generator |
| config_mask_get | GET /config/mask | Get mask of the detector (binary) |
| config_mask_tiff_get | GET /config/mask.tiff | Get mask of the detector (TIFF) |
| config_roi_get | GET /config/roi | Get ROI definitions |
| config_roi_put | PUT /config/roi | Upload ROI definitions |
| config_select_detector_get | GET /config/select_detector | List available detectors |
| config_select_detector_put | PUT /config/select_detector | Select detector |
| config_spot_finding_get | GET /config/spot_finding | Get data processing configuration |
| config_spot_finding_put | PUT /config/spot_finding | Configure spot finding |
| config_user_mask_get | GET /config/user_mask | Detector must be Initialized. Get user mask of the detector (binary) |
| config_user_mask_put | PUT /config/user_mask | Upload user mask of the detector (binary) |
| config_user_mask_tiff_get | GET /config/user_mask.tiff | Detector must be Initialized. Get user mask of the detector (TIFF) |
| config_user_mask_tiff_put | PUT /config/user_mask.tiff | Upload user mask of the detector |
| config_zeromq_metadata_get | GET /config/zeromq_metadata | Get ZeroMQ metadata socket settings |
| config_zeromq_metadata_put | PUT /config/zeromq_metadata | Set ZeroMQ metadata settings |
| config_zeromq_preview_get | GET /config/zeromq_preview | Get ZeroMQ preview settings |
| config_zeromq_preview_put | PUT /config/zeromq_preview | Set ZeroMQ preview settings |
| deactivate_post | POST /deactivate | Prepare detector to turn off |
| detector_status_get | GET /detector/status | Get detector status |
| fpga_status_get | GET /fpga_status | Get status of FPGA devices |
| image_buffer_clear_post | POST /image_buffer/clear | Clear image buffer |
| image_buffer_image_cbor_get | GET /image_buffer/image.cbor | Get image message in CBOR format |
| image_buffer_image_jpeg_get | GET /image_buffer/image.jpeg | Get preview image in JPEG format using custom settings |
| image_buffer_image_tiff_get | GET /image_buffer/image.tiff | Get preview image in TIFF format |
| image_buffer_start_cbor_get | GET /image_buffer/start.cbor | Get Start message in CBOR format |
| image_buffer_status_get | GET /image_buffer/status | Get status of the image buffers |
| initialize_post | POST /initialize | Initialize detector and data acquisition |
| pedestal_post | POST /pedestal | Collect dark current for the detector |
| preview_pedestal_tiff_get | GET /preview/pedestal.tiff | Get pedestal in TIFF format |
| preview_plot_get | GET /preview/plot | Generate 1D plot from Jungfraujoch |
| result_scan_get | GET /result/scan | Get full scan result |
| start_post | POST /start | Start detector |
| statistics_calibration_get | GET /statistics/calibration | Get calibration statistics |
| statistics_data_collection_get | GET /statistics/data_collection | Get data collection statistics |
| statistics_get | GET /statistics | Get general statistics |
| status_get | GET /status | Get Jungfraujoch status |
| trigger_post | POST /trigger | Send soft trigger to the detector |
| version_get | GET /version | Get Jungfraujoch version of jfjoch_broker |
| wait_till_done_post | POST /wait_till_done | Wait for acquisition done |
| xfel_event_code_get | GET /xfel/event_code | Return XFEL event codes for the current data acquisition |
| xfel_pulse_id_get | GET /xfel/pulse_id | Return XFEL pulse IDs for the current data acquisition |
cancel_post
cancel_post()
Cancel running data collection
Command will inform FPGA network card to stop pedestal or data collection at the current stage. Any frame that is currently being processed by CPU will be finished and sent to writer. Given the command is making sure to gracefully stop data acquisition and detector, it might take some time to switch back after command finished to Idle state. If data collection is not running, the command has no effect.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Cancel running data collection
api_instance.cancel_post()
except Exception as e:
print("Exception when calling DefaultApi->cancel_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Cancel request sent to FPGAs (or ignored, as data collection is not running) | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_azim_int_get
AzimIntSettings config_azim_int_get()
Get azimuthal integration configuration
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.azim_int_settings import AzimIntSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get azimuthal integration configuration
api_response = api_instance.config_azim_int_get()
print("The response of DefaultApi->config_azim_int_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_azim_int_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_azim_int_put
config_azim_int_put(azim_int_settings=azim_int_settings)
Configure azimuthal integration
Can be done when detector is Inactive or Idle
Example
import jfjoch_client
from jfjoch_client.models.azim_int_settings import AzimIntSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
azim_int_settings = jfjoch_client.AzimIntSettings() # AzimIntSettings | (optional)
try:
# Configure azimuthal integration
api_instance.config_azim_int_put(azim_int_settings=azim_int_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_azim_int_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| azim_int_settings | AzimIntSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_dark_mask_get
DarkMaskSettings config_dark_mask_get()
Get settings for dark data collection to calculate mask
Example
import jfjoch_client
from jfjoch_client.models.dark_mask_settings import DarkMaskSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get settings for dark data collection to calculate mask
api_response = api_instance.config_dark_mask_get()
print("The response of DefaultApi->config_dark_mask_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_dark_mask_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_dark_mask_put
config_dark_mask_put(dark_mask_settings=dark_mask_settings)
Set configuration for dark data collection to calculate mask
This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point. This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.models.dark_mask_settings import DarkMaskSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
dark_mask_settings = jfjoch_client.DarkMaskSettings() # DarkMaskSettings | (optional)
try:
# Set configuration for dark data collection to calculate mask
api_instance.config_dark_mask_put(dark_mask_settings=dark_mask_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_dark_mask_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| dark_mask_settings | DarkMaskSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_detector_get
DetectorSettings config_detector_get()
Get detector configuration
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.detector_settings import DetectorSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get detector configuration
api_response = api_instance.config_detector_get()
print("The response of DefaultApi->config_detector_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_detector_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_detector_put
config_detector_put(detector_settings=detector_settings)
Change detector configuration
Detector settings are ones that have effect on calibration, i.e., pedestal has to be collected again after changing these settings. This can only be done when detector is Idle, Error or Inactive states. If detector is in Idle state , pedestal procedure will be executed automatically - there must be no X-rays on the detector during the operation. If detector is in Inactive or Error states, new settings will be saved, but no calibration will be executed.
Example
import jfjoch_client
from jfjoch_client.models.detector_settings import DetectorSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
detector_settings = jfjoch_client.DetectorSettings() # DetectorSettings | (optional)
try:
# Change detector configuration
api_instance.config_detector_put(detector_settings=detector_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_detector_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| detector_settings | DetectorSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_file_writer_get
FileWriterSettings config_file_writer_get()
Get file writer settings
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.file_writer_settings import FileWriterSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get file writer settings
api_response = api_instance.config_file_writer_get()
print("The response of DefaultApi->config_file_writer_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_file_writer_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_file_writer_put
config_file_writer_put(file_writer_settings=file_writer_settings)
Change file writer settings
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.models.file_writer_settings import FileWriterSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
file_writer_settings = jfjoch_client.FileWriterSettings() # FileWriterSettings | (optional)
try:
# Change file writer settings
api_instance.config_file_writer_put(file_writer_settings=file_writer_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_file_writer_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| file_writer_settings | FileWriterSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_image_format_conversion_post
config_image_format_conversion_post()
Configure format for data collection with full conversion
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Configure format for data collection with full conversion
api_instance.config_image_format_conversion_post()
except Exception as e:
print("Exception when calling DefaultApi->config_image_format_conversion_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_image_format_get
ImageFormatSettings config_image_format_get()
Get image output format
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.image_format_settings import ImageFormatSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get image output format
api_response = api_instance.config_image_format_get()
print("The response of DefaultApi->config_image_format_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_image_format_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_image_format_put
config_image_format_put(image_format_settings=image_format_settings)
Change image output format
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.models.image_format_settings import ImageFormatSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
image_format_settings = jfjoch_client.ImageFormatSettings() # ImageFormatSettings | (optional)
try:
# Change image output format
api_instance.config_image_format_put(image_format_settings=image_format_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_image_format_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| image_format_settings | ImageFormatSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_image_format_raw_post
config_image_format_raw_post()
Configure format for raw data collection
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Configure format for raw data collection
api_instance.config_image_format_raw_post()
except Exception as e:
print("Exception when calling DefaultApi->config_image_format_raw_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_indexing_get
IndexingSettings config_indexing_get()
Get indexing configuration
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.indexing_settings import IndexingSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get indexing configuration
api_response = api_instance.config_indexing_get()
print("The response of DefaultApi->config_indexing_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_indexing_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_indexing_put
config_indexing_put(indexing_settings=indexing_settings)
Change indexing algorithm settings
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.models.indexing_settings import IndexingSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
indexing_settings = jfjoch_client.IndexingSettings() # IndexingSettings | (optional)
try:
# Change indexing algorithm settings
api_instance.config_indexing_put(indexing_settings=indexing_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_indexing_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| indexing_settings | IndexingSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_instrument_get
InstrumentMetadata config_instrument_get()
Get instrument metadata
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.instrument_metadata import InstrumentMetadata
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get instrument metadata
api_response = api_instance.config_instrument_get()
print("The response of DefaultApi->config_instrument_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_instrument_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_instrument_put
config_instrument_put(instrument_metadata=instrument_metadata)
Change instrument metadata
This can only be done when detector is Idle, Error or Inactive states.
Example
import jfjoch_client
from jfjoch_client.models.instrument_metadata import InstrumentMetadata
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
instrument_metadata = jfjoch_client.InstrumentMetadata() # InstrumentMetadata | (optional)
try:
# Change instrument metadata
api_instance.config_instrument_put(instrument_metadata=instrument_metadata)
except Exception as e:
print("Exception when calling DefaultApi->config_instrument_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| instrument_metadata | InstrumentMetadata | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_internal_generator_image_put
config_internal_generator_image_put(id=id, body=body)
Load binary image for internal FPGA generator
Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires binary blob with 16-bit integer numbers of size of detector in raw/converted coordinates (depending on detector settings).
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
id = 56 # int | Image id to upload (optional)
body = None # bytearray | (optional)
try:
# Load binary image for internal FPGA generator
api_instance.config_internal_generator_image_put(id=id, body=body)
except Exception as e:
print("Exception when calling DefaultApi->config_internal_generator_image_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | int | Image id to upload | [optional] |
| body | bytearray | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/octet-stream
- Accept: text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_internal_generator_image_tiff_put
config_internal_generator_image_tiff_put(id=id, body=body)
Load TIFF image for internal FPGA generator
Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires TIFF with 16-bit integer numbers of size of detector in raw/converted coordinates (depending on detector settings).
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
id = 56 # int | Image ID to upload (optional)
body = None # bytearray | (optional)
try:
# Load TIFF image for internal FPGA generator
api_instance.config_internal_generator_image_tiff_put(id=id, body=body)
except Exception as e:
print("Exception when calling DefaultApi->config_internal_generator_image_tiff_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | int | Image ID to upload | [optional] |
| body | bytearray | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: image/tiff
- Accept: text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_mask_get
bytearray config_mask_get()
Get mask of the detector (binary)
Detector must be Initialized. Get full pixel mask of the detector. See NXmx standard for meaning of pixel values.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get mask of the detector (binary)
api_response = api_instance.config_mask_get()
print("The response of DefaultApi->config_mask_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_mask_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/octet-stream
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Binary array (4 byte; unsigned) | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_mask_tiff_get
bytearray config_mask_tiff_get()
Get mask of the detector (TIFF)
Should be in Idle state. Get full pixel mask of the detector See NXmx standard for meaning of pixel values
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get mask of the detector (TIFF)
api_response = api_instance.config_mask_tiff_get()
print("The response of DefaultApi->config_mask_tiff_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_mask_tiff_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: image/tiff
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Pixel mask in TIFF format (4 byte; unsigned) | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_roi_get
RoiDefinitions config_roi_get()
Get ROI definitions
Example
import jfjoch_client
from jfjoch_client.models.roi_definitions import RoiDefinitions
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get ROI definitions
api_response = api_instance.config_roi_get()
print("The response of DefaultApi->config_roi_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_roi_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_roi_put
config_roi_put(roi_definitions=roi_definitions)
Upload ROI definitions
Example
import jfjoch_client
from jfjoch_client.models.roi_definitions import RoiDefinitions
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
roi_definitions = jfjoch_client.RoiDefinitions() # RoiDefinitions | (optional)
try:
# Upload ROI definitions
api_instance.config_roi_put(roi_definitions=roi_definitions)
except Exception as e:
print("Exception when calling DefaultApi->config_roi_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| roi_definitions | RoiDefinitions | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_select_detector_get
DetectorList config_select_detector_get()
List available detectors
Configured detectors that can be selected by used
Example
import jfjoch_client
from jfjoch_client.models.detector_list import DetectorList
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# List available detectors
api_response = api_instance.config_select_detector_get()
print("The response of DefaultApi->config_select_detector_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_select_detector_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_select_detector_put
config_select_detector_put(detector_selection=detector_selection)
Select detector
Jungfraujoch allows to control multiple detectors and/or region-of-interests. The command allows to choose one detector from the list (ID has to be consistent with one provided by GET response). Changing detector will set detector to Inactive state and will require reinitialization.
Example
import jfjoch_client
from jfjoch_client.models.detector_selection import DetectorSelection
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
detector_selection = jfjoch_client.DetectorSelection() # DetectorSelection | (optional)
try:
# Select detector
api_instance.config_select_detector_put(detector_selection=detector_selection)
except Exception as e:
print("Exception when calling DefaultApi->config_select_detector_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| detector_selection | DetectorSelection | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_spot_finding_get
SpotFindingSettings config_spot_finding_get()
Get data processing configuration
Can be done anytime
Example
import jfjoch_client
from jfjoch_client.models.spot_finding_settings import SpotFindingSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get data processing configuration
api_response = api_instance.config_spot_finding_get()
print("The response of DefaultApi->config_spot_finding_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_spot_finding_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_spot_finding_put
config_spot_finding_put(spot_finding_settings=spot_finding_settings)
Configure spot finding
Can be done anytime, also while data collection is running
Example
import jfjoch_client
from jfjoch_client.models.spot_finding_settings import SpotFindingSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
spot_finding_settings = jfjoch_client.SpotFindingSettings() # SpotFindingSettings | (optional)
try:
# Configure spot finding
api_instance.config_spot_finding_put(spot_finding_settings=spot_finding_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_spot_finding_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| spot_finding_settings | SpotFindingSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_user_mask_get
bytearray config_user_mask_get()
Detector must be Initialized. Get user mask of the detector (binary)
Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Detector must be Initialized. Get user mask of the detector (binary)
api_response = api_instance.config_user_mask_get()
print("The response of DefaultApi->config_user_mask_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_user_mask_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/octet-stream
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | User mask in binary format (4 byte; unsigned) | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_user_mask_put
config_user_mask_put(body=body)
Upload user mask of the detector (binary)
Should be in Idle state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don't need to be assigned value. Mask is expected as binary array (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
body = None # bytearray | (optional)
try:
# Upload user mask of the detector (binary)
api_instance.config_user_mask_put(body=body)
except Exception as e:
print("Exception when calling DefaultApi->config_user_mask_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | bytearray | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/octet-stream
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | All good | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_user_mask_tiff_get
bytearray config_user_mask_tiff_get()
Detector must be Initialized. Get user mask of the detector (TIFF)
Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Detector must be Initialized. Get user mask of the detector (TIFF)
api_response = api_instance.config_user_mask_tiff_get()
print("The response of DefaultApi->config_user_mask_tiff_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_user_mask_tiff_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: image/tiff
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | User mask in TIFF format (4 byte; unsigned) | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_user_mask_tiff_put
config_user_mask_tiff_put(body=body)
Upload user mask of the detector
Should be in Idle state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don't need to be assigned value. Mask is expected as TIFF (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration. User mask is not automatically applied - i.e. pixels with user mask will have a valid pixel value in the images.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
body = None # bytearray | (optional)
try:
# Upload user mask of the detector
api_instance.config_user_mask_tiff_put(body=body)
except Exception as e:
print("Exception when calling DefaultApi->config_user_mask_tiff_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | bytearray | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: image/tiff
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | All good | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_zeromq_metadata_get
ZeromqMetadataSettings config_zeromq_metadata_get()
Get ZeroMQ metadata socket settings
Example
import jfjoch_client
from jfjoch_client.models.zeromq_metadata_settings import ZeromqMetadataSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get ZeroMQ metadata socket settings
api_response = api_instance.config_zeromq_metadata_get()
print("The response of DefaultApi->config_zeromq_metadata_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_zeromq_metadata_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_zeromq_metadata_put
config_zeromq_metadata_put(zeromq_metadata_settings=zeromq_metadata_settings)
Set ZeroMQ metadata settings
Jungfraujoch can generate metadata message stream on ZeroMQ PUB socket. This stream covers all images. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request.
Example
import jfjoch_client
from jfjoch_client.models.zeromq_metadata_settings import ZeromqMetadataSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
zeromq_metadata_settings = jfjoch_client.ZeromqMetadataSettings() # ZeromqMetadataSettings | (optional)
try:
# Set ZeroMQ metadata settings
api_instance.config_zeromq_metadata_put(zeromq_metadata_settings=zeromq_metadata_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_zeromq_metadata_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| zeromq_metadata_settings | ZeromqMetadataSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_zeromq_preview_get
ZeromqPreviewSettings config_zeromq_preview_get()
Get ZeroMQ preview settings
Example
import jfjoch_client
from jfjoch_client.models.zeromq_preview_settings import ZeromqPreviewSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get ZeroMQ preview settings
api_response = api_instance.config_zeromq_preview_get()
print("The response of DefaultApi->config_zeromq_preview_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->config_zeromq_preview_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
config_zeromq_preview_put
config_zeromq_preview_put(zeromq_preview_settings=zeromq_preview_settings)
Set ZeroMQ preview settings
Jungfraujoch can generate preview message stream on ZeroMQ SUB socket. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request. Options set with this PUT request have no effect on HTTP based preview.
Example
import jfjoch_client
from jfjoch_client.models.zeromq_preview_settings import ZeromqPreviewSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
zeromq_preview_settings = jfjoch_client.ZeromqPreviewSettings() # ZeromqPreviewSettings | (optional)
try:
# Set ZeroMQ preview settings
api_instance.config_zeromq_preview_put(zeromq_preview_settings=zeromq_preview_settings)
except Exception as e:
print("Exception when calling DefaultApi->config_zeromq_preview_put: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| zeromq_preview_settings | ZeromqPreviewSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
deactivate_post
deactivate_post()
Prepare detector to turn off
Should be in Idle or Error state. Command deactivates data acquisition and turns off detector high voltage and ASIC. Should be used always before turning off power from the detector.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Prepare detector to turn off
api_instance.deactivate_post()
except Exception as e:
print("Exception when calling DefaultApi->deactivate_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Detector ready to turn off | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
detector_status_get
DetectorStatus detector_status_get()
Get detector status
Status of the JUNGFRAU detector
Example
import jfjoch_client
from jfjoch_client.models.detector_status import DetectorStatus
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get detector status
api_response = api_instance.detector_status_get()
print("The response of DefaultApi->detector_status_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->detector_status_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 404 | Running in "simulator" mode - no detector present | - |
| 500 | Error encountered when trying to read status | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
fpga_status_get
List[FpgaStatusInner] fpga_status_get()
Get status of FPGA devices
Example
import jfjoch_client
from jfjoch_client.models.fpga_status_inner import FpgaStatusInner
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get status of FPGA devices
api_response = api_instance.fpga_status_get()
print("The response of DefaultApi->fpga_status_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->fpga_status_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_clear_post
image_buffer_clear_post()
Clear image buffer
Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Clear image buffer
api_instance.image_buffer_clear_post()
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_clear_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Done | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_image_cbor_get
bytearray image_buffer_image_cbor_get(id=id)
Get image message in CBOR format
Contains full image data and metadata. The image must come from the latest data collection.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
id = -1 # int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional) (default to -1)
try:
# Get image message in CBOR format
api_response = api_instance.image_buffer_image_cbor_get(id=id)
print("The response of DefaultApi->image_buffer_image_cbor_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_image_cbor_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer | [optional] [default to -1] |
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/cbor, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Return image message | - |
| 404 | Image not present in the buffer - either not yet measured or already replaced by a next image. | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_image_jpeg_get
bytearray image_buffer_image_jpeg_get(id=id, show_user_mask=show_user_mask, show_roi=show_roi, show_spots=show_spots, show_beam_center=show_beam_center, saturation=saturation, jpeg_quality=jpeg_quality, show_res_ring=show_res_ring, color=color, show_res_est=show_res_est)
Get preview image in JPEG format using custom settings
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
id = -1 # int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional) (default to -1)
show_user_mask = False # bool | Show user mask (optional) (default to False)
show_roi = False # bool | Show ROI areas on the image (optional) (default to False)
show_spots = True # bool | Show spot finding results on the image (optional) (default to True)
show_beam_center = True # bool | Show beam center on the image (optional) (default to True)
saturation = 3.4 # float | Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used (optional)
jpeg_quality = 100 # int | Quality of JPEG image (100 - highest; 0 - lowest) (optional) (default to 100)
show_res_ring = 0.1 # float | Show resolution ring, provided in Angstrom (optional) (default to 0.1)
color = indigo # str | Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat (optional) (default to indigo)
show_res_est = False # bool | Show resolution estimation as a ring (optional) (default to False)
try:
# Get preview image in JPEG format using custom settings
api_response = api_instance.image_buffer_image_jpeg_get(id=id, show_user_mask=show_user_mask, show_roi=show_roi, show_spots=show_spots, show_beam_center=show_beam_center, saturation=saturation, jpeg_quality=jpeg_quality, show_res_ring=show_res_ring, color=color, show_res_est=show_res_est)
print("The response of DefaultApi->image_buffer_image_jpeg_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_image_jpeg_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer | [optional] [default to -1] |
| show_user_mask | bool | Show user mask | [optional] [default to False] |
| show_roi | bool | Show ROI areas on the image | [optional] [default to False] |
| show_spots | bool | Show spot finding results on the image | [optional] [default to True] |
| show_beam_center | bool | Show beam center on the image | [optional] [default to True] |
| saturation | float | Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used | [optional] |
| jpeg_quality | int | Quality of JPEG image (100 - highest; 0 - lowest) | [optional] [default to 100] |
| show_res_ring | float | Show resolution ring, provided in Angstrom | [optional] [default to 0.1] |
| color | str | Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat | [optional] [default to indigo] |
| show_res_est | bool | Show resolution estimation as a ring | [optional] [default to False] |
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: image/jpeg, text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Preview image | - |
| 404 | Image not present in the buffer - either not yet measured or already replaced by a next image. | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_image_tiff_get
bytearray image_buffer_image_tiff_get(id=id)
Get preview image in TIFF format
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
id = -1 # int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional) (default to -1)
try:
# Get preview image in TIFF format
api_response = api_instance.image_buffer_image_tiff_get(id=id)
print("The response of DefaultApi->image_buffer_image_tiff_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_image_tiff_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | int | Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer | [optional] [default to -1] |
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: image/tiff
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Preview image | - |
| 404 | No preview image recorded so far | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_start_cbor_get
bytearray image_buffer_start_cbor_get()
Get Start message in CBOR format
Contains metadata for a dataset (e.g., experimental geometry)
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get Start message in CBOR format
api_response = api_instance.image_buffer_start_cbor_get()
print("The response of DefaultApi->image_buffer_start_cbor_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_start_cbor_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/cbor, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Return start message | - |
| 404 | No measurement so far | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
image_buffer_status_get
ImageBufferStatus image_buffer_status_get()
Get status of the image buffers
Can be run at any stage of Jungfraujoch operation, including during data collection. The status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots, then image might be replaced in the buffer between calling /images and /image.cbor.
Example
import jfjoch_client
from jfjoch_client.models.image_buffer_status import ImageBufferStatus
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get status of the image buffers
api_response = api_instance.image_buffer_status_get()
print("The response of DefaultApi->image_buffer_status_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->image_buffer_status_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Done | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
initialize_post
initialize_post()
Initialize detector and data acquisition
Should be used in two cases: - Detector is in Inactive state - Detector is in Error state X-ray shutter must be closed. This operation will reconfigure network interface of the detector. During operation of the detector it is recommended to use the POST /pedestal operation instead. If storage cells are used, the execution time might be few minutes. This is async function - one needs to use POST /wait_till_done to ensure operation is done.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Initialize detector and data acquisition
api_instance.initialize_post()
except Exception as e:
print("Exception when calling DefaultApi->initialize_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Initialization started | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
pedestal_post
pedestal_post()
Collect dark current for the detector
Updates calibration of the JUNGFRAU detector. Must be in Idle state. X-ray shutter must be closed. Recommended to run once per hour for long integration times (> 100 us). This is async function - one needs to use POST /wait_till_done to ensure operation is done.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Collect dark current for the detector
api_instance.pedestal_post()
except Exception as e:
print("Exception when calling DefaultApi->pedestal_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
preview_pedestal_tiff_get
bytearray preview_pedestal_tiff_get(gain_level, sc=sc)
Get pedestal in TIFF format
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
gain_level = 56 # int | Gain level (0, 1, 2)
sc = 56 # int | Storage cell number (optional)
try:
# Get pedestal in TIFF format
api_response = api_instance.preview_pedestal_tiff_get(gain_level, sc=sc)
print("The response of DefaultApi->preview_pedestal_tiff_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->preview_pedestal_tiff_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| gain_level | int | Gain level (0, 1, 2) | |
| sc | int | Storage cell number | [optional] |
Return type
bytearray
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: image/tiff
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Calibration image | - |
| 404 | No calibration recorded so far | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
preview_plot_get
Plots preview_plot_get(type, binning=binning, compression=compression, fill=fill, experimental_coord=experimental_coord, azint_unit=azint_unit)
Generate 1D plot from Jungfraujoch
Example
import jfjoch_client
from jfjoch_client.models.plots import Plots
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
type = 'type_example' # str | Type of requested plot
binning = 56 # int | Binning of frames for the plot (0 = default binning) (optional)
compression = False # bool | Enable DEFLATE compression of output data. (optional) (default to False)
fill = 3.4 # float | Fill value for elements that were missed during data collection (optional)
experimental_coord = False # bool | If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored (optional) (default to False)
azint_unit = Q_recipA # str | Unit used for azim int. (optional) (default to Q_recipA)
try:
# Generate 1D plot from Jungfraujoch
api_response = api_instance.preview_plot_get(type, binning=binning, compression=compression, fill=fill, experimental_coord=experimental_coord, azint_unit=azint_unit)
print("The response of DefaultApi->preview_plot_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->preview_plot_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| type | str | Type of requested plot | |
| binning | int | Binning of frames for the plot (0 = default binning) | [optional] |
| compression | bool | Enable DEFLATE compression of output data. | [optional] [default to False] |
| fill | float | Fill value for elements that were missed during data collection | [optional] |
| experimental_coord | bool | If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored | [optional] [default to False] |
| azint_unit | str | Unit used for azim int. | [optional] [default to Q_recipA] |
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json, text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK. | - |
| 400 | Input parsing or validation error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
result_scan_get
ScanResult result_scan_get()
Get full scan result
Example
import jfjoch_client
from jfjoch_client.models.scan_result import ScanResult
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get full scan result
api_response = api_instance.result_scan_get()
print("The response of DefaultApi->result_scan_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->result_scan_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK. | - |
| 404 | No grid scan recorded | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
start_post
start_post(dataset_settings=dataset_settings)
Start detector
Start data acquisition. Detector must be in Idle state. Doesn't run calibration procedure. When the function returns, detector is ready to accept soft/TTL triggers.
Example
import jfjoch_client
from jfjoch_client.models.dataset_settings import DatasetSettings
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
dataset_settings = jfjoch_client.DatasetSettings() # DatasetSettings | (optional)
try:
# Start detector
api_instance.start_post(dataset_settings=dataset_settings)
except Exception as e:
print("Exception when calling DefaultApi->start_post: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| dataset_settings | DatasetSettings | [optional] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: text/plain, application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 400 | Input parsing or validation error | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
statistics_calibration_get
List[CalibrationStatisticsInner] statistics_calibration_get()
Get calibration statistics
Statistics are provided for each module/storage cell separately
Example
import jfjoch_client
from jfjoch_client.models.calibration_statistics_inner import CalibrationStatisticsInner
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get calibration statistics
api_response = api_instance.statistics_calibration_get()
print("The response of DefaultApi->statistics_calibration_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->statistics_calibration_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
List[CalibrationStatisticsInner]
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
statistics_data_collection_get
MeasurementStatistics statistics_data_collection_get()
Get data collection statistics
Results of the last data collection
Example
import jfjoch_client
from jfjoch_client.models.measurement_statistics import MeasurementStatistics
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get data collection statistics
api_response = api_instance.statistics_data_collection_get()
print("The response of DefaultApi->statistics_data_collection_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->statistics_data_collection_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
| 404 | No data collection performed so far | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
statistics_get
JfjochStatistics statistics_get(compression=compression)
Get general statistics
Example
import jfjoch_client
from jfjoch_client.models.jfjoch_statistics import JfjochStatistics
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
compression = False # bool | Enable DEFLATE compression of output data. (optional) (default to False)
try:
# Get general statistics
api_response = api_instance.statistics_get(compression=compression)
print("The response of DefaultApi->statistics_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->statistics_get: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| compression | bool | Enable DEFLATE compression of output data. | [optional] [default to False] |
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
status_get
BrokerStatus status_get()
Get Jungfraujoch status
Status of the data acquisition
Example
import jfjoch_client
from jfjoch_client.models.broker_status import BrokerStatus
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get Jungfraujoch status
api_response = api_instance.status_get()
print("The response of DefaultApi->status_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->status_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Everything OK | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
trigger_post
trigger_post()
Send soft trigger to the detector
Generate soft trigger
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Send soft trigger to the detector
api_instance.trigger_post()
except Exception as e:
print("Exception when calling DefaultApi->trigger_post: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Trigger sent | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
version_get
str version_get()
Get Jungfraujoch version of jfjoch_broker
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Get Jungfraujoch version of jfjoch_broker
api_response = api_instance.version_get()
print("The response of DefaultApi->version_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->version_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
str
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: text/plain
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Release number of Jungfraujoch | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
wait_till_done_post
wait_till_done_post(timeout=timeout)
Wait for acquisition done
Block execution of external script till initialization, data collection or pedestal is finished. Running this command does not affect (cancel) running data collection, it is only to ensure synchronous execution of other software. To not block web server for a indefinite period of time, the procedure is provided with a timeout. Extending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection.
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
timeout = 60 # int | Timeout in seconds (0 == immediate response) (optional) (default to 60)
try:
# Wait for acquisition done
api_instance.wait_till_done_post(timeout=timeout)
except Exception as e:
print("Exception when calling DefaultApi->wait_till_done_post: %s\n" % e)
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| timeout | int | Timeout in seconds (0 == immediate response) | [optional] [default to 60] |
Return type
void (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Detector in `Idle` state, another data collection can start immediately | - |
| 400 | Timeout parameter out of bounds | - |
| 500 | Error within Jungfraujoch code - see output message. | - |
| 502 | Detector is inactive mode | - |
| 504 | Timeout reached, need to restart operation | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
xfel_event_code_get
List[int] xfel_event_code_get()
Return XFEL event codes for the current data acquisition
Return array of XFEL event codes
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Return XFEL event codes for the current data acquisition
api_response = api_instance.xfel_event_code_get()
print("The response of DefaultApi->xfel_event_code_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->xfel_event_code_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
List[int]
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Event codes collected | - |
| 404 | Not in XFEL mode or no acquisition recorded | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
xfel_pulse_id_get
List[int] xfel_pulse_id_get()
Return XFEL pulse IDs for the current data acquisition
Return array of XFEL pulse IDs - (-1) if image not recorded
Example
import jfjoch_client
from jfjoch_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost:5232
# See configuration.py for a list of all supported configuration parameters.
configuration = jfjoch_client.Configuration(
host = "http://localhost:5232"
)
# Enter a context with an instance of the API client
with jfjoch_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = jfjoch_client.DefaultApi(api_client)
try:
# Return XFEL pulse IDs for the current data acquisition
api_response = api_instance.xfel_pulse_id_get()
print("The response of DefaultApi->xfel_pulse_id_get:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->xfel_pulse_id_get: %s\n" % e)
Parameters
This endpoint does not need any parameter.
Return type
List[int]
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Pulse ID collected | - |
| 404 | Not in XFEL mode or no acquisition recorded | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]