# ANASEN Monte Carlo (anasenMS.cpp)

## Overview

`anasenMS.cpp` is a standalone Monte Carlo simulation for an ANASEN-style detector setup. It generates transfer reaction kinematics, propagates products to a wire chamber (PW) and a silicon array (SX3), reconstructs tracks, and writes output to a ROOT tree.  

## Requirements

- ROOT (e.g. `root-config` for compile flags)
- C++ compiler (gcc/g++)
- Project includes: `ClassTransfer.h`, `ClassAnasen.h`, plus their dependent implementation files.

## Build

In `Armory` directory:

the directory contains a make file

Run `make AnasenMS` and it will automatically run

```bash
g++ -O2 -o anasenMS anasenMS.cpp ClassTransfer.cpp ClassAnasen.cpp ... `root-config --cflags --libs`
```

(Adjust source file list based on actual project layout.)

## Run

```bash
./anasenMS [numEvents] vis(optional)
```

- `numEvents`: optional integer, default `1000000`
- Outputs: `SimAnasen1.root` containing `tree1` and `tree2`
tree1 contains pre-energy loss calculations
tree2 contains post-energy loss calculations (subject to change)

## What the code does

- Detector geometry is built within ClassAnasen.h

-To assign dead channels (anode/cathode/SX3), add ID's to IsDead<detector> boolean functions at top of simulation,
  inside the set

- Initializes reaction: `TransferReaction transfer`
  - `SetA(24,12,0)` target
  - `SetIncidentEnergyAngle(10,0,0)` beam energy and direction
  - `Seta`, `Setb` reaction fragment indices
- Sets excitation lists: `ExAList`, `ExList`
- Vertex and resolution settings:
  - `vertexX/Y/Z` ranges
  - `sigmaSX3_W`, `sigmaSX3_L`, `sigmaPW_A`, `sigmaPW_C`
- Loads energy loss tables from `../ELoss/` using `TGraph` for interpolation
- Prepares ROOT output tree and branches for truth/reconstructed
- Loop over events:
  - Sample excitation and CM direction
  - `transfer.Event(thetaCM, phiCM)` outputs `TLorentzVector` products
  - Compute lab angles/energies
  - Random vertex inside target volume
  - Run detector response:
    - `pw->FindWireID(...)`
    - `sx3->FindSX3Pos(...)`
  - Read out wire hits and SX3 channel + depth
  - Apply position smearing for SX3
  - **Apply energy loss** to light particle using interpolated dE/dx from table, based on path length from vertex to hit
  - Reconstruct track via `pw->CalTrack` and `pw->CalTrack2`
  - Fill ROOT tree
- At end: write tree, close file, clean up

## Notes

- Important methods are from:
  - `ClassTransfer` (`SetA`, `SetIncidentEnergyAngle`, `Seta`, `Setb`, `SetExA`, `SetExB`, `CalReactionConstant`, `Event`)
  - `ClassAnasen` / `SX3` / `PW` (`FindWireID`, `FindSX3Pos`, `GetHitInfo`, `CalTrack`, `CalTrack2`, `GetTrackTheta`, `GetTrackPhi`, `GetZ0`, `GetHitPosWithSigma`, `GetID`, etc.)
- Optional: change excitation lists, vertex spread, and sigma values to mimic different beam/target conditions.

## Example Workflow

- Say you want to do a beam of Al27 through standard pressure gas.
  - If using the random energy scan route, determine the depth your beam travels in the detector, and set the appropriate window in the .cpp file in <<vertexZRange>>.
  - If you want to track it's energy loss through the detector, create a lookup table with PCEnergyAnalysis.py in the helium and import it using <<elossbeam>>. When making the table, set the initial energy of the beam as the 'max energy' of the table.
To take into account things like the kapton window and other materials, make lookup tables for them and map their energy loss through them one after another, and use the final energy from that as the maximum beam energy.

- For there you need to run a simulation for each reaction you want to measure. Declare their components in the transfer.Set(A,a,b,B). A is your beam, a is the helium target, b is your proton, alpha, deuterium, etc, and B is the daughter nuclei. 

- Run 'make AnasenMS' in the build directory and let it compile. From there, run the excecutable './AnasenMS'. The simulation will run and automatically load all the data into the root file 'SimAnasen1.root'. This is the file that gets read into PCEnergyAnalysis.py. 

- Once the simulation is complete, start the analysis script. Do not start it while the simulation is still running, or you will miss data. The simulation will automatically open the file SimAnasen1.root, and with that you can run 'make_plots'. If it's proton data, it will assume that automatically, but if it is alpha data, you need to pass 'alpha' as an additional argument.

- If you have two reactions to analyze, you can use 'dual_plotter'. Renaming them 'SimAnasenProton.root' and 'SimAnasenAlpha.root' will allow you to run the function with no additional arguments. However, for any other names or additional reactions, you will need to add the file names manually as additional arguments. The program assumes them to be in the Armory directory, so if they are in a subfile, include the subfile in the argument. 

- Plots and histograms will automatically get saved to the ELoss folder. By default reactions are on tree1, and are sorted by particle

- Tree2 is used for secondary decay channels, and simulating double-proton decays. The secondary decay data is stored in tree2. Dual plotter will combine trees automatically, but make_plots assumes to use tree1. This can be switched using set_tree in the program, and then running make_plots
  - Secondary reactions can be turned off and on with a boolean <<enableSequentialDecay>>
  - Fill in relevant data about the decay in the lines following

- Additional features include terminal energy loss calculations using initial energy, final energy and distance travelled. Using two of these three there are three different functions to find the third variable. For range, use energy_distance, declare the particle, medium, the initial energy, and set final energy to 0. This will give you the range of the given particle.