Research

Areas of research on this page include particle physics, automation, microscopy, and biophysics

Investigation of interference effects in resonant and non-resonant Beyond the Standard Model Higgs Pair Production at ATLAS*

Searching for Higgs pair production, in events with two b-jets and two τ-leptons, the Standard Model predicts non-resonant HH production below the sensitivity of the currently available LHC data set. Significant non-resonant and resonant enhancements to the HH cross section are predicted in many Beyond-the-Standard-Model theories, including a Heavy Higgs boson decaying to two 125 GeV mass Higgs bosons.

Experimentalists have been using the narrow width approximation for the heavy Higgs resonance, ignoring the possible influence of higher widths. Is it safe to assume we can use the narrow approximation, or could variable widths have a significant influence on the interference between the heavy Higgs and the Standard Model Higgs?

We investigate Higgs pair production in the final state with two b-jets and two τ-leptons using MadGraph at the Parton level. The studies include a range of point masses for the heavy Higgs from 300 to 2000 GeV. Each point mass is generated at variable widths of the heavy Higgs resonance.

Interference between the non-resonant and heavy Higgs resonant production were found to be dependent on mass point and width. Particular masses interference is greatest at particular widths. Thus, we should be testing at all widths, especially with particular point masses.

*This material is based upon work supported by the National Science Foundation.

Below is a demonstration of the root based nTuples used for analysis constructed via MadGraph.

Below is a constructed algorithm composed of a variety of languages, such as: Root, C++, LaTex, and Script. This algorithm was composed to produce a variety of histograms for analysis.

Below is summarized presentation of the conducted study. The audience of this presentation was ATLAS's BBtautau DiHiggs Production group located within CERN.

An Automated Platform For High Throughput Fluorescence Microscopy

We integrated an inverted digital fluorescence microscope (Etaluma LumascopeTM), a laboratory robot (KiNEDx KX-300), and a focus motor to create an inexpensive, high throughput, screening platform. High throughput biology or biochemistry is generally performed using multi-well microtiter plates. For example, a stack of ten 384-well plates is equivalent to 3,840 test-tubes, or individual assay containers. Our automated microscopy platform takes sequential multi-color images of each well in a stack of plates, without any human intervention. Commercially available lab equipment that performs similar automated microscopy in microtiter plates costs more than $100,000. Our apparatus achieves these capabilities at a fraction of that cost, making automated high throughput microscopy available to more academic and budget-constrained labs.

Unique to our approach is using one robot to move microtiter plates from stack(s) to the microscope stage, and sequentially positioning each well over the microscope for imaging. This eliminates the need for an expensive automated stage. A stepper motor driven belt around the microscope’s focus knob enabled an Arduino microcontroller to automate focus. Manual focus is facilitated via a toggle switch attached to the Arduino inputs. From device drivers to assay protocol, software architecture is based on a hierarchy of short MATLAB functions and scripts. Device drivers for the robot, LumascopeTM, and focus motor (Arduino) support two modes. Simulation mode facilitates debugging by driving a 3-D graphical representation of the apparatus that updates as the protocol executes. Turning off the simulation mode sends commands to the hardware, which responds in real-time. The bulk of the source code executes identically in both modes, thus reducing the need for tedious debugging of the platform in real time.

We will demonstrate the automated microscopy platform in operation, characterize its throughput and focus performance, and explain its novel use.

Below is poster constructed to summarize our research to the CSU Channel Islands 2022 SAGE Conference.

In Progress

Cardiomyocytes Beat Frequency Study with Variable Drug Induction

Cardiomyocyte Monte Carlo for Constructing Fast Fourier Transform Analysis Program

Here is Simulation program in regards to beads, to attempt a Fast Fourier Transform analysis program on.

To run the program, one needs to download the following MATLAB files in one folder where you will be running everything from.

1. BeadsClass.m

2. WellImageClass.m

3. MonteCarlo_CardioWell.m

This program is implemented via object oriented programming. BeadClass creates a bead of properties such as dead or alive, frequency, location, etc. WellImageClass creates a singular well image contain a set amount of beads, containing variable properties ranging from the images size, number of beads, background noise, etc. MonteCarlo_CardioWell is the main program that implements the object programs. Please note, the only portion to be ran is the MonteCarlo_CardioWell.m file, it will call to the other files like a library in a computer program that are included prior to the main instantiation. Think rather, instead of ints, booleans, floats, essentially the basic variable types, we are using a new variable type we created. Just like there are default libraries in programming that allow there to be functions and parameters for the basic variables, we make our own libraries in BeadClass.m and WellImagesClass.m. These files allow us to give properties and make functions for manipulating our new "home-made" variables. I wouldn't recommend tampering much with BeadClass.m and MonteCarlo.m unless your looking to add more function types for each of our new variable types are implement some debugging in the code. In MonteCarlo_CardioWell program, is your main program essentially, that calls and makes declarations and instances of these variable types. Essentially, BeadClass.m and WellImageClass.m is where we design our variables, but MonteCarlo_CardioWell.m is where we use and implement the variables. Here, MonteCarlo_CardioWell.m begins with an inputted image size parameter, for the size of the image to produced, it then creates a well of beads image, creates and randomizes as programmed. Then I call it to produce an image at variable times. It begins at 1 second to 13 seconds, and the frequency is a dedicated randomized value in the the class files in the form of radians/sec. If you run the MonteCarlo_CardioWell.m program as is, you will have 13 figure windows appear, where you will see a change in the "alive" beads and the "dead" ones stay the same color because there not changing. I do not go too deep into explaining the properties and processes implements and the concepts being implemented in WellImageClass or BeadsClass but I am happy to if requested. Additionally, I have included a sample run below with the provided code as is:

Here we have a 1600x1600 well image. The bead count is randomized and not chosen. This scenario we have 21 beads. Keep in mind this value will changes and new images are produced with new beads each time you run the main MonteCarlo_CardioWell.m file. Below are the produced images.

Scrolling through the images as if it where a time lapse image, you'll notice that there are 21 beads as foretold by the program. If you had looked through the command window - I did but didn't show it cause its a significant amount to screenshot since we are looking at all the properties of each bead, so many many many screenshots are needed for 21 beads - you will see that a set portion of our beads are dead and some are alive. Only a set few change color, as a result of the bead being on a beating cardiomyocyte, and the ones on a dead cardiomyocyte don't move so its color doesn't change, these are according to it initialize status. In this scenario, we have about 5 dead and the rest are alive. I believe, one may have been cropped out by my screenshot, therefore you will only see 20 instead of 21. The variance in color of the beads on an alive cell, are a function of cosine, in a way behaving as an oscillation like a heartbeat. Therefore, you may see some beads disappear completely, but just like an oscillation function, it will come back, our function just hit zero is all, but in the next second or two they will come back. There is some slight debugging to be done, we want our frequency to be in a scale much faster then per second, and we don't want the beads to disappear, but at minimum be extremely dim, the beads are quite large in the image honestly, they can easily be made smaller for more realistic image, and lastly, the oscillation value of the green value goes either negative or out of bounds for green in our oscillation function after 13 seconds, meaning the function may need some alterations or the frequency and initial phase rather. The frequencies of all the alive beads are a function of randomizing, but gaussian randomization, meaning that all the frequencies of the alive beads are centered around an average or a mean. Essentially, we can start testing the use of a Fast Fourier Transform and match up its analysis with the mean value of the random gaussian used to provide the alive beads a frequency in the class file.

In performing the Fast Fourier analysis, one may find it fruitful to produce the resulting images and produce an image stack. MATLAB provides a variety of functions I have only begun playing with that require the passing in of an image stack. To increase the the number of images in your image stack, it may be best to rather do increments of one second as in the MonteCarlo_CardioWell.m program that produces 13 images to do a tenth of second increments. Starting at 0.1 seconds, to 13 seconds. Giving you well over a 100 images to make an image stack from and attempt Fourier Analysis on. FFT_Thomas.m, This is an initial attempt on using image stacks and FFT with MATLAB. This attempt was conducting prior to the one described above, therefore the image stack and use of FFT are different, but it provides a demonstration into the possibility of using FFT on an image stack and so on. One would highly recommend doing a deep dive read into the functionality and implementations of MATLAB's Fast Fourier Transforms functions.

The aforementioned MATLAB files:

%BeadClass.m

classdef BeadsClass 
    properties
        xCord                           % Coordinate in the X plane
        yCord                           % Coordinate in the Y plane
        Dead                            % Will this bead be moving, 1 true, 0 false
        BeatFrequency                   % How fast we see change in the oscillation of the bead brightness
        Brightness                      % current brightness of this bead as a function of time
        MaxAmplitude                    % Max amplitude of the brightness of the bead  
        InitialPhase                    % Randomized initial phase shift of the bead in terms of its oscillation (between 0 and 2π)
    end 

    methods

        function obj = BeadsClass(xCord, yCord, Dead, BeatFrequency,Brightness, MaxAmplitude, InitialPhase) %initialization of the bead
            obj.xCord = xCord;
            obj.yCord = yCord;
            obj.MaxAmplitude = MaxAmplitude;
               
            if Dead == 0
                obj.Dead = Dead;
                obj.BeatFrequency = 0;
                obj.InitialPhase = 0;
            else
                obj.Dead = Dead;
                obj.BeatFrequency = BeatFrequency;
                obj.InitialPhase=InitialPhase;
            end
            obj.Brightness =Brightness;
        end

        function g = get.xCord(obj)
            g = obj.xCord;
        end

        function g = get.yCord(obj)
            g = obj.yCord;
        end

        function g = get.Brightness(obj)
            g = obj.Brightness;
        end

        function obj = Set.Brightness(obj, time) % make the brightness a oscillation function of time with a frequency
            w = obj.BeatFrequency;
            A = obj.MaxAmplitude;
            t = time; 
            O = obj.InitialPhase;
            s = A*cos(w*t + O);
            obj.Brightness = s;
        end 

    end
end

%WellImageClass.m 

classdef WellImageClass 
    properties
        ImageSize                       % m value for a m x m image 
        time                            % time value for the image
        numberOfBeads                   % number of beads in this image
        sigma           
        noiseAmpl     
        beadArray                      %creates an array of our beads
        Image                           % The image
    end
    methods
        function obj = WellImageClass(imgSz)
            obj.time = 0;
            obj.ImageSize = imgSz;
            obj.numberOfBeads = 0;
            numBeads= (randi([0 25]));   % instantiates anywhere from 0 to 100 beads in our well image
            display(numBeads);
            obj.numberOfBeads = numBeads;
            
            objArray= [BeadsClass(0,0,0,0,0.4470,0.4470,0),BeadsClass(imgSz/4,imgSz/4,0,0,0.4470,0.4470,0)]

            for i = 1:numBeads
                xcord = randi(imgSz)+0;
                ycord = randi(imgSz)+0;

                viable = randi(3);                    % random value between 0 and 1, 1 - dead, 0 - alive
                if viable ==3
                    viable =1;
                else 
                    viable = 0;
                end 
   
                freqW = randi(11.0001-0.0001)-1;        % the rate of change of the brightness can be anywhere from 0 10 for the brightness                   
                maxAmp = randi(10)+10;                               % note in matlab, green has a value between 10-20 for 0-255 scale
                PhaseO = randi(361)-1;              % random phase shift between 0 - 2π
                PhaseO = PhaseO*pi/180;

                % begin initalization of all beads in well
                
                newbead = BeadsClass(xcord,ycord,viable,freqW,0.4470,0.4470,PhaseO)
                objArray(end+1) = newbead;
           

            obj.beadArray = objArray;  

                pause(0.5);
            
            end

        end

        function g = get.numberOfBeads(obj)
            g = obj.numberOfBeads;
        end
        
        function r = imageAtTimet(obj, time, imgSz)    % creates image at desiganetd time with the beads at there designated brightness
                                                % call the Amplitude of
                                                % brightness function in
                                                 % bead class in order
                                                
            x0 = imgSz/2;
            y0 = imgSz/2;
            ampl =1;
            obj.noiseAmpl = randi(2);
            obj.sigma = randi(2);

            [x, y] = meshgrid(1:imgSz,1:imgSz); 
            img = ampl * exp(-((x-x0).^2 +(y-y0).^2)/2/obj.sigma^2); 
            obj.Image = obj.noiseAmpl * randn(size(img));   % Creates a noise image background the image of the well
            
            figure('Visible','on')
            imshow(obj.Image)

            for i = 1:obj.numberOfBeads
                hold on

                objArray = obj.beadArray;

                currentBead = objArray(i)
                xb = currentBead.xCord;
                yb = currentBead.yCord;

                w = currentBead.BeatFrequency;
                A = currentBead.MaxAmplitude;
                t = time; 
                p = currentBead.InitialPhase;
                s = A*cosd((w*t + p)*2/pi);


                greenValue =[0.0 s 0.0];

                plot(xb,yb,'Color',greenValue,'Marker','hexagram','MarkerSize',14,'LineWidth',15)    
           end
            
               
             
        end
    end
end

%MonteCarlo_CardioWell.m


wellSampleSize = 1600;

WellSample= WellImageClass(wellSampleSize);

numbBeads = WellSample.numberOfBeads


WellSample.imageAtTimet(1,wellSampleSize)
WellSample.imageAtTimet(2,wellSampleSize)
WellSample.imageAtTimet(3,wellSampleSize)
WellSample.imageAtTimet(4,wellSampleSize)
WellSample.imageAtTimet(5,wellSampleSize)
WellSample.imageAtTimet(6,wellSampleSize)
WellSample.imageAtTimet(7,wellSampleSize)
WellSample.imageAtTimet(8,wellSampleSize)
WellSample.imageAtTimet(9,wellSampleSize)
WellSample.imageAtTimet(10,wellSampleSize)
WellSample.imageAtTimet(11,wellSampleSize)
WellSample.imageAtTimet(12,wellSampleSize)
WellSample.imageAtTimet(13,wellSampleSize)

Thomas Adams' Portfolio