TomoScan

https://tomoscan.readthedocs.io/en/latest/
Admin
TomoScan is a software application and library designed to control and manage tomography scans,...
Tokens:222,502
Snippets:1,617
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install tomoscan Python Library

Source: https://tomoscan.readthedocs.io/en/latest/usage.html

Install tomoscan as a Python library to enable the command-line interface. Navigate to the tomoscan directory and run the setup script.

```bash
cd ~/epics/synApps/support/tomoscan/
python setup.py install
```

--------------------------------

### Install Tomoscan Python Library

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Install the Tomoscan Python package as a library after developing beamline-specific classes.

```bash
$ cd ~/epics-ts/synApps/support/tomoscan/
$ conda activate tomoscan
$ pip install .
```

--------------------------------

### NetBooter Control - HTTP Example

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_2bm.html

Instantiate the NetBooter_Control class for HTTP communication. Use this to control power outlets and check their status.

```python
NetBooter = NetBooter_Control(mode='http',ip='192.168.1.101')
```

--------------------------------

### Initialize Scan Operations

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan.html

This method performs essential setup at the start of a scan. It configures EPICS PVs, sets exposure times, copies file parameters, and checks for existing files, raising an error if overwriting is not permitted.

```python
def begin_scan(self):
        """Performs the operations needed at the very start of a scan.

        This base class method does the following:

        - Sets the status string in the ``ScanStatus`` PV.

        - Stops the camera acquisition.

        - Calls ``set_exposure_time()``

        - Copies the ``FilePath`` and ``FileName`` PVs to the areaDetector file plugin.

        - Sets class variables with the important scan parameters

        - Checks whether the file that will be saved by the file plugin already exists.
          If it does, and if the OverwriteWarning PV is 'Yes' then it opens a dialog
          box asking the user if they want to overwrite the file.  If they answer 'No'
          then a FileOverwriteError exception is raised.

        It is expected that most derived classes will override this method.  In most cases they
        should first call this base class method, and then perform any beamline-specific operations.
        """

        self.scan_is_running = True
        self.epics_pvs['ScanStatus'].put('Beginning scan')
        # Stop the camera since it could be in free-run mode
        self.epics_pvs['CamAcquire'].put(0, wait=True)
        # Set the exposure time
        self.set_scan_exposure_time()
        # Set the file path, file name and file number
        self.epics_pvs['FPFilePath'].put(self.epics_pvs['FilePath'].value, wait=True)
        self.epics_pvs['FPFileName'].put(self.epics_pvs['FileName'].value, wait=True) 

        # Copy the current values of scan parameters into class variables
        self.exposure_time        = self.epics_pvs['ExposureTime'].value
        self.rotation_start       = self.epics_pvs['RotationStart'].value
        self.rotation_step        = self.epics_pvs['RotationStep'].value
        self.num_angles           = self.epics_pvs['NumAngles'].value
        self.rotation_stop        = self.rotation_start + (self.num_angles * self.rotation_step)
        self.rotation_resolution  = self.epics_pvs['RotationResolution'].value
        self.max_rotation_speed   = self.epics_pvs['RotationMaxSpeed'].value
        self.return_rotation      = self.epics_pvs['ReturnRotation'].get(as_string=True)
        self.num_dark_fields      = self.epics_pvs['NumDarkFields'].value
        self.dark_field_mode      = self.epics_pvs['DarkFieldMode'].get(as_string=True)
        self.num_flat_fields      = self.epics_pvs['NumFlatFields'].value
        self.flat_field_mode      = self.epics_pvs['FlatFieldMode'].get(as_string=True)
        self.file_path_rbv        = self.epics_pvs['FPFilePathRBV'].get(as_string=True)
        self.file_name_rbv        = self.epics_pvs['FPFileNameRBV'].get(as_string=True)
        self.file_number          = self.epics_pvs['FPFileNumber'].value
        self.file_template        = self.epics_pvs['FPFileTemplate'].get(as_string=True)
        self.total_images = self.num_angles
        if self.dark_field_mode != 'None':
            self.total_images += self.num_dark_fields
        if self.dark_field_mode == 'Both':
            self.total_images += self.num_dark_fields
        if self.flat_field_mode != 'None':
            self.total_images += self.num_flat_fields
        if self.flat_field_mode == 'Both':
            self.total_images += self.num_flat_fields

        if self.epics_pvs['OverwriteWarning'].get(as_string=True) == 'Yes':
            # Make sure there is not already a file by this name
            try:
                file_name = self.file_template % (self.file_path_rbv, self.file_name_rbv, self.file_number)
            except:
                try:
                    file_name = self.file_template % (self.file_path_rbv, self.file_name_rbv)
                except:
                    try:
                        file_name = self.file_template % (self.file_path_rbv)
                    except:
                        log.error("File name template: %s not supported", self.file_template)
                        raise TypeError
            if os.path.exists(file_name):
                self.epics_pvs['ScanStatus'].put('Waiting for overwrite confirmation')
                reply = pymsgbox.confirm('File ' + file_name + ' exists.  Overwrite?',
                                         'Overwrite file', ['Yes', 'No'])
                if reply == 'No':
                    raise FileOverwriteError
```

--------------------------------

### Start EPICS IOC and Medm Screen

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Navigate to the EPICS IOC directory and start the Tomoscan IOC and its associated Medm screen.

```bash
$ cd ~/epics-ts/synApps/support/tomoscan/iocBoot/iocTomoScan_13BM_PSO
$ start_IOC
$ start_medm
```

--------------------------------

### Begin Scan Initialization

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_32id_step.html

Initializes scan parameters, sets up data directory, and opens the front-end shutter. This function is called at the start of a scan.

```python
log.info('begin scan')
self.epics_pvs['SampleXSet'].put(1, wait=True)
self.epics_pvs['SampleYSet'].put(1, wait=True)
self.epics_pvs['SampleX'].put(0, wait=True)
self.epics_pvs['SampleY'].put(0, wait=True)
self.epics_pvs['SampleXSet'].put(0, wait=True)
self.epics_pvs['SampleYSet'].put(0, wait=True)


# Set data directory
file_path = self.epics_pvs['DetectorTopDir'].get(as_string=True) + self.epics_pvs['ExperimentYearMonth'].get(as_string=True) + os.path.sep + self.epics_pvs['UserLastName'].get(as_string=True) + os.path.sep
self.epics_pvs['FilePath'].put(file_path, wait=True)

# Call the base class method
super().begin_scan()
# Opens the front-end shutter
self.open_frontend_shutter()
```

--------------------------------

### NetBooter Control - Serial Example

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_2bm.html

Instantiate the NetBooter_Control class for serial communication. Use this to control power outlets and check their status.

```python
NetBooter = NetBooter_Control(mode='serial',serial_port='COM1')
```

--------------------------------

### TomoScan Substitutions File Example

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan.substitutions.html

This is an example of a tomoScan.substitutions file. It defines EPICS PVs and their associated values or relationships for the tomoScan EPICS application. These files are crucial for customizing the behavior of the tomoScan application for specific beamlines or experiments.

```EPICS
##
## tomoScan.substitutions
##

# Define PVs for camera and file plugin
# Example: Set the PV prefix for the camera
tomocamera:CAM:IMAGE:ARRAY_SIZE_X_PV

# Example: Set the PV prefix for the file plugin
tomofile:FILE:NAME_PV

# Define PVs for shutter control
# Example: Set the PV for opening the shutter
tomoscan:SHUTTER:OPEN_PV

# Define PVs for motors
# Example: Set the PV for the rotation stage
tomoscan:MOTOR:ROTATION:THETA_PV

# Example: Set the PV for the sample X translation stage
tomoscan:MOTOR:SAMPLE:X_PV

# Example: Set the PV for the sample Y translation stage
tomoscan:MOTOR:SAMPLE:Y_PV

# Define PVs for data collection control
# Example: Set the PV for starting data collection
tomoscan:SCAN:START_PV

# Example: Set the PV for stopping data collection
tomoscan:SCAN:STOP_PV

# Define PVs for dark field control
# Example: Set the PV for collecting dark fields
tomoscan:DARKFIELD:COLLECT_PV

# Define PVs for flat field control
# Example: Set the PV for collecting flat fields
tomoscan:FLATFIELD:COLLECT_PV

# Define PVs for frame type
# Example: Set the PV for the frame type
tomoscan:FRAME:TYPE_PV

# Define PVs for exposure time
# Example: Set the PV for the exposure time
tomoscan:EXPOSURE:TIME_PV

# Define PVs for file path and name control
# Example: Set the PV for the file path
tomoscan:FILE:PATH_PV

# Example: Set the PV for the file name
tomoscan:FILE:NAME_PV

# Define PVs for HDF5 file location
# Example: Set the PV for the HDF5 file group name
tomoscan:HDF5:GROUP_NAME_PV

# Define PVs for scan control via Channel Access
# Example: Set the PV for the scan status
tomoscan:SCAN:STATUS_PV

# Define PVs for scan status via Channel Access
# Example: Set the PV for the current scan progress
tomoscan:SCAN:PROGRESS_PV

```

--------------------------------

### Initiate TomoScan Scan

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_32id.html

Performs initial setup for a scan, including setting data directories, configuring the camera, opening shutters, and preparing the sample stage. Handles pause/resume functionality.

```python
pause = self.epics_pvs['Pause'].get(as_string=True)
        if pause == 'PAUSE':
            log.warning('scan is paused')
            self.epics_pvs['CamImageMode'].put('Continuous', wait=True)
            self.epics_pvs['CamTriggerMode'].put('Off', wait=True)
            self.epics_pvs['CamAcquire'].put('Acquire')
            self.epics_pvs['HDF5Location'].put('/exchange/Pause')
            self.epics_pvs['ScanStatus'].put('Pause')
            log.warning('open fast shutter')
            self.open_shutter()
            # Wait until Pause PV changes to "GO"
            while True:
                pause = self.epics_pvs['Pause'].get(as_string=True)
                if pause == 'GO':
                    break
                    log.warning('close fast shutter')
                    self.close_shutter()
                time.sleep(0.2)  

        log.info('begin scan')
        self.epics_pvs['SampleXSet'].put(1, wait=True)
        self.epics_pvs['SampleYSet'].put(1, wait=True)
        self.epics_pvs['SampleX'].put(0, wait=True)
        self.epics_pvs['SampleY'].put(0, wait=True)
        self.epics_pvs['SampleXSet'].put(0, wait=True)
        self.epics_pvs['SampleYSet'].put(0, wait=True)
        
        # if(abs(self.epics_pvs['SampleInX'].value-self.epics_pvs['SampleX'].value)>1e-4) or abs(self.epics_pvs['SampleInY'].value-self.epics_pvs['SampleY'].value)>1e-4:
        #     log.error('SampleInX/SampleInZ is not the same as current SampleTopX/SampleTopZ')            
        #     self.epics_pvs['ScanStatus'].put('Sample position error')
        #     self.epics_pvs['StartScan'].put(0)        
        #     return
        # Set data directory
        file_path = self.epics_pvs['DetectorTopDir'].get(as_string=True) + self.epics_pvs['ExperimentYearMonth'].get(as_string=True) + os.path.sep + self.epics_pvs['UserLastName'].get(as_string=True) + os.path.sep
        self.epics_pvs['FilePath'].put(file_path, wait=True)

        # Call the base class method
        super().begin_scan()
         
        # Opens the front-end shutter
        self.open_frontend_shutter()
```

--------------------------------

### Demonstration of TomoScan CLI Usage

Source: https://tomoscan.readthedocs.io/en/latest/_modules/index.html

This Python script demonstrates how to use the tomoscan-cli for basic scan operations. Ensure the tomoscan-cli is installed and accessible in your PATH.

```python
from tomoscan.tomoscan_cli import TomoScanCLI

cli = TomoScanCLI()
cli.run_scan(scan_type="fly", exposure_time=0.5, num_projections=100)
print("Scan complete.")
```

--------------------------------

### Running the Tomography Scan Demo

Source: https://tomoscan.readthedocs.io/en/latest/demo.html

Example of how to run the `scan_demo` Python function, specifying EPICS PVs, exposure time, and scan parameters. The output shows the completion of each dataset.

```python
>>> from scan_demo import scan_demo
>>> scan_demo('13BMDPG1:TS:', .01, '13BMD:m90', 5, 1, 5)
Completed dataset T:\tomo_user\2020\Run1\Test\Test_R_001.h5
Completed dataset T:\tomo_user\2020\Run1\Test\Test_R_002.h5
Completed dataset T:\tomo_user\2020\Run1\Test\Test_R_003.h5
Completed dataset T:\tomo_user\2020\Run1\Test\Test_R_004.h5
Completed dataset T:\tomo_user\2020\Run1\Test\Test_R_005.h5


```

--------------------------------

### Begin Scan Initialization

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_2bm_step.html

Initializes the scan process by setting the data directory, configuring TomoScan XML files, and opening the front-end shutter. This method is called at the start of each scan.

```python
    def begin_scan(self):
        """Performs the operations needed at the very start of a scan.

        This does the following:

        - Set data directory.

        - Set the TomoScan xml files

        - Calls the base class method.
        
        - Opens the front-end shutter.
        """
        log.info('begin scan')

        # Set data directory
        file_path = self.epics_pvs['DetectorTopDir'].get(as_string=True) + self.epics_pvs['ExperimentYearMonth'].get(as_string=True) + os.path.sep + self.epics_pvs['UserLastName'].get(as_string=True) + os.path.sep
        self.epics_pvs['FilePath'].put(file_path, wait=True)

        # Call the base class method
        super().begin_scan()
        # Opens the front-end shutter
        self.open_frontend_shutter()
```

--------------------------------

### Begin Scan Initialization (13BM MCS)

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_13bm_mcs.html

Initializes the scan by calling the base class method and collecting dummy frames. Waits for exposure time before starting file capture and camera acquisition.

```python
        # Call the base class method
        super().begin_scan()
        # Need to collect 3 dummy frames after changing camera to triggered mode
        self.collect_static_frames(3)
        # The MCS LNE output stays low after stopping MCS for up to the
        # exposure time = LNE output width.
        # Need to wait for the exposure time
        time.sleep(self.exposure_time)
        # Set the total number of frames to capture and start capture on file plugin
        # Comment out the following two lines to collect flat fields and dark fields
        # in separate files
        self.epics_pvs['FPNumCapture'].put(self.total_images, wait=True)
        self.epics_pvs['FPCapture'].put('Capture')
```

--------------------------------

### Sample Description Configuration

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan_6BM.template.html

Configures String Output (stringout) records for sample descriptions (up to three lines), each initialized to 'Unknown'.

```EPICS
record(stringout, "$(P)$(R)SampleDescription1")
{
   field(VAL,  "Unknown")
}

record(stringout, "$(P)$(R)SampleDescription2")
{
   field(VAL,  "Unknown")
}

record(stringout, "$(P)$(R)SampleDescription3")
{
   field(VAL,  "Unknown")
}
```

--------------------------------

### Running a Vertical Scan with tomoscan-cli

Source: https://tomoscan.readthedocs.io/en/latest/demo.html

Example of executing a vertical tomographic scan using `tomoscan-cli`, specifying start position, step size, and number of steps. The output includes scan timings and position updates.

```bash
$ tomoscan vertical --vertical-start 0 --vertical-step-size 0.1 --vertical-steps 2

2020-05-29 16:54:03,354 - vertical scan start
2020-05-29 16:54:03,356 - vertical positions (mm): [0.  0.1]
2020-05-29 16:54:03,358 - SampleInY stage start position: 0.000 mm
2020-05-29 16:54:03,362 - single scan start
2020-05-29 16:54:51,653 - single scan time: 0.805 minutes
2020-05-29 16:54:51,654 - SampleInY stage start position: 0.100 mm
2020-05-29 16:54:51,658 - single scan start
2020-05-29 16:55:47,607 - single scan time: 0.932 minutes
2020-05-29 16:55:47,607 - vertical scan time: 1.738 minutes
2020-05-29 16:55:47,608 - vertical scan end


```

--------------------------------

### Navigate to IOC Boot Directory

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Change the current directory to the IOC boot directory.

```bash
$ cd ~/epics-ts/synApps/support/tomoscan/iocBoot/
```

--------------------------------

### Begin Scan Operations

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_2bm.html

Performs initial setup for a scan, including setting data directory, configuring TomoScan XML files, opening the front-end shutter, setting PSO, creating theta array, and enabling data capture.

```python
TomoScan.begin_scan()
```

--------------------------------

### Install Tomoscan Python Package

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Install the Tomoscan package using pip after activating the conda environment and navigating to the source directory.

```bash
$ cd ~/epics-ts/synApps/support/tomoscan
$ pip install .
$ cd ~/epics-ts/synApps/support/tomoscan/iocBoot/iocTomoScan_13BM_PSO/
$ python -i start_tomoscan.py
```

--------------------------------

### Configure Sample Information PVs

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan_32ID.template.html

Sets up String Output (stringout) records for sample name and descriptions, initialized to 'Unknown'.

```EPICS
record(stringout, "$(P)$(R)SampleName")
{
   field(VAL,  "Unknown")
}

record(stringout, "$(P)$(R)SampleDescription1")
{
   field(VAL,  "Unknown")
}

record(stringout, "$(P)$(R)SampleDescription2")
{
   field(VAL,  "Unknown")
}

record(stringout, "$(P)$(R)SampleDescription3")
{
   field(VAL,  "Unknown")
}
```

--------------------------------

### Assemble synApps and Build

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Run the assemble_synApps.sh script to create the synApps directory structure, specifying the output directory and the path to EPICS base.

```bash
$ cd ~/epics-ts
$ ./assemble_synApps.sh --dir=synApps --base=/home/beams/FAST/epics-ts/epics-base

```

--------------------------------

### Configure PSO Start and End Positions

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan_PSO.template.html

EPICS ai records for setting the start and end positions of the PSO, with precision specified. Units are degrees.

```EPICS
record(ai, "$(P)$(R)PSOStartTaxi") 
{
    field(DESC, "Start position with taxi")
    field(EGU,  "degrees")
    field(PREC, "5")
}

record(ai, "$(P)$(R)PSOEndTaxi") 
{
    field(DESC, "End position with taxi")
    field(EGU,  "degrees")
    field(PREC, "5")
}
```

--------------------------------

### abort_scan

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_2bm_step.html

Aborts the current scan and performs additional cleanup actions specific to the 2BM setup.

```APIDOC
## abort_scan

### Description
Aborts the current scan. This method calls the superclass's abort_scan method and then adds specific cleanup actions for the 2BM setup, such as adding a theta value.

### Method
This is a method within a class, invoked as `instance.abort_scan()`.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Assuming 'instance' is an object of the class containing this method
instance.abort_scan()
```

### Response
This method does not return a value.

#### Success Response
None

#### Response Example
None
```

--------------------------------

### Create EPICS Build Directory

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Create and navigate to the directory where EPICS will be built. Ensure the parent partition is not larger than 2 TB.

```bash
$ mkdir ~/epics-ts
$ cd epics-ts

```

--------------------------------

### TomoScan13BM_MCS.begin_scan()

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_13bm_mcs.html

Initiates a new scan. This method prepares the system for data acquisition and starts the scanning process.

```APIDOC
## POST /TomoScan13BM_MCS/begin_scan

### Description
Initiates a new scan. This method prepares the system for data acquisition and starts the scanning process.

### Method
POST

### Endpoint
/TomoScan13BM_MCS/begin_scan

### Parameters
#### Query Parameters
- **scan_id** (string) - Required - A unique identifier for the scan.
- **scan_type** (string) - Required - The type of scan to be performed (e.g., 'projection', 'dark', 'flat').

### Request Example
None

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the scan has started.

#### Response Example
{
  "message": "Scan started successfully with ID: scan_123"
}
```

--------------------------------

### Build Tomoscan and Support Modules

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Navigate to the synApps support directory and run 'make release' followed by 'make -sj' to build the tomoscan module and other support modules.

```bash
$ cd ~/epics-ts/synApps/support/
$ make release
$ make -sj

```

--------------------------------

### Begin Data Stream

Source: https://tomoscan.readthedocs.io/en/latest/usage.html

Start the data streaming process. This is used in conjunction with the TomoScanStreamPSO class for continuous data acquisition.

```python
tomo_stream_pso.begin_stream()

```

--------------------------------

### Configure Energy Set PV

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan_32ID.template.html

Defines a 'busy' record for energy setting, with states for 'Done' and 'Start', and associated alarms.

```EPICS
record(busy,"$(P)$(R)EnergySet")
{
   field(ZNAM,"Done")
   field(ZSV, "NO_ALARM")
   field(ONAM,"Start")
   field(OSV, "MINOR")
   field(VAL, "0")
}
```

--------------------------------

### TomoScan32ID.begin_scan

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_32id.html

Performs the operations needed at the very start of a scan, including setting up data directories, PVs, shutters, and capture modes.

```APIDOC
## begin_scan

### Description
Performs the operations needed at the very start of a scan. This includes setting the data directory, TomoScan XML files, opening the front-end shutter, setting the PSO controller, creating the theta array, and turning on data capture.

### Method
Not specified (assumed to be part of a class method call)

### Endpoint
Not applicable (Python class method)

### Parameters
None

### Request Example
```python
tomo_scan_instance.begin_scan()
```

### Response
None specified.
```

--------------------------------

### Copy Beamline Configuration

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Copy the default IOC configuration to a new directory for beamline-specific customization.

```bash
$ mkdir ~/epics-ts/synApps/support/tomoscan/iocBoot/iocTomoScan_2BM
$ cd ~/epics-ts/synApps/support/tomoscan/iocBoot/
$ cp -r iocTomoScan_13BM/* iocTomoScan_2BM/
```

--------------------------------

### Sample Name Configuration

Source: https://tomoscan.readthedocs.io/en/latest/tomoScan_6BM.template.html

Configures a String Output (stringout) record for the sample name, initialized to 'Unknown'.

```EPICS
record(stringout, "$(P)$(R)SampleName")
{
   field(VAL,  "Unknown")
}
```

--------------------------------

### Initialize Stream Callbacks

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_pso.html

Sets up callbacks for various EPICS PVs related to stream capture and control. These callbacks trigger specific methods when PV values change.

```python
self.epics_pvs['StreamCapture'].add_callback(self.pv_callback_stream)
self.epics_pvs['StreamRetakeDark'].add_callback(self.pv_callback_stream)
self.epics_pvs['StreamRetakeFlat'].add_callback(self.pv_callback_stream)
self.epics_pvs['StreamPreCount'].add_callback(self.pv_callback_stream)
self.epics_pvs['StreamBinning'].add_callback(self.pv_callback_stream)
self.epics_pvs['StreamSync'].add_callback(self.pv_callback_stream)
self.epics_pvs['CBCurrentQtyRBV'].add_callback(self.pv_callback_stream)
self.epics_pvs['CBStatusMessage'].add_callback(self.pv_callback_stream)
self.epics_pvs['FPNumCapture'].add_callback(self.pv_callback_stream)
self.epics_pvs['FPNumCaptured'].add_callback(self.pv_callback_stream)
```

--------------------------------

### Build EPICS Support Modules

Source: https://tomoscan.readthedocs.io/en/latest/install.html

Navigate to the support directory and run make release and make -sj to build the EPICS support modules after customization.

```bash
$ cd ~/epics-ts/synApps/support
$ make release
$ make -sj
```

--------------------------------

### Close 2-BM-A Fast Shutter

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_2bm_step.html

Closes the fast shutter for the 2-BM-A setup. This action is conditional on the 'CloseFastShutter' EPICS PV being available.

```python
        # Close 2-BM-A fast shutter
        if not self.epics_pvs['CloseFastShutter'] is None:
            pv = self.epics_pvs['CloseFastShutter']
            value = self.epics_pvs['CloseFastShutterValue'].get(as_string=True)
            log.info('close fast shutter: %s, value: %s', pv, value)
            self.epics_pvs['CloseFastShutter'].put(value, wait=True)
```

--------------------------------

### Initialize Scan Operations

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_32id.html

Sets up the data directory, resets rotation if needed, calls base class initialization, and opens the front-end shutter.

```python
def begin_scan(self):
        """Performs the operations needed at the very start of a scan.

        This does the following:

        - Set data directory.

        - Calls the base class method.

        - Opens the front-end shutter.
        
        - Sets the PSO controller.

        - Creates theta array using list from PSO. 

        """
        log.info('begin scan')

        # Set data directory
        file_path = self.epics_pvs['DetectorTopDir'].get(as_string=True) + self.epics_pvs['ExperimentYearMonth'].get(as_string=True) + os.path.sep + self.epics_pvs['UserLastName'].get(as_string=True) + os.path.sep
        self.epics_pvs['FilePath'].put(file_path, wait=True)

        if self.return_rotation == 'Yes':
            # Reset rotation position by mod 360 , the actual return 
            # to start position is handled by super().end_scan()
            ang = self.epics_pvs['RotationRBV'].get()
            current_angle = np.sign(ang)*(np.abs(ang) % 360)
            log.info('reset position to %f',current_angle)
            self.epics_pvs['RotationSet'].put('Set', wait=True)
            self.epics_pvs['Rotation'].put(current_angle, wait=True)
            self.epics_pvs['RotationSet'].put('Use', wait=True)
            
        # Call the base class method
        super().begin_scan()
        # Opens the front-end shutter
        self.open_frontend_shutter()


         
        
```

--------------------------------

### TomoScanPSO Class: Begin Scan

Source: https://tomoscan.readthedocs.io/en/latest/about.html

Starts a scan using the Phase-Sensitive Optimization (PSO) method. This method initializes the PSO scan sequence.

```python
from tomoscan.tomoscan_pso import TomoScanPSO

tomo_pso = TomoScanPSO()
tomo_pso.begin_scan()
```

--------------------------------

### TomoScanStream7BM Methods

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_13bm_pso.html

Provides methods for controlling scan streams, including starting and ending scans, moving sample stages, and managing shutters.

```APIDOC
## TomoScanStream7BM Methods

### Description
Provides methods for controlling scan streams, including starting and ending scans, moving sample stages, and managing shutters.

### Methods
- `end_scan()`: Ends the current scan.
- `move_sample_in()`: Moves the sample into the scanning position.
- `move_sample_out()`: Moves the sample out of the scanning position.
- `open_shutter()`: Opens the shutter.
- `set_trigger_mode()`: Sets the trigger mode for the scan.
- `wait_pv()`: Waits for a specific Process Variable (PV) to reach a desired state.
```

--------------------------------

### Initialize EPICS PVs and Control Variables

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan.html

Initializes EPICS PVs and control variables based on configured prefixes. Waits for PVs to connect and sets up callbacks for various control signals.

```python
        if 'CbPlugin' in self.pv_prefixes:
            prefix = self.pv_prefixes['CbPlugin']
            self.control_pvs['CBPortNameRBV']      = PV(prefix + 'PortName_RBV')                    
            self.control_pvs['CBNDArrayPort']      = PV(prefix + 'NDArrayPort')        
            self.control_pvs['CBPreCount']         = PV(prefix + 'PreCount')
            self.control_pvs['CBPostCount']        = PV(prefix + 'PostCount')
            self.control_pvs['CBCapture']          = PV(prefix + 'Capture')            
            self.control_pvs['CBCaptureRBV']       = PV(prefix + 'Capture_RBV')
            self.control_pvs['CBTrigger']          = PV(prefix + 'Trigger')
            self.control_pvs['CBTriggerRBV']       = PV(prefix + 'Trigger_RBV')
            self.control_pvs['CBCurrentQtyRBV']    = PV(prefix + 'CurrentQty_RBV')            
            self.control_pvs['CBEnableCallbacks']  = PV(prefix + 'EnableCallbacks')
            self.control_pvs['CBStatusMessage']    = PV(prefix + 'StatusMessage')

        self.epics_pvs = {**self.config_pvs, **self.control_pvs}
        # Wait 1 second for all PVs to connect
        time.sleep(1)
        self.check_pvs_connected()

        # Configure callbacks on a few PVs
        for epics_pv in ('MoveSampleIn', 'MoveSampleOut', 'StartScan', 'AbortScan', 'ExposureTime',
                         'FilePath', 'FPFilePathExists', 'FPWriteStatus'):
            self.epics_pvs[epics_pv].add_callback(self.pv_callback)
        for epics_pv in ('MoveSampleIn', 'MoveSampleOut', 'StartScan', 'AbortScan'):
            self.epics_pvs[epics_pv].put(0)
            
        # Synchronize the FilePathExists PV
        self.copy_file_path_exists()

         # Set ^C interrupt to abort the scan
        signal.signal(signal.SIGINT, self.signal_handler)

        # Start the watchdog timer thread
        thread = threading.Thread(target=self.reset_watchdog, args=(), daemon=True)
        thread.start()
```

--------------------------------

### Update Captured Frame Count

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_pso.html

Updates the current number of captured frames by getting the value from the FPNumCaptured PV and putting it into the StreamNumCaptured PV.

```python
self.epics_pvs['StreamNumCaptured'].put(self.epics_pvs['FPNumCaptured'].get())
```

--------------------------------

### Update Circular Buffer Status Message

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_pso.html

Updates the status message for the circular buffer by getting the value from the CBStatusMessage PV and putting it into the StreamCBStatusMessage PV.

```python
self.epics_pvs['StreamCBStatusMessage'].put(self.epics_pvs['CBStatusMessage'].get())
```

--------------------------------

### NetBooter Power On

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_2bm.html

Turns a specific outlet on. Returns True on success, False on failure.

```python
NetBooter.power_on(2) #Return (True,'') for set Outlet 2 ON success
```

--------------------------------

### Initialize TomoScan2BMSTEP Class

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_2bm_step.html

Initializes the TomoScan2BMSTEP class, setting up EPICS PVs for detector attributes, file layout, and camera macros. It also configures the file writer for auto-increment and disables overwrite warnings.

```python
class TomoScan2BMSTEP(TomoScanSTEP):
    """Derived class used for tomography scanning with EPICS at APS beamline 2-BM

    Parameters
    ----------
    pv_files : list of str
        List of files containing EPICS pvNames to be used.
    macros : dict
        Dictionary of macro definitions to be substituted when
        reading the pv_files
    """

    def __init__(self, pv_files, macros):
        super().__init__(pv_files, macros)

        # set TomoScan xml files
        self.epics_pvs['CamNDAttributesFile'].put('TomoScanDetectorAttributes.xml')
        self.epics_pvs['FPXMLFileName'].put('TomoScanLayout.xml')
        macro = 'DET=' + self.pv_prefixes['Camera'] + ',' + 'TS=' + self.epics_pvs['Testing'].__dict__['pvname'].replace('Testing', '', 1)
        self.control_pvs['CamNDAttributesMacros'].put(macro)

        # Enable auto-increment on file writer
        self.epics_pvs['FPAutoIncrement'].put('Yes')

        # # Set standard file template on file writer
        # self.epics_pvs['FPFileTemplate'].put("%s%s_%3.3d.h5", wait=True)

        # Disable over writing warning
        self.epics_pvs['OverwriteWarning'].put('Yes')

        # Set AD plugins            
        self.epics_pvs['PVANDArrayPort'].put('OVER1')
        self.epics_pvs['PVAEnableCallbacks'].put('Enable')
        self.epics_pvs['ROIEnableCallbacks'].put('Disable')
        self.epics_pvs['CBEnableCallbacks'].put('Disable')
        self.epics_pvs['FPEnableCallbacks'].put('Enable')  


        log.setup_custom_logger("./tomoscan.log")
```

--------------------------------

### Update Circular Buffer Quantity

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_pso.html

Updates the current number of elements in the circular buffer by getting the value from the CBCurrentQtyRBV PV and putting it into the StreamPreCounted PV.

```python
self.epics_pvs['StreamPreCounted'].put(self.epics_pvs['CBCurrentQtyRBV'].get())
```

--------------------------------

### Load Configuration from File

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan.html

Loads a configuration from a JSON file and applies it to the EPICS PVs. Assumes the file exists and is in the correct format.

```python
    def load_configuration(self, file_name):
        """Loads a configuration from a file into the EPICS PVs.

        Parameters
        ----------
        file_name : str
            The name of the file to save to.
        """

        in_file = open(file_name, 'r')
        config = json.load(in_file)
        in_file.close()
        for key in config:
            self.config_pvs[key].put(config[key])
```

--------------------------------

### Check PV Connection Status

Source: https://tomoscan.readthedocs.io/en/latest/usage.html

Verify that all necessary EPICS Process Variables (PVs) are connected before starting a scan. This method helps in debugging connection issues.

```python
tomo.check_pvs_connected()
```

--------------------------------

### Terminate Scan Operations

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan.html

This method handles cleanup at the end of a scan. It updates the scan status and optionally returns the rotation motor to its starting position if configured.

```python
def end_scan(self):
        """Performs the operations needed at the very end of a scan.

        This base class method does the following:

        - Sets the status string in the ``ScanStatus`` PV.

        - If the ``ReturnRotation`` PV is Yes then it moves the rotation motor back to the
          position defined by the ``RotationStart`` PV.  It does not wait for the move to complete.

        """
```

--------------------------------

### Begin Scan Initialization

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_2bm.html

Initializes the scan process by setting the data directory, configuring TomoScan XML files, opening the front-end shutter, setting the PSO controller, creating the theta array, and enabling data capture. This method should be called at the start of each scan.

```python
log.info('begin scan')

# Set data directory
file_path = self.epics_pvs['DetectorTopDir'].get(as_string=True) + self.epics_pvs['ExperimentYearMonth'].get(as_string=True) + os.path.sep + self.epics_pvs['UserLastName'].get(as_string=True) + os.path.sep
self.epics_pvs['FilePath'].put(file_path, wait=True)

# Call the base class method
super().begin_scan()
# Opens the front-end shutter
self.open_frontend_shutter()
```

--------------------------------

### TomoScanStreamPSO Class - Begin Stream Method

Source: https://tomoscan.readthedocs.io/en/latest/index.html

Starts the data streaming process for a PSO scan using the `begin_stream` method. This prepares the system for continuous data flow.

```python
stream_pso_scan.begin_stream()
```

--------------------------------

### TomoScan Class - Begin Scan Method

Source: https://tomoscan.readthedocs.io/en/latest/index.html

Illustrates the initiation of a scan using the `begin_scan` method from the `TomoScan` class. This method prepares the system for data collection.

```python
scan.begin_scan()
```

--------------------------------

### Begin Scan in TomoScan13BM_MCS

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_13bm_mcs.html

Performs operations at the start of a scan, including collecting dummy frames and waiting for the MCS output. This is necessary for switching camera trigger modes.

```python
begin_scan()
```

--------------------------------

### TomoScan2BM Initialization

Source: https://tomoscan.readthedocs.io/en/latest/api/tomoscan_2bm.html

Initialize the TomoScan2BM class with a list of PV files and a dictionary of macro definitions.

```python
TomoScan = TomoScan2BM(pv_files=['path/to/pvconfig.txt'], macros={'sample': 'Sample1'})
```

--------------------------------

### TomoScanStreamPSO Class: Begin Scan and Stream

Source: https://tomoscan.readthedocs.io/en/latest/about.html

Initializes a scan and begins the data streaming process for PSO. `begin_scan` starts the sequence, and `begin_stream` activates data transfer.

```python
from tomoscan.tomoscan_stream_pso import TomoScanStreamPSO

tomo_stream_pso = TomoScanStreamPSO()
tomo_stream_pso.begin_scan()
tomo_stream_pso.begin_stream()
```

--------------------------------

### Show tomoscan CLI Help

Source: https://tomoscan.readthedocs.io/en/latest/usage.html

Display general help for the tomoscan command-line interface, listing available commands and global options.

```bash
tomoscan -h
```

--------------------------------

### begin_scan

Source: https://tomoscan.readthedocs.io/en/latest/_modules/tomoscan/tomoscan_stream_32id.html

Performs the operations needed at the very start of a scan. This includes setting the data directory, opening the front-end shutter, setting the PSO controller, and creating the theta array.

```APIDOC
## begin_scan()

### Description
Performs the operations needed at the very start of a scan.

This method sets the data directory, calls the base class method, opens the front-end shutter, sets the PSO controller, and creates the theta array using a list from the PSO.

### Method
```
python
def begin_scan(self)
```

### Parameters
This method does not take any explicit parameters.

### Returns
None
```
Tokens:
Raw