DEV Community: Desmond Gilmour

Your Antibody Barely Dissociates. How Much Can You Trust the Off-Rate?

Desmond Gilmour — Mon, 02 Nov 2026 15:35:41 +0000

An antibody binds its target. The dissociation phase starts. The curve barely moves.

That can be encouraging. It also raises a question I keep returning to as I learn more about surface plasmon resonance, or SPR:

Did we observe enough dissociation to rank this antibody confidently?

A small off-rate needs a convincing curve

SPR follows binding and dissociation in real time. The off-rate, written as koff, describes how quickly a bound complex separates.

A smaller value means slower dissociation under the conditions tested. The Assay Guidance Manual explains how these rates relate to binding affinity.

Consider a hypothetical interaction with koff = 0.00001 s⁻¹. Under a simple 1:1 model, the calculated loss of binding-specific signal after ten minutes is only about 0.6%.

That is a small change to build a candidate ranking around.

The question becomes whether the assay can distinguish that movement from background drift, surface instability and measurement variability.

Check what is keeping the signal on the surface

Before trusting a very slow off-rate, I would look at three things:

The background. Reference and buffer-blank measurements help establish whether the small signal change belongs to the interaction. The captured material also needs to remain stable. Research on SPR surface design shows how loss of captured protein can complicate slow-dissociation measurements.
The binding arrangement. A molecule can detach and bind again nearby. An antibody can also engage through both binding arms, creating avidity: the combined strength of multiple contacts. Rebinding and bivalent binding can both slow apparent dissociation.
The consistency. Repeat the measurement, inspect the gaps between the data and fitted curve, and check whether a longer dissociation window supports the same result. Close candidates need differences large enough to stand above the assay’s variability.

A smooth fit becomes much more useful when the assay supports its assumptions.

Temperature can reveal more of the interaction

This is one reason I find the temperature flexibility of Alto Digital SPR useful.

In Nicoya’s temperature-dependence study, the tested antibody–antigen pair dissociated approximately 5.6 times faster at 37°C than at 25°C. Its measured affinity also weakened. These are manufacturer application data.

That gives a scientist another useful measurement condition, especially when 37°C fits the biological question.

The temperature belongs with the result. A value measured at 37°C describes that condition; it cannot replace an unresolved off-rate at 25°C. Candidate rankings should be compared under matched conditions.

Equilibrium fitting gives you another route to affinity

Alto also supports steady-state affinity fitting.

This approach uses the binding response across concentrations after equilibrium has been reached to estimate KD, the equilibrium dissociation constant. It provides another route to affinity without requiring separate estimates of both rate constants.

The requirement is real equilibrium across an informative concentration range. Tight-binding interactions can take a long time to get there, particularly at low concentrations, as Jarmoskaite and colleagues demonstrate.

Equilibrium fitting can answer how tightly the partners bind. It does not, by itself, establish how quickly they separate.

Make confidence practical

Nicoya lists 16 parallel sensors, automated on-cartridge serial dilutions and sample volumes starting at 2 µL for Alto.

What interests me is the room that creates for assay development: allocating material to replicates, checking surface loading and comparing candidates under matched conditions, with less manual dilution work.

Before advancing a candidate on a tiny fitted off-rate, ask whether its ranking survives those checks. If two slow binders remain unresolved, report that clearly and choose the next experiment that can separate them.

The goal is a candidate ranking you can defend with the measured data.

Desmond Gilmour

Email: dgilmour@nicoyalife.com

Phone: +1 519-546-9876

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

What Happens Before Your First HDX Time Point?

Desmond Gilmour — Mon, 02 Nov 2026 03:51:50 +0000

The first HDX time point shapes what you can learn about a protein.

Once a region’s exchange has reached its plateau, collecting more late time points cannot recover the missing early kinetics.

As I continue learning about protein dynamics, this is the question I keep coming back to: does the measurement window match the biology?

Fast exchange deserves an earlier measurement

Hydrogen–deuterium exchange mass spectrometry, or HDX-MS, measures how certain hydrogens in a protein’s backbone exchange with deuterium, a heavier form of hydrogen.

Researchers measure the resulting mass changes after different labeling periods. In a typical peptide-level workflow, digestion helps locate those changes along the protein’s sequence.

Under matched experimental conditions, the exchange curves provide information about structural protection and flexibility. Weakly protected regions can exchange on the millisecond timescale, putting useful information ahead of measurements that begin several seconds later.

Source: Kish et al., Analytical Chemistry, 2023

Imagine two samples whose exchange curves differ early on but reach the same plateau. Start measuring after that plateau, and the difference is absent from the collected data.

The experiment needs earlier measurements to resolve that early behavior.

Automation does not recover missing early data

Automation makes complex experiments easier to run consistently. But an automated workflow can still collect its first measurement after the most informative part of a fast exchange curve has passed.

For these regions, the important upgrade is access to an earlier observation window.

A 2023 study by Kish and colleagues demonstrated this with ms2min, an automated research system developed with Applied Photophysics/Nicoya which eventually become the FastHDX. The system measured labeling times from 50 milliseconds to 300 seconds.

Measurements in the 50–150 millisecond range helped characterize weakly protected regions of glycogen phosphorylase, a large enzyme. The study showed how early sampling provides access to exchange behavior that is difficult to resolve at longer times.

That is a concrete scientific reason to look beyond how smoothly a system runs and examine when it starts measuring.

Bring the early time points into the workflow

This is what draws my attention to FastHDX.

Nicoya’s published specifications cover labeling times from 50 milliseconds to 24 hours. Researchers can investigate early exchange and follow more protected regions over longer periods using the same platform.

Its automated quench-flow design controls labeling and quenching before transferring samples into compatible liquid chromatography–mass spectrometry workflows. That puts the early measurements into a controlled, automated process.

The specified sample requirement is 8 µL per time point. For teams working with limited protein, that is a useful number for planning replicates, additional conditions, and a time course that covers the question properly.

Together, those capabilities make millisecond HDX a practical part of experimental planning.

Choose the window that answers the question

When evaluating an HDX workflow, I would start with the regions I need to understand and the exchange behavior I need to resolve.

For rapidly exchanging regions, that means looking before the first second.

A well-run experiment starts measuring while the information you need is still distinguishable. FastHDX brings that earlier window into an automated workflow, giving researchers more room to investigate the protein behavior that matters to their project.

Desmond Gilmour

Email: dgilmour@nicoyalife.com

Phone: +1 519-546-9876

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

Could a Thermal Fingerprint Help Confirm Your Biologic’s Identity?

Desmond Gilmour — Mon, 02 Nov 2026 03:47:47 +0000

When a lab handles several biologic products, a simple question becomes important:

Does this sample match the material we expect?

As I learn more about protein characterization, I’m seeing how much information sits inside a thermal unfolding curve. Alongside stability measurements, those profiles can help distinguish materials across a biologics portfolio.

That makes SUPR-DSF an interesting platform for this work: detailed fluorescence measurements, a 384-well format, and small sample volumes.

Thermal fingerprints have already shown their value

A recent peer-reviewed study in Pharmaceutical Research evaluated thermal-profile identity testing across 15 biopharmaceutical products.

Its best-performing comparison method achieved 100% specificity and 99.7% sensitivity, excluding comparisons between the tested originator and its biosimilar, which the approach could not distinguish.

The useful finding is that thermal unfolding profiles successfully separated a range of biologic products when compared against reference profiles using an objective scoring method and that is exactly what the SUPR-DSF can do.

Capture the information behind the melting temperature

Intrinsic differential scanning fluorimetry, or DSF, follows a protein’s natural fluorescence as it is heated. Changes around fluorescent amino acids alter the measured signal as the protein unfolds.

SUPR-DSF's software supports wavelength ratios and analysis of the spectrum’s average position.

For method development, that flexibility matters. Teams can investigate which readout reveals useful differences between their samples and examine the unfolding profiles alongside melting temperatures.

That is what interests me about full-spectrum acquisition: the experiment provides several ways to interrogate the fluorescence data.

Build a meaningful comparison into the plate

Imagine a team evaluating several antibodies. They need reference materials, repeat measurements, and the other products that could realistically be confused.

The 384-well format of SUPR-DSF provides room to organize those comparisons within a single plate.

That capacity supports a stronger study design: multiple products alongside controls and replicates, with space to investigate relevant formulation conditions.

For analytical-development scientists and teams working across several customer programs, the practical benefit is straightforward: more of the comparisons needed to assess a method can fit into the experiment.

Keep sample requirements manageable

A broad comparison becomes easier to plan when each measurement uses a small amount of material.

Applied Photophysics describes SUPR-DSF measurements using standard black 384-well PCR plates and seals, with volumes as low as 10 µL. Samples are prepared and measured in the same plate.

That combines low sample-volume requirements with familiar consumables and avoids a separate transfer into individual measurement vessels.

When materials are valuable or limited, those workflow details matter. They help make room in the sample budget for the repeat measurements and comparisons that build confidence in a result.

Start with the products you need to tell apart

The next useful question is specific:

Which products or sample mix-ups would your method need to distinguish?

Use that answer to choose reference materials, assemble a representative sample panel, and define how matching profiles will be assessed.

For me, the appeal of SUPR-DSF is clear: it brings together the fluorescence data, plate capacity, and sample efficiency needed to explore thermal fingerprinting in a practical workflow.

Desmond Gilmour

Email: dgilmour@nicoyalife.com

Phone: +1 519-546-9876

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

Your RNA CD Spectrum Changed. What Does That Mean for Your Formulation?

Desmond Gilmour — Mon, 02 Nov 2026 03:21:23 +0000

Imagine changing the buffer around an RNA sample. Its circular dichroism spectrum shifts.

What changed, and does it matter for the formulation?

As I continue learning about nucleic-acid characterization, this is the question that keeps my attention. A changed curve can be a useful starting point. The next step is understanding what that change means for the sample and the decision in front of you.

A spectrum starts the conversation

Circular dichroism, or CD, measures the difference in absorption of left- and right-circularly polarized light. In DNA and RNA, it is sensitive to how the bases are arranged and stacked. That makes CD useful for examining structural changes in solution. Synchrotron SOLEIL explains the underlying science here.

Several structural contributions can overlap in one spectrum. Interpreting a change therefore takes more than spotting a shifted peak.

Following structure and stability together

Consider a hypothetical buffer comparison. One condition gives a higher melting temperature, but it also changes the starting CD spectrum. I would want to understand whether it preserves the structure of interest before choosing it on thermal stability alone.

This is where Chirascan V100 becomes relevant. It collects CD and absorbance together. I see that second signal as useful context when assessing strongly absorbing samples or buffers and deciding which parts of a spectrum are suitable for interpretation.

With the appropriate temperature-control setup, Chirascan can also follow spectra during heating, connecting structural changes with thermal transitions. Comparing measurements before heating and after cooling can show whether the CD pattern returns. Biological activity would still need its own assessment.

The practical appeal for a development team is being able to investigate the starting structure and its response to stress within the same platform.

Chirascan in published nucleic acid research

In a 2017 study by Vlasenok and colleagues, researchers used Chirascan for CD and absorbance measurements of imperfect G-quadruplex DNA: four-stranded structures with interruptions or defects. Their work included thermal measurements and studies involving small-molecule ligands.

That is a concrete example of using the platform to investigate structure, stability, and interactions. An RNA formulation would need its own feasibility work, but the study illustrates the kinds of connected questions Chirascan can help researchers explore.

Where NA-CDQuant fits

A 2026 PNAS paper introduces NA-CDQuant, a research tool that estimates nucleic-acid structural contributions using 18 reference families derived mainly from synchrotron CD data. It points toward more quantitative interpretation of overlapping spectra.

NA-CDQuant is separate research software. Its performance with Chirascan spectra and real formulations still needs validation. The authors also found reduced accuracy when restricting spectra to conventional CD wavelength ranges. For me, that reinforces the value of establishing usable spectral coverage before relying on a fitted result.

Start with the decision you need to make

For a formulation comparison, I would start by establishing repeatable spectra, measuring the matching buffer, and accounting for concentration and cuvette path length. Those checks help separate a meaningful sample difference from a measurement problem. Published guidance on nucleic-acid CD explains why these details matter.

For teams working with RNA, antisense, or other oligonucleotides, that is the opportunity I see: build a structural comparison that helps decide which conditions deserve further investigation, supported by complementary measurements.

If your formulation has changed and you want to understand the structural consequences, discuss whether your samples and spectral range are suitable for a Chirascan feasibility study.

If you have questions about CD, protein stability and structure or how these systems could fit into your workflow, I’m happy to chat.

Desmond Gilmour

Email: dgilmour@nicoyalife.com

Phone: +1 519-546-9876

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

How I’m Using ChatGPT as My Personal Trainer

Desmond Gilmour — Mon, 02 Nov 2026 00:30:52 +0000

I’m using ChatGPT as my personal trainer, with Garmin, Tredict, and Hevy helping it work from my actual training data.

I’m working toward a half-Ironman while continuing to build muscle and strength. It sounds like an impossible task but I'm hoping AI can help get me there. That means coordinating swimming, cycling, running, and lifting around real life.

My goal is for AI to run the full training process: build my workouts, set progression targets, review what I complete, and adjust the next week.

A ChatGPT Project holds the context

I use a dedicated ChatGPT Project for my training. Projects keep related chats, uploaded files, and instructions together, so I have somewhere to build an ongoing picture of my goals and progress.

That includes my schedule, exercise preferences, training history, and feedback. I can also upload other records, such as bloodwork or guidance from a healthcare professional. It seems scary at first giving AI access to all this data but it's been very helpful thus far and I think worth sharing.

Garmin, Tredict, and Hevy supply the training detail

Each tool contributes something different:

Tool	What it contributes
Garmin	Recorded activities and available heart-rate, sleep, and recovery measurements.
Tredict	Supported Garmin data and endurance-training tools for AI review and planning communicating with ChatGPT.
Hevy	My exercises, sets, reps, weights, and workout notes and communicates with ChatGPT.

The whole idea is to have the data be accessible by my ChatGPT project while also have ChatGPT be able to write to these apps. At this point the ChatGPT project still needs to be prompted a few times to get exactly what I want but it's been great in developing a plan.

I want a trainer that adapts

At the end of the week, I ask ChatGPT to review what I actually completed and build the next week around it.

My feedback matters here. Recently, I skipped a Saturday session because it didn’t feel worth the gym trip based on the accessory exercises prescribed. I moved my Sunday leg day there in place of it, then ran and biked the following day.

The next weekly plan will take into account for that change I made and spit out an entirely guided plan where I don't have a day of accessory work.

Why I think more people should explore this

Collecting useful health and training data gives me a record I can return to.

Am I getting stronger? Am I completing the endurance work? Is the schedule realistic? What should change?

AI can help organize those questions and propose a plan, but I want it to explain which records support each adjustment and flag missing information. I’m selective about sharing sensitive health records and checking app permissions.

What excites me is having my goals, workout history, and feedback available in one ongoing training project.

I hope this post can help get you on track! It's much cheaper to have an AI trainer and a few apps than to go to a personal training session once a week.

AI-Designed Binders: From Predictions to Automated SPR Validation

Desmond Gilmour — Mon, 26 Oct 2026 18:00:18 +0000

If an AI model gives your team hundreds of promising protein designs, how quickly can you work out which ones deserve more attention?

As I continue learning about protein design and biophysical analysis, I keep coming back to this question. Generating candidates is exciting. Building a practical way to evaluate them is what makes those predictions useful.

The prediction is where testing begins

In its October 20, 2026 report, Anthropic described a campaign that generated 318,484 designs, selected 211 for experimental testing, and identified 17 that met its binder criteria.

Adaptyv Bio and Twist Bioscience used surface plasmon resonance, or SPR, to investigate binding in different protein-production formats. The criteria included reproducibility, an affinity threshold and no detected binding to an unrelated control. One target was assessed by only one laboratory, so the evidence was not identical across all reported hits.

The work explored possible antivenom research, but binding results did not establish neutralization or efficacy in living animals. It remains a company technical report and data release.

The broader lesson for me is simple: a prediction becomes more useful when we can connect it to experimental evidence.

What SPR adds to the decision

SPR follows binding near a sensor surface in real time. Its curves, called sensorgrams, help show how quickly an interaction forms and how quickly it comes apart.

That adds context to affinity, often reported as KD: a lower value indicates tighter binding under the measured conditions.

Before trusting a ranking, I would ask:

Does the binding result repeat?
Do the controls support the claimed specificity?
Do the curves support the fitted model and reported values?

Those questions matter because the measurement can also be influenced by the assay itself. For example, Schuck and Minton showed how molecular transport near a sensor can distort apparent binding rates.

As candidate numbers grow, the practical challenge becomes collecting this evidence without creating an overwhelming preparation workload.

Why Alto’s cartridge design matters

This is where I find the design of Alto digital SPR particularly relevant.

Nicoya specifies 16 channels, sample inputs as low as 2 µL, and automated serial dilutions on the cartridge. Actual sample requirements depend on the assay. For teams working with limited protein, these capabilities can make it easier to plan comparisons, repeats and controls while keeping sample demands manageable.

The automation advantage also starts with the consumable.

Alto’s sensors, sample wells and assay fluid handling are integrated into a disposable cartridge. Its well spacing supports single- and eight-channel pipetting, and the cartridge is designed for robotic handling. That gives an automation team a defined unit to prepare, move and load. These features are described in the Alto Automation Suite documentation.

For me, the useful benefit is the connection between sample preparation and measurement: the instrument can carry out programmed sample movements and dilutions after the cartridge is loaded.

Connecting SPR to a larger automated workflow

The Alto Automation Suite adds an API—a software interface—for checking instrument status, starting runs and retrieving results. It follows SiLA 2 laboratory automation standards, and Nicoya provides preconfigured labware definitions and workflows for the Opentrons Flex.

With the required liquid handling, robotic transfer and scheduling in place, the documented workcell supports unattended SPR operation.

It also creates an interesting option for scaling: one shared liquid handler could prepare cartridges for multiple Alto instruments while those instruments run their assays. The number it could support depends on preparation times, assay schedules, robotic access and sample-storage requirements, so that configuration needs to be validated during integration.

The aim is to make experimental feedback easier to collect and connect to the original design.

Adding a stability check with SUPR-DSF

Binding is one part of understanding a candidate. Its response to stress is another.

SUPR-DSF complements that workflow by measuring changes in a protein’s natural fluorescence during heating. Nicoya describes a 384-well format, 10 µL sample volumes, and standard qPCR plates and seals.

That provides a practical way to compare thermal behaviour across suitable candidates or buffer conditions, using familiar consumables.

Its plate format also supports automated sample preparation and robotic loading. A manufacturer application note documents robotic loading and measurement of 16 plates, with sample preparation performed as separate modules.

The methods answer different questions: SPR examines binding behaviour; DSF examines thermal unfolding behaviour. Intrinsic DSF needs a usable fluorescence signal, and a melting temperature alone does not establish shelf life or biological activity.

These product capabilities describe potential workflows; the Anthropic campaign was not a demonstration of Alto or SUPR-DSF.

What I’m taking from this

For teams designing proteins with AI, I think the most useful next step is to plan the experimental feedback alongside the computational pipeline.

Decide what evidence a candidate needs, then choose a workflow that makes collecting that evidence practical. Low sample requirements, automation-compatible consumables and connected instruments can help teams spend less time preparing samples and more time interpreting results.

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

These posts share my own perspective as I continue learning and are not official company statements.

AI assisted with research and drafting.

If you have questions about SPR, protein stability or how these systems could fit into your workflow, I’m happy to chat.

Desmond Gilmour

Email: dgilmour@nicoyalife.com

Phone: +1 519-546-9876

Beyond Tm: What SUPR-DSF Adds to a Protein Stability Screen

Desmond Gilmour — Mon, 19 Oct 2026 15:55:35 +0000

If two formulations give your protein nearly the same melting temperature, how do you decide which one deserves further testing?

As I continue learning about protein stability, I’m finding that what happens after heating can be just as useful as what happens during it.

That is what caught my attention about temperature cycling on SUPR-DSF.

What does melting temperature tell us?

Intrinsic differential scanning fluorimetry, or intrinsic DSF, tracks changes in a protein’s natural fluorescence as it heats up. These changes can reveal unfolding, the loss of its folded structure.

The apparent melting temperature, Tm, describes where an unfolding transition occurs. It is useful for comparing how proteins respond to heat under matched conditions. Cohrs et al., 2025.

However, a higher Tm does not automatically mean a better formulation. In one antibody study, Tm did not correlate with long-term aggregation rates during refrigerated or room-temperature storage. Rembert et al., 2024.

So there is another question worth asking: does the protein recover when it cools down?

What temperature cycling adds

SUPR-DSF supports modulated scanning fluorimetry, or MSF, which adds repeated heating and cooling cycles.

After each heating step, the sample returns to a reference temperature. The instrument measures whether its fluorescence returns toward the starting signal. Increasing the heating temperature across successive cycles reveals when recovery begins to fail.

This provides a nonreversibility onset temperature, Tnr, alongside the unfolding information.

There is research behind asking this question. In a study of 13 antibodies, those that resisted aggregation during storage at 40°C had higher nonreversibility onset temperatures. That makes reversibility a useful additional clue when choosing candidates for further testing. Berner et al., 2021.

Why the screening format matters

A useful measurement also needs to fit the amount of protein, time, and budget available.

SUPR-DSF uses as low as 7 µL samples in plates with up to 384 wells. Small sample volumes can help conserve material, while the plate capacity provides room for multiple buffers, additives, controls, and replicates.

It also uses standard qPCR plates and seals, which can help keep routine consumable costs down. For a lab comparing many conditions, those practical details can make a broader screen easier to manage.

How I would use the extra information

Imagine two formulations with similar Tm values, but one loses fluorescence recovery earlier. That hypothetical result gives you a reason to investigate a difference that the melting temperatures alone missed.

My takeaway: use SUPR-DSF to compare both unfolding and recovery, then use those results to decide which formulations deserve the next round of testing.

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

What Chirascan LD Reveals About Polymer Alignment

Desmond Gilmour — Tue, 13 Oct 2026 02:23:24 +0000

By Desmond Gilmour

As part of my learning journey, I’ve been exploring how Chirascan linear dichroism, or LD, can help researchers understand polymers. I wanted to share three papers that made this application clearer to me.

What caught my attention was a simple idea: a material’s behaviour depends on how its parts are arranged. For polymer films and coatings, knowing whether those parts line up can help explain how the material interacts with light.

What LD measures

LD compares how much light a sample absorbs in two directions of polarisation, set at right angles. Polarisation describes the direction in which light’s electric field vibrates.

If the sample absorbs more strongly in one direction, that difference can reveal alignment among its light-absorbing parts. With a suitable absorption band, researchers can relate this to the arrangement of a polymer or its components.

A Chirascan configured for LD measures that difference across wavelengths. This helps researchers investigate questions such as whether a coating process preserved alignment or how a polymer sits within a larger structure.

Three papers that helped me understand the application

The first two used Chirascan for LD. The third used its complementary CD capability to study polymer films.

1 Checking alignment in polymer coatings

In a study published online in 2024, Khelifa and colleagues built coatings containing cellulose nanocrystals—tiny, rod-like particles—inside an acrylic polymer.

They used Chirascan Plus LD to study films with up to 50 layers. Turning the films changed the signal from positive to negative. Together with X-ray measurements, the results supported the conclusion that alignment was preserved as layers were added.

For coating research, that is a useful contribution: Chirascan helped the team check whether their fabrication process maintained the internal structure they wanted.

2 Understanding how a polymer follows a template

In a 2015 paper in RSC Advances, Hanczyc and colleagues studied a polyfluorene derivative, a polymer with useful light-absorbing properties. They examined how it associated with thin protein fibres that acted as templates.

Using Chirascan with an LD accessory, they found evidence that the polymer backbones lined up along those fibres. The spectra also revealed differences between dissolved and aggregated forms attached to the fibres.

LD added information about the polymer’s arrangement, helping the researchers interpret its optical behaviour. Separate laser measurements examined its ability to absorb two photons.

3 Exploring the optical behaviour of polymer films

In a 2020 Nature Communications paper, Wade and colleagues used Chirascan CD to study semiconducting polymer films.

CD compares absorption of left- and right-handed circularly polarised light. The combined measurements linked the strong response in non-aligned films to local interactions within the material.

This study shows another useful side of Chirascan for polymer research: investigating optical properties linked to handedness. LD and CD provide different pieces of information, and both can matter when developing materials that control light.

Why Chirascan stands out to me for this work

What I find useful is the range of questions an appropriately configured Chirascan can address.

Its solid sample holder allows compatible films to be measured at different angles. For suitable elongated structures in liquid, the Couette cell for Chirascan VX and V100 uses controlled flow to create alignment. Researchers can then measure how absorption changes with direction.

That gives researchers ways to study both finished films and assemblies in liquid. The ability to investigate LD and CD also helps connect a material’s alignment with its wider optical behaviour.

My takeaway from these papers is that Chirascan can help turn questions about polymer organisation into measurable evidence. That is what makes this application interesting to me: understanding how a material’s structure contributes to what it does.

I work at Nicoya Lifesciences. The views expressed here are my own and do not necessarily reflect those of Nicoya. This is a personal publication, not an official company communication.

3D Spinning Molecule Using Avogadro, Blender and Three.js

Desmond Gilmour — Sun, 30 Apr 2023 13:16:50 +0000

TL;DR

In this blog post, we'll explore how to convert any molecule of interest into an .obj file, which will enable you to create and display molecular animations on your personal website.

Intro

As a chemist and computer scientist, you might find your creativity expressed in various ways. When I come across well-designed tools or personal websites with engaging features, I tend to get excited about what they are doing. I imagine this might help you with the same.

What You Will build

In this blog post, we'll guide you through adding a molecule to your personal site. The molecule displayed here is called epinephrine:

This will be done in two steps.

We will create the object file based of this youtube video using Avogadro, OpenBabel and final blender.
Implement your new molecule object as a Next.js component.

Getting Started

overing the entire process would result in an excessively long blog post, so we'll rely on a detailed YouTube video for the initial steps. This video will walk you through the creation of the .mol object, and its instructions can easily be adapted to different molecules.

The only deviation from the video is that I exported the fully-created molecule as an '.fbx' file.

Building the component

We'll briefly explain how to build this component before presenting the representative code.

Import necessary dependencies and a 3D model file in FBX format (Epinephrine.fbx).
Create a functional component Molecule that uses the useRef hook to create a reference to a DOM element (the container for the 3D scene).
Use the useEffect hook to set up the Three.js scene when the component is mounted. This hook is called once when the component is mounted, and the clean-up function is called when the component is unmounted.
Inside the useEffect hook, create a new Three.js scene, camera, and renderer. The renderer is added to the container element (retrieved using the containerRef).
Load the 3D object (molecule) using the FBXLoader. Once the object is loaded, add it to the scene, set up lighting (ambient, directional, and point lights), and add the lights to the scene.
Define an animate function that animates the 3D object by rotating it around the Z-axis. The renderer then renders the scene, and the animate function is called again using requestAnimationFrame. This creates an animation loop.
As a clean-up function, remove the renderer DOM element from the container and dispose of the renderer when the component is unmounted.
Render a div element with the reference to containerRef and a specified width and height, which serves as the container for the Three.js scene.

Full Code

import React, { useRef, useEffect } from 'react';
import * as THREE from 'three';
import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader';
import molecule from "./Epinephrine.fbx";

export default function Molecule() {
    const containerRef = useRef();

    useEffect(() => {

        const scene = new THREE.Scene();
        const camera = new THREE.PerspectiveCamera(
            75, 
            containerRef.current.clientWidth / containerRef.current.clientHeight,
            0.1, 
            2000 
        );
        camera.position.z = 625;


        // Create a Three.js renderer
        const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
        renderer.setClearColor(0x000000, 0);
        renderer.setSize(containerRef.current.clientWidth, containerRef.current.clientHeight);

        // Add the renderer to the container
        containerRef.current.appendChild(renderer.domElement);

        // Load the 3D object
        const loader = new FBXLoader();
        loader.load(molecule, (object) => {
            object.rotation.x = Math.PI / 2;
            scene.add(object);
            const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
            scene.add(ambientLight);

            const directionalLight1 = new THREE.DirectionalLight(0xffffff, 0.5);
            directionalLight1.position.set(0, 1, 0);
            scene.add(directionalLight1);

            const directionalLight2 = new THREE.DirectionalLight(0xffffff, 0.5);
            directionalLight2.position.set(0, -1, 0);
            scene.add(directionalLight2);
            const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
            directionalLight.position.set(-1, 1, 1);
            scene.add(directionalLight);

            const pointLight1 = new THREE.PointLight(0xffffff, 1, 100);
            pointLight1.position.set(-5, 5, 5);
            scene.add(pointLight1);

            const pointLight2 = new THREE.PointLight(0xffffff, 1, 100);
            pointLight2.position.set(5, -5, 5);
            scene.add(pointLight2);

            // Animate the object
            function animate() {
                object.rotation.z += 0.01;
                renderer.render(scene, camera);
                requestAnimationFrame(animate);
            }
            animate();
        });

    // Clean up
        return () => {
            containerRef.current.removeChild(renderer.domElement);
            renderer.dispose();
        };
    }, []);

    return <div ref={containerRef} style={{
        width: '200px', 
        height: '300px',  
    }}/>;
}

If you have any questions or want to discuss this further, feel free to reach out to me through the social media links available on my personal website. I'd be happy to help!

Lasso Highlighting In Datamol

Desmond Gilmour — Mon, 17 Apr 2023 18:07:37 +0000

TL;DR

In this blog post, we'll explore the lasso_highlight_image() function in Datamol, a Python library for scientists working with molecular data. We'll see how it can be used to highlight specific parts or features of a molecule quickly. We'll also provide some examples of how to use the function and discuss its limitations and areas for improvement for future contributors.

Intro

If you work with chemical data and need to visualize it, you'll want to check out Datamol. This Python library has a new addition called lasso highlight, which was initially produced by Christian W. Feldmann. The lasso highlighting function allows you to quickly identify and visualize specific parts or features of a molecule. It's useful for identifying functional groups, comparing and contrasting different molecules, and analyzing molecular structure and properties.

Examples

To use the lasso_highlight_image() function, you supply a molecule and specify the substructures you want to highlight. The function returns an image of the molecule with the specified substructures highlighted. You can provide the target and search molecules in SMILES format or as a rdkit.Chem.mol object. The function also takes parameters to specify the image type (PNG or SVG), size, and image characteristics.The details of each parameter can be found here.

Here are two examples to help you get started:

1.Lasso highlight with multiple substructures with PNG image

import datamol as dm

target_molecule = "CO[C@@H](O)C1=C(O[C@H](F)Cl)C(C#N)=C1ONNC[NH3+]"
substructure = ["CONN", "N#CC~CO"]

dm.lasso_highlight_image(target_molecule, substructures, (400, 400), use_svg=False)

Lasso highlight with single substructures with SVG image

import datamol as dm

target_molecule = "CO[C@@H](O)C1=C(O[C@H](F)Cl)C(C#N)=C1ONNC[NH3+]"
substructure = dm.to_smarts("CONN")

dm.lasso_highlight_image(target_molecule, substructure, (300, 300))

Limitations and What's Next

Although the lasso_highlight_image() function is highly valuable, it does have a few limitations. To enhance its capabilities and overcome these constraints, the following features could be incorporated:

Add functionality to write to a file, similar to the to_image() function in Datamol/viz/viz.py.
Allow the analysis of multiple target molecules at once.
Canonicalize search molecules to prevent duplicate highlighting.
Update the documentation in Visualization.ipynb.

If you're interested in contributing to the project, check out the Datamol website and the contribution guidelines. Alternatively, feel free to contact me from my social media on my personal website for any questions or feedback.

Contributing to RDKit

Desmond Gilmour — Tue, 28 Mar 2023 19:26:06 +0000

If you want to get into cheminformatics or AI/ML for drug discovery, you may have encountered RDKit. It is a great tool to help you analyze chemical information and is used in many labs, making it a great open-source tool to contribute to if you're looking to work in the biotech industry!

I needed help figuring out how to contribute to the RDKit. However, one tutorial explained it well, although I did need just a bit more help figuring out how to exactly to do it. I wrote this blog to provide an informal way to fill the gaps in case anyone else is missing a certain piece to building RDKit too. I was working on MacOS Ventura 13.1 when I built RDKit.

The below steps will explain how to run, test, and ultimately contribute to the RDKit

1. Fork and clone to your local machine

You can do this a few different ways; choose whichever you like.

Visit RDkit's Github and fork the project.

Once forked, go to the green button on the repo that says "<> Code" and copy the HTTPS URL from the dropdown.

Open the folder you want to use and enter the command git clone https://github.com/<YOURUSERNAME>/rdkit where is replaced with your own.

2. Compile and Run RDKit on Your Machince

Open the project folder in whichever source code editor you prefer.

Make a conda environment using the below commands in your terminal...

conda create -c conda-forge -n my-rdkit-env rdkit
conda activate my-rdkit-env

Followed by the commands below to help RDKit locate what it needs to...

export RDBASE=`pwd`
export DYLD_LIBRARY_PATH="$RDBASE/lib"
export PYTHONPATH="$RDBASE"

You need to create your build folder and change the directory to it...

mkdir cmake-build
cd cmake-build

Use cmake called with the following flags. The .. after all the flags are essential for the command to navigate the files, do not exclude.

cmake -DPy_ENABLE_SHARED=1 -DBOOST_ROOT="$CONDA_PREFIX" -DBoost_NO_SYSTEM_PATHS=ON -DBoost_NO_BOOST_CMAKE=TRUE -DRDK_INSTALL_INTREE=ON -DRDK_INSTALL_STATIC_LIBS=OFF -DRDK_BUILD_CPP_TESTS=ON -DPYTHON_NUMPY_INCLUDE_PATH="$(python -c 'import numpy ; print(numpy.get_include())')" -DRDK_BUILD_CAIRO_SUPPORT=ON -DRDK_BUILD_FREETYPE_SUPPORT=ON ..

Now we will build the RDKit using the command below, don't be surprised if this takes 1 hour or longer. Luckily, you will only have to do this once, as CMake is smart enough to rebuild the files you have changed.

(make -j 6 install ; find $RDBASE/rdkit -name \*.so -exec install_name_tool -add_rpath $RDBASE/lib {} \; -print )

Now you have a fully compiled and built RDKit you can use from here on out. You can use ctest to ensure it runs and all test cases are successful. Typically you would like to run test from only one test file and to do that you would run something similar to ctest -R <test_name> This way you can focus better on your own changes.

3. Finding an Issue and Making A Branch

Now that everything is built, you can navigate to GitHub and pick an issue that interests you and branch to start working on this issue as such...

git branch fixes-#<issue number>

Insert the issue number where is; this way when your PR is merged, it automatically is linked to the issue so it can be removed.

I hope this helps clarify building and contributing to RDKit. I would love feedback about potential changes I can add to this post, so please do not hesitate to share.

Thanks for reading!

How to Automatically Update Resume On Your Personal Site From OverLeaf

Desmond Gilmour — Mon, 27 Mar 2023 22:45:29 +0000

I don't know about you, but I struggle with keeping track of the hundreds of iterations of my resume and keeping my website updated with the most recent one. So I thought to automate it.

This post explains how to automatically update your resume from OverLeaf onto your personal website. This post is specific to paid users of OverLeaf since it is a paid feature to push from OverLeaf to GitHub

Open the drop-down where it says menu on the top left-hand side of your project. It will produce a drop-down, as shown in the picture below. Click sync to GitHub.

Enter a repository name and a brief descriptions to and create the repository.

Go to GitHub to see a new repository where only your latex file from OverLeaf should exist. In this repo, go to the Actions tab at the top, as shown in the picture below

Create a new workflow, and then enter the code below. This code will create the PDF version of the latex file with every push into this repository. Each push will create a new release of your resume's latest iteration, and it will be an artifact attached to this. You may encounter an error based off the permission of the GitHub Action but this issue is explained well in this post.

name: Build LaTeX document
on: [push]
jobs:
  build_latex:
    runs-on: ubuntu-latest
    steps:
      - name: Set up Git repository
        uses: actions/checkout@v2
      - name: Compile LaTeX document
        uses: xu-cheng/latex-action@v2
        with:
          root_file: main.tex
      - name: Uploading artifact
        uses: actions/upload-artifact@v2
        with:
          name: PDF
          path: main.pdf
      - name: Get Time
        id: time
        uses: nanzm/get-time-action@v1.1
        with:
          timeZone: -5
          format: 'YYYY-MM-DD-HH-mm-ss'
      - name: Create Release
        id: create_release
        uses: softprops/action-gh-release@v1
        with:
          name: Resume compiled on ${{ steps.time.outputs.time }}
          tag_name: ${{ steps.time.outputs.time }}
      - name: Upload Release Asset
        id: upload-release-asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: ./main.pdf
          asset_name:  resume-${{ steps.time.outputs.time }}.pdf
          asset_content_type: application/pdf

Navigate to your program, where your download resume link exists. We will use GitHub's Graphql API to retrieve the download URL for the PDF version of your resume. Space Jelly explains the following code very well. This was placed at the top of Navbar React component of my personal project.

const [downloadableResume, setDownloadableResume] = useState();

  const baseUrl = "https://api.github.com/graphql";

  const httpLink = createHttpLink({
    uri: baseUrl,
  });

  const authLink = setContext((_, { headers }) => {
    return {
      headers: {
        ...headers,
        authorization: `Bearer $${process.env.GITHUB_ACCESS_TOKEN}`,
      },
    };
  });

  const client = new ApolloClient({
    link: authLink.concat(httpLink),
    cache: new InMemoryCache(),
  });

  useEffect(() => {
    client.query({
        query: gql`
        {
          viewer {
            login
          }
          repository(name: "resume", owner: "dessygil") {
            id
            releases(first: 1) {
              edges {
                node {
                  id
                  releaseAssets(first: 1) {
                    edges {
                      node {
                        downloadUrl
                      }
                    }
                  }
                }
              }
            }
          }
        }
        `,
      })
      .then((response) => {
        setDownloadableResume(response.data.repository.releases.edges[0].node.releaseAssets.edges[0].node.downloadUrl);
      });
  }, []);

This should be all you need to build a fully automated pipeline for your personal website. If there is anything else that you would like to see added to this post, please don't hesitate to reach out.