Skip to content

Docs CSC now features an automatic Finnish translation. Click here for more information.

Warning!

Puhti and Mahti are being decommissioned in stages, and their storage areas will become fully unavailable from 15 October 2026. Clean up unnecessary files and move any data you need to keep by 31 August 2026. See the Roihu data migration guide for instructions on transferring your data to Roihu.

Puhti scratch is very full: keep only active data there and move or delete everything else. No new Puhti scratch quota will be granted.

Q20 Service in MyCSC

There are currently some issues with the Q20 service for projects that have Q20 allocations. If you cannot find the Aalto-Q20 service or are otherwise experiencing issues please contact the CSC Service Desk at servicedesk@csc.fi.

Pulse level access

Pulse level access gives the user a lower level of control over their quantum jobs. Instead of only defining jobs via circuits using gates with pulse level access the user has control over the control pulses of the quantum computer. Pulse level access to both VTT Q50 and Aalto Q20 is enabled through the IQM Pulla python package. IQM Pulla is already installed in the module for each quantum computer. Below you'll find an overview on running pulse level jobs from LUMI on the available quantum computers. For more advanced documentation on using IQM Pulla see IQM's documentation

Load the environment

module use /appl/local/quantum/modulefiles    
module load fiqci-vtt-qiskit

Import packages

import os

from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from iqm.iqm_client.util import print_env_vars
from iqm.qiskit_iqm import IQMProvider
from iqm.pulla.pulla import Pulla
from iqm.pulla.utils_qiskit import qiskit_to_pulla, sweep_job_to_qiskit

Define Pulla client and backend

Q20_CORTEX_URL = os.getenv('Q20_CORTEX_URL')

p = Pulla(Q20_CORTEX_URL, quantum_computer="radiance20")

q20_provider = IQMProvider(Q20_CORTEX_URL, quantum_computer="radiance20")
backend = provider.get_backend()
Q50_CORTEX_URL = os.getenv('Q50_CORTEX_URL')

p = Pulla(Q50_CORTEX_URL, quantum_computer="q50")

q50_provider = IQMProvider(Q50_CORTEX_URL, quantum_computer="q50")
backend = provider.get_backend()

Define a quantum circuit

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.measure_all()

Transpile to backend

qc_transpiled = transpile(qc, backend=backend, optimization_level=3)

Convert to Pulla

circuits, compiler = qiskit_to_pulla(p, backend, qc_transpiled)

shots = 100
settings = compiler.get_settings(circuits=circuits)
settings.set_shots(shots)

job_definition, context = compiler.compile(circuits, settings=settings)

Visualise pulse scheduling

Optionally it is possible to visualise the pulse scheduling before submitting the job.

from iqm.pulse.playlist.visualisation.base import inspect_playlist
from IPython.core.display import HTML

HTML(inspect_playlist(job_definition.sweep_definition.playlist, [0]))

Submit through Pulla

job = p.submit_playlist(job_definition, context=context)
job.wait_for_completion()
qiskit_result = sweep_job_to_qiskit(job, shots=shots)

print(f"Raw results:\n{job.result().circuit_measurement_results}\n")
print(f"Qiskit result counts:\n{qiskit_result.get_counts()}\n")

Running through LUMI

For instructions on running the job on LUMI you can use the example batch script below.

#!/bin/bash

#SBATCH --job-name=pulsejob   # Job name
#SBATCH --account=project_<id>  # Project for billing (slurm_job_account)
#SBATCH --partition=small   # Partition (queue) name
#SBATCH --ntasks=1              # One task (process)
#SBATCH --mem-per-cpu=2G       # memory allocation
#SBATCH --cpus-per-task=1     # Number of cores (threads)
#SBATCH --time=00:05:00         # Run time (hh:mm:ss)

module use /appl/local/quantum/modulefiles
module load fiqci-vtt-qiskit

export DEVICES=("radiance20")
source $RUN_SETUP
python your_python_script.py
#!/bin/bash

#SBATCH --job-name=pulsejob   # Job name
#SBATCH --account=project_<id>  # Project for billing (slurm_job_account)
#SBATCH --partition=small   # Partition (queue) name
#SBATCH --ntasks=1              # One task (process)
#SBATCH --mem-per-cpu=2G       # memory allocation
#SBATCH --cpus-per-task=1     # Number of cores (threads)
#SBATCH --time=00:05:00         # Run time (hh:mm:ss)

module use /appl/local/quantum/modulefiles
module load fiqci-vtt-qiskit

export DEVICES=("q50")
source $RUN_SETUP
python your_python_script.py

Alternatively you can submit interactive jobs using srun

module use /appl/local/quantum/modulefiles
module --ignore_cache load "fiqci-vtt-qiskit/"
export DEVICES=("radiance20")
srun --account project_xxx -t 00:15:00 -c 1 -n 1 --partition q_fiqci bash -c "source $RUN_SETUP && python your_python_script.py"
module use /appl/local/quantum/modulefiles
module --ignore_cache load "fiqci-vtt-qiskit/"
export DEVICES=("q50")
srun --account project_xxx -t 00:15:00 -c 1 -n 1 --partition q_fiqci bash -c "source $RUN_SETUP && python your_python_script.py"