From bb67011bb523eafa391b73dd7353a0deb3f69427 Mon Sep 17 00:00:00 2001
From: gwm17 <gmccann@fsu.edu>
Date: Tue, 30 Aug 2022 15:01:11 -0400
Subject: [PATCH] Fix up detector geometry, make names clearer for dets and
 constexpr more of the geometry

---
 src/Detectors/AnasenEfficiency.cpp            |  8 +-
 src/Detectors/AnasenEfficiency.h              |  6 +-
 src/Detectors/CMakeLists.txt                  |  4 +-
 src/Detectors/QQQDetector.cpp                 | 47 ++++++------
 src/Detectors/QQQDetector.h                   | 12 +--
 .../{StripDetector.cpp => SX3Detector.cpp}    | 73 ++++++++-----------
 .../{StripDetector.h => SX3Detector.h}        | 25 ++++---
 src/Detectors/SabreDetector.cpp               | 53 ++++++--------
 src/Detectors/SabreDetector.h                 | 53 ++++++--------
 src/Detectors/SabreEfficiency.cpp             |  2 +-
 src/Detectors/SabreEfficiency.h               |  3 -
 11 files changed, 123 insertions(+), 163 deletions(-)
 rename src/Detectors/{StripDetector.cpp => SX3Detector.cpp} (70%)
 rename src/Detectors/{StripDetector.h => SX3Detector.h} (76%)

diff --git a/src/Detectors/AnasenEfficiency.cpp b/src/Detectors/AnasenEfficiency.cpp
index 5a0b7d8..8c6cd19 100644
--- a/src/Detectors/AnasenEfficiency.cpp
+++ b/src/Detectors/AnasenEfficiency.cpp
@@ -11,16 +11,16 @@ AnasenEfficiency::AnasenEfficiency() :
 {
 	for(int i=0; i<s_nSX3PerBarrel; i++)
 	{
-		m_Ring1.emplace_back(4, s_sx3Length, s_sx3Width, s_barrelPhiList[i], s_barrel1Z, s_barrelRhoList[i]);
+		m_Ring1.emplace_back(s_barrelPhiList[i], s_barrel1Z, s_barrelRhoList[i]);
 		m_Ring1[i].SetPixelSmearing(true);
-		m_Ring2.emplace_back(4, s_sx3Length, s_sx3Width, s_barrelPhiList[i], s_barrel2Z, s_barrelRhoList[i]);
+		m_Ring2.emplace_back(s_barrelPhiList[i], s_barrel2Z, s_barrelRhoList[i]);
 		m_Ring2[i].SetPixelSmearing(true);
 	}
 	for(int i=0; i<s_nQQQ; i++)
 	{
-		m_forwardQQQs.emplace_back(s_qqqInnerR, s_qqqOuterR, s_qqqDeltaPhi, s_qqqPhiList[i], s_qqqZList[i]);
+		m_forwardQQQs.emplace_back(s_qqqPhiList[i], s_qqqZList[i]);
 		m_forwardQQQs[i].SetSmearing(true);
-		m_backwardQQQs.emplace_back(s_qqqInnerR, s_qqqOuterR, s_qqqDeltaPhi, s_qqqPhiList[i], (-1.0)*s_qqqZList[i]);
+		m_backwardQQQs.emplace_back(s_qqqPhiList[i], (-1.0)*s_qqqZList[i]);
 		m_backwardQQQs[i].SetSmearing(true);
 	}
 }
diff --git a/src/Detectors/AnasenEfficiency.h b/src/Detectors/AnasenEfficiency.h
index 9c2b7a6..8337793 100644
--- a/src/Detectors/AnasenEfficiency.h
+++ b/src/Detectors/AnasenEfficiency.h
@@ -4,7 +4,7 @@
 #include <string>
 
 #include "DetectorEfficiency.h"
-#include "StripDetector.h"
+#include "SX3Detector.h"
 #include "QQQDetector.h"
 #include "Target.h"
 #include "Nucleus.h"
@@ -39,15 +39,11 @@ private:
 	static constexpr int s_nSX3PerBarrel = 12;
 	static constexpr int s_nQQQ = 4;
 	static constexpr double s_sx3Length = 0.075;
-	static constexpr double s_sx3Width = 0.04;
 	static constexpr double s_barrelGap = 0.0254;
 	static constexpr double s_sx3FrameGap = 0.049; //0.049 is base gap due to frames
 	static constexpr double s_barrel1Z = s_sx3Length/2.0 + s_sx3FrameGap + s_barrelGap/2.0;
 	static constexpr double s_barrel2Z = (-1.0)*(s_barrelGap/2.0 + s_sx3Length/2.0);
 	static constexpr double s_qqqZ = 0.0125 + s_sx3Length + s_sx3FrameGap + s_barrelGap/2.0;
-	static constexpr double s_qqqInnerR = 0.0501;
-	static constexpr double s_qqqOuterR = 0.0990;
-	static constexpr double s_qqqDeltaPhi = 1.52119;
 	static constexpr double s_qqqZList[4] = {s_qqqZ, s_qqqZ, s_qqqZ, s_qqqZ};
 	static constexpr double s_qqqPhiList[4] = {5.49779, 0.785398, 2.35619, 3.92699};
 	static constexpr double s_barrelRhoList[12] = {0.0890601, 0.0889871, 0.0890354, 0.0890247, 0.0890354, 0.0890354, 0.0890247,
diff --git a/src/Detectors/CMakeLists.txt b/src/Detectors/CMakeLists.txt
index c3c5232..3c949eb 100644
--- a/src/Detectors/CMakeLists.txt
+++ b/src/Detectors/CMakeLists.txt
@@ -16,8 +16,8 @@ target_sources(Detectors PUBLIC
     SabreDetector.h
     SabreEfficiency.cpp
     SabreEfficiency.h
-    StripDetector.cpp
-    StripDetector.h
+    SX3Detector.cpp
+    SX3Detector.h
 )
 
 target_link_libraries(Detectors
diff --git a/src/Detectors/QQQDetector.cpp b/src/Detectors/QQQDetector.cpp
index 11d5155..0f7046a 100644
--- a/src/Detectors/QQQDetector.cpp
+++ b/src/Detectors/QQQDetector.cpp
@@ -1,11 +1,8 @@
 #include "QQQDetector.h"
 
-QQQDetector::QQQDetector(double R_in, double R_out, double deltaPhi, double phiCentral, double z, double x, double y) :
-	m_innerR(R_in), m_outerR(R_out), m_deltaPhi(deltaPhi), m_centralPhi(phiCentral), m_translation(x,y,z), m_norm(0.0,0.0,1.0),
-	m_uniformFraction(0.0, 1.0), m_isSmearing(false)
+QQQDetector::QQQDetector(double phiCentral, double zOffset, double xOffset, double yOffset) :
+	m_centralPhi(phiCentral), m_translation(xOffset,yOffset,zOffset), m_norm(0.0,0.0,1.0), m_uniformFraction(0.0, 1.0), m_isSmearing(false)
 {
-	m_deltaR = (m_outerR - m_innerR)/s_nRings;
-	m_deltaPhiWedge = m_deltaPhi/s_nWedges;
 	m_zRotation.SetAngle(m_centralPhi);
 	m_ringCoords.resize(s_nRings);
 	m_wedgeCoords.resize(s_nWedges);
@@ -28,23 +25,23 @@ void QQQDetector::CalculateCorners()
 	//Generate flat ring corner coordinates
 	for(int i=0; i<s_nRings; i++)
 	{
-		x0 = (m_innerR + m_deltaR*(i+1))*std::cos(-m_deltaPhi/2.0);
-		y0 = (m_innerR + m_deltaR*(i+1))*std::sin(-m_deltaPhi/2.0);
+		x0 = (s_innerR + s_deltaR*(i+1))*std::cos(-s_deltaPhiTotal/2.0);
+		y0 = (s_innerR + s_deltaR*(i+1))*std::sin(-s_deltaPhiTotal/2.0);
 		z0 = 0.0;
 		m_ringCoords[i][0].SetXYZ(x0, y0, z0);
 
-		x1 = (m_innerR + m_deltaR*(i))*std::cos(-m_deltaPhi/2.0);
-		y1 = (m_innerR + m_deltaR*(i))*std::sin(-m_deltaPhi/2.0);
+		x1 = (s_innerR + s_deltaR*(i))*std::cos(-s_deltaPhiTotal/2.0);
+		y1 = (s_innerR + s_deltaR*(i))*std::sin(-s_deltaPhiTotal/2.0);
 		z1 = 0.0;
 		m_ringCoords[i][1].SetXYZ(x1, y1, z1);
 
-		x2 = (m_innerR + m_deltaR*(i))*std::cos(m_deltaPhi/2.0);
-		y2 = (m_innerR + m_deltaR*(i))*std::sin(m_deltaPhi/2.0);
+		x2 = (s_innerR + s_deltaR*(i))*std::cos(s_deltaPhiTotal/2.0);
+		y2 = (s_innerR + s_deltaR*(i))*std::sin(s_deltaPhiTotal/2.0);
 		z2 = 0.0;
 		m_ringCoords[i][2].SetXYZ(x2, y2, z2);
 
-		x3 = (m_innerR + m_deltaR*(i+1))*std::cos(m_deltaPhi/2.0);
-		y3 = (m_innerR + m_deltaR*(i+1))*std::sin(m_deltaPhi/2.0);
+		x3 = (s_innerR + s_deltaR*(i+1))*std::cos(s_deltaPhiTotal/2.0);
+		y3 = (s_innerR + s_deltaR*(i+1))*std::sin(s_deltaPhiTotal/2.0);
 		z3 = 0.0;
 		m_ringCoords[i][3].SetXYZ(x3, y3, z3);
 	}
@@ -52,23 +49,23 @@ void QQQDetector::CalculateCorners()
 	//Generate flat wedge corner coordinates
 	for(int i=0; i<s_nWedges; i++)
 	{
-		x0 = m_outerR * std::cos(-m_deltaPhi/2.0 + i*m_deltaPhiWedge);
-		y0 = m_outerR * std::sin(-m_deltaPhi/2.0 + i*m_deltaPhiWedge);
+		x0 = s_outerR * std::cos(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
+		y0 = s_outerR * std::sin(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
 		z0 = 0.0;
 		m_wedgeCoords[i][0].SetXYZ(x0, y0, z0);
 
-		x1 = m_innerR * std::cos(-m_deltaPhi/2.0 + i*m_deltaPhiWedge);
-		y1 = m_innerR * std::sin(-m_deltaPhi/2.0 + i*m_deltaPhiWedge);
+		x1 = s_innerR * std::cos(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
+		y1 = s_innerR * std::sin(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
 		z1 = 0.0;
 		m_wedgeCoords[i][1].SetXYZ(x1, y1, z1);
 
-		x2 = m_innerR * std::cos(-m_deltaPhi/2.0 + (i+1)*m_deltaPhiWedge);
-		y2 = m_innerR * std::sin(-m_deltaPhi/2.0 + (i+1)*m_deltaPhiWedge);
+		x2 = s_innerR * std::cos(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
+		y2 = s_innerR * std::sin(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
 		z2 = 0.0;
 		m_wedgeCoords[i][2].SetXYZ(x2, y2, z2);
 
-		x3 = m_outerR * std::cos(-m_deltaPhi/2.0 + (i+1)*m_deltaPhiWedge);
-		y3 = m_outerR * std::sin(-m_deltaPhi/2.0 + (i+1)*m_deltaPhiWedge);
+		x3 = s_outerR * std::cos(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
+		y3 = s_outerR * std::sin(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
 		z3 = 0.0;
 		m_wedgeCoords[i][3].SetXYZ(x3, y3, z3);
 	}
@@ -156,13 +153,13 @@ ROOT::Math::XYZPoint QQQDetector::GetHitCoordinates(int ringch, int wedgech)
 	double r_center, phi_center;
 	if(m_isSmearing)
 	{
-		r_center  = m_innerR + (m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator())+ringch)*m_deltaR;
-		phi_center = -m_deltaPhi/2.0 + (m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator())+wedgech)*m_deltaPhiWedge;
+		r_center  = s_innerR + (m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator())+ringch)*s_deltaR;
+		phi_center = -s_deltaPhiTotal/2.0 + (m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator())+wedgech)*s_deltaPhi;
 	}
 	else
 	{
-		r_center  = m_innerR + (0.5+ringch)*m_deltaR;
-		phi_center = -m_deltaPhi/2.0 + (0.5+wedgech)*m_deltaPhiWedge;
+		r_center  = s_innerR + (0.5+ringch)*s_deltaR;
+		phi_center = -s_deltaPhiTotal/2.0 + (0.5+wedgech)*s_deltaPhi;
 	}
 	double x = r_center*std::cos(phi_center);
 	double y = r_center*std::sin(phi_center);
diff --git a/src/Detectors/QQQDetector.h b/src/Detectors/QQQDetector.h
index 9126a3c..e27084a 100644
--- a/src/Detectors/QQQDetector.h
+++ b/src/Detectors/QQQDetector.h
@@ -20,7 +20,7 @@
 class QQQDetector
 {
 public:
-	QQQDetector(double R_in, double R_out, double deltaPhi, double phiCentral, double z, double x=0, double y=0);
+	QQQDetector(double phiCentral, double zOffset, double xOffset=0, double yOffset=0);
 	~QQQDetector();
 	const ROOT::Math::XYZPoint& GetRingCoordinates(int ringch, int corner) { return m_ringCoords[ringch][corner]; }
 	const ROOT::Math::XYZPoint& GetWedgeCoordinates(int wedgech, int corner) { return m_wedgeCoords[wedgech][corner]; }
@@ -42,11 +42,6 @@ private:
 	void CalculateCorners();
 	ROOT::Math::XYZPoint TransformCoordinates(ROOT::Math::XYZPoint& vector) { return m_translation * (m_zRotation * vector) ; }
 
-	double m_innerR;
-	double m_outerR;
-	double m_deltaR;
-	double m_deltaPhi;
-	double m_deltaPhiWedge;
 	double m_centralPhi;
 
 	std::vector<std::vector<ROOT::Math::XYZPoint>> m_ringCoords, m_wedgeCoords;
@@ -60,6 +55,11 @@ private:
 	static constexpr int s_nRings = 16;
 	static constexpr int s_nWedges = 16;
 	static constexpr double s_deg2rad  = M_PI/180.0;
+	static constexpr double s_innerR = 0.0501;
+	static constexpr double s_outerR = 0.0990;
+	static constexpr double s_deltaR = (s_outerR - s_innerR) / s_nRings;
+	static constexpr double s_deltaPhiTotal = 1.52119;
+	static constexpr double s_deltaPhi = s_deltaPhiTotal / s_nWedges;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/Detectors/StripDetector.cpp b/src/Detectors/SX3Detector.cpp
similarity index 70%
rename from src/Detectors/StripDetector.cpp
rename to src/Detectors/SX3Detector.cpp
index 126e90f..47688ae 100644
--- a/src/Detectors/StripDetector.cpp
+++ b/src/Detectors/SX3Detector.cpp
@@ -1,5 +1,4 @@
-#include "StripDetector.h"
-#include <iostream>
+#include "SX3Detector.h"
 
 /*
   Corner layout for each strip in the un-rotated frame
@@ -10,36 +9,22 @@
   |                          |              
   |                          |              x
   2--------------------------3    z<--------X
-																						|
-																						|
-																						|
-																						y
+											|
+											|
+											|
+											y
 */
 
-StripDetector::StripDetector(int ns, double len, double wid, double cphi, double cz, double crho) :
-	m_norm(1.0,0.0,0.0), m_uniformFraction(0.0, 1.0), m_isSmearing(false)
+StripDetector::StripDetector(double centerPhi, double centerZ, double centerRho) :
+	m_centerPhi(centerPhi), m_centerZ(centerZ), m_centerRho(centerRho), m_norm(1.0,0.0,0.0), m_uniformFraction(0.0, 1.0), m_isSmearing(false)
 {
-
-	m_nStrips = ns;
-	
-	m_stripLength = std::fabs(len);
-	m_totalWidth = std::fabs(wid);
-	m_frontStripWidth = m_totalWidth/m_nStrips;
-	m_backStripLength = m_stripLength/m_nStrips;
-
-	while (cphi < 0)
-		cphi += 2*M_PI;
-	m_centerPhi = cphi;
-	m_centerZ   = cz;
-	m_centerRho = std::fabs(crho);
-
 	m_zRotation.SetAngle(m_centerPhi);
 
-	m_frontStripCoords.resize(m_nStrips);
-	m_backStripCoords.resize(m_nStrips);
-	m_rotFrontStripCoords.resize(m_nStrips);
-	m_rotBackStripCoords.resize(m_nStrips);
-	for(int i=0; i<m_nStrips; i++)
+	m_frontStripCoords.resize(s_nStrips);
+	m_backStripCoords.resize(s_nStrips);
+	m_rotFrontStripCoords.resize(s_nStrips);
+	m_rotBackStripCoords.resize(s_nStrips);
+	for(int i=0; i<s_nStrips; i++)
 	{
 		m_frontStripCoords[i].resize(s_nCorners);
 		m_backStripCoords[i].resize(s_nCorners);
@@ -55,28 +40,28 @@ StripDetector::~StripDetector() {}
 void StripDetector::CalculateCorners()
 {
 	double y_min, y_max, z_min, z_max; 
-	for (int s=0; s<m_nStrips; s++)
+	for (int s=0; s<s_nStrips; s++)
 	{
-		y_max = m_totalWidth/2.0 - m_frontStripWidth*s;
-		y_min = m_totalWidth/2.0 - m_frontStripWidth*(s+1);
-		z_max = m_centerZ + m_stripLength/2.0;
-		z_min = m_centerZ - m_stripLength/2.0;
+		y_max = s_totalWidth/2.0 - s_frontStripWidth*s;
+		y_min = s_totalWidth/2.0 - s_frontStripWidth*(s+1);
+		z_max = m_centerZ + s_totalLength/2.0;
+		z_min = m_centerZ - s_totalLength/2.0;
 		m_frontStripCoords[s][2].SetXYZ(m_centerRho, y_max, z_max);
 		m_frontStripCoords[s][3].SetXYZ(m_centerRho, y_max, z_min);
 		m_frontStripCoords[s][0].SetXYZ(m_centerRho, y_min, z_max);
 		m_frontStripCoords[s][1].SetXYZ(m_centerRho, y_min, z_min);
 
-		z_max = (m_centerZ - m_stripLength/2.0) + (s+1)*m_backStripLength;
-		z_min = (m_centerZ - m_stripLength/2.0) + (s)*m_backStripLength;
-		y_max = m_totalWidth/2.0;
-		y_min = -m_totalWidth/2.0;
+		z_max = (m_centerZ - s_totalLength/2.0) + (s+1)*s_backStripLength;
+		z_min = (m_centerZ - s_totalLength/2.0) + (s)*s_backStripLength;
+		y_max = s_totalWidth/2.0;
+		y_min = -s_totalWidth/2.0;
 		m_backStripCoords[s][2].SetXYZ(m_centerRho, y_max, z_max);
 		m_backStripCoords[s][3].SetXYZ(m_centerRho, y_max, z_min);
 		m_backStripCoords[s][0].SetXYZ(m_centerRho, y_min, z_max);
 		m_backStripCoords[s][1].SetXYZ(m_centerRho, y_min, z_min);
 	}
 
-	for(int s=0; s<m_nStrips; s++)
+	for(int s=0; s<s_nStrips; s++)
 	{
 		m_rotFrontStripCoords[s][0] = m_zRotation*m_frontStripCoords[s][0];
 		m_rotFrontStripCoords[s][1] = m_zRotation*m_frontStripCoords[s][1];
@@ -98,12 +83,12 @@ ROOT::Math::XYZPoint StripDetector::GetHitCoordinates(int front_stripch, double
 
 	double y;
 	if(m_isSmearing)
-		y = -m_totalWidth/2.0 + (front_stripch + m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator()))*m_frontStripWidth;
+		y = -s_totalWidth/2.0 + (front_stripch + m_uniformFraction(Mask::RandomGenerator::GetInstance().GetGenerator()))*s_frontStripWidth;
 	else
-		y = -m_totalWidth/2.0 + (front_stripch+0.5)*m_frontStripWidth;
+		y = -s_totalWidth/2.0 + (front_stripch+0.5)*s_frontStripWidth;
 
 	//recall we're still assuming phi=0 det:
-	ROOT::Math::XYZPoint coords(m_centerRho, y, front_strip_ratio*(m_stripLength/2) + m_centerZ);
+	ROOT::Math::XYZPoint coords(m_centerRho, y, front_strip_ratio*(s_totalLength/2) + m_centerZ);
   
 	//NOW rotate by appropriate phi
 	return m_zRotation*coords;
@@ -125,7 +110,7 @@ StripHit StripDetector::GetChannelRatio(double theta, double phi)
 		phi -= 2*M_PI;
 
 	//then we can check easily whether it even hit the detector in phi
-	double det_max_phi = std::atan2(m_totalWidth/2,m_centerRho);
+	double det_max_phi = std::atan2(s_totalWidth/2,m_centerRho);
 	double det_min_phi = -det_max_phi;
   
 	if (phi < det_min_phi || phi > det_max_phi)
@@ -138,18 +123,18 @@ StripHit StripDetector::GetChannelRatio(double theta, double phi)
 	double yhit = xhit*tan(phi);
 	double zhit = sqrt(xhit*xhit+yhit*yhit)/tan(theta);
 
-	for (int s=0; s<m_nStrips; s++) {
+	for (int s=0; s<s_nStrips; s++) {
 		if (xhit >=m_frontStripCoords[s][0].X() && xhit <=m_frontStripCoords[s][0].X() && //Check min and max x (constant in flat)
 			yhit >=m_frontStripCoords[s][1].Y() && yhit <=m_frontStripCoords[s][2].Y() && //Check min and max y
 			zhit >=m_frontStripCoords[s][1].Z() && zhit <=m_frontStripCoords[s][0].Z()) //Check min and max z
 		{
 			hit.front_strip_index = s;
-			hit.front_ratio = (zhit-m_centerZ)/(m_stripLength/2);
+			hit.front_ratio = (zhit-m_centerZ)/(s_totalLength/2);
 			break;
 		}
 	}
 
-	for (int s=0; s<m_nStrips; s++) {
+	for (int s=0; s<s_nStrips; s++) {
 		if (xhit >= m_backStripCoords[s][0].X() && xhit <= m_backStripCoords[s][0].X() && //Check min and max x (constant in flat)
 			yhit >= m_backStripCoords[s][1].Y() && yhit <= m_backStripCoords[s][2].Y() && //Check min and max y
 			zhit >= m_backStripCoords[s][1].Z() && zhit <= m_backStripCoords[s][0].Z()) //Check min and max z
diff --git a/src/Detectors/StripDetector.h b/src/Detectors/SX3Detector.h
similarity index 76%
rename from src/Detectors/StripDetector.h
rename to src/Detectors/SX3Detector.h
index cc6463a..965e488 100644
--- a/src/Detectors/StripDetector.h
+++ b/src/Detectors/SX3Detector.h
@@ -1,5 +1,5 @@
-#ifndef STRIP_DETECTOR_H
-#define STRIP_DETECTOR_H
+#ifndef SX3_DETECTOR_H
+#define SX3_DETECTOR_H
 
 // +z is along beam axis
 // +y is vertically "downward" in the lab frame
@@ -30,7 +30,7 @@ class StripDetector
 {
 public:
   
-	StripDetector(int ns, double len, double wid, double cphi, double cz, double crho);
+	StripDetector(double centerPhi, double centerZ, double centerRho);
 	~StripDetector();
 	const ROOT::Math::XYZPoint& GetFrontStripCoordinates(int stripch, int corner) const { return m_frontStripCoords[stripch][corner]; }
 	const ROOT::Math::XYZPoint& GetBackStripCoordinates(int stripch, int corner) const { return m_backStripCoords[stripch][corner]; }
@@ -50,18 +50,10 @@ public:
 	StripHit GetChannelRatio(double theta, double phi);
 
 private:
-	bool ValidChannel(int f) { return ((f >= 0 && f < m_nStrips) ? true : false); };
+	bool ValidChannel(int f) { return ((f >= 0 && f < s_nStrips) ? true : false); };
 	bool ValidRatio(double r) { return ((r >= -1 && r <= 1) ? true : false); };
 	void CalculateCorners();
 
-	int m_nStrips;
-	static constexpr int s_nCorners = 4;
-
-	double m_stripLength; //common to all strips, hence total
-	double m_totalWidth;
-	double m_frontStripWidth; //assuming equal widths
-	double m_backStripLength; //assuming equal widths
-
 	double m_centerPhi; //assuming det centered above x-axis (corresponds to zero phi)
 	double m_centerZ;
 	double m_centerRho; //perpendicular radius from axis
@@ -77,6 +69,15 @@ private:
 
 	bool m_isSmearing;
 
+	//Units in meters
+	static constexpr double s_nStrips = 4; //Same for front and back
+	static constexpr double s_nCorners = 4;
+	static constexpr double s_totalLength = 0.075; //length of front strips
+	static constexpr double s_backStripLength = s_totalLength / s_nStrips;
+	static constexpr double s_totalWidth = 0.04; //width of back strips
+	static constexpr double s_frontStripWidth = s_totalWidth / s_nStrips;
+	static constexpr double s_deg2rad = M_PI/180.0;
+
 };
 
 #endif
diff --git a/src/Detectors/SabreDetector.cpp b/src/Detectors/SabreDetector.cpp
index 9d9da27..cf143ee 100644
--- a/src/Detectors/SabreDetector.cpp
+++ b/src/Detectors/SabreDetector.cpp
@@ -53,8 +53,7 @@
 #include "SabreDetector.h"
 
 SabreDetector::SabreDetector() :
-m_outerR(0.1351), m_innerR(0.0326), m_deltaPhiFlat(54.4*s_deg2rad), m_centerPhi(0.0), m_tilt(0.0), 
-	m_translation(0.,0.,0.), m_norm(0,0,1.0), m_detectorID(-1)
+m_centerPhi(0.0), m_tilt(0.0), m_translation(0.,0.,0.), m_norm(0,0,1.0), m_detectorID(-1)
 {
 	m_yRotation.SetAngle(m_tilt);
 	m_zRotation.SetAngle(m_centerPhi);
@@ -73,17 +72,11 @@ m_outerR(0.1351), m_innerR(0.0326), m_deltaPhiFlat(54.4*s_deg2rad), m_centerPhi(
 		m_tiltWedgeCoords[i].resize(4);
 	}
 
-	m_deltaRFlat = m_outerR - m_innerR;
-	m_deltaRFlatRing = m_deltaRFlat/s_nRings;
-	m_deltaPhiFlatWedge = m_deltaPhiFlat/s_nWedges;
-
 	CalculateCorners();
 }
 
-SabreDetector::SabreDetector(int detID, double Rin, double Rout, double deltaPhi_flat, double phiCentral, 
-							 double tiltFromVert, double zdist, double xdist, double ydist) :
-	m_outerR(Rout), m_innerR(Rin), m_deltaPhiFlat(deltaPhi_flat), m_centerPhi(phiCentral), m_tilt(tiltFromVert), 
-	m_translation(xdist, ydist, zdist), m_norm(0,0,1.0), m_detectorID(detID)
+SabreDetector::SabreDetector(int detID, double phiCentral, double tiltFromVert, double zdist, double xdist, double ydist) :
+	m_centerPhi(phiCentral), m_tilt(tiltFromVert), m_translation(xdist, ydist, zdist), m_norm(0,0,1.0), m_detectorID(detID)
 {
 	m_yRotation.SetAngle(m_tilt);
 	m_zRotation.SetAngle(m_centerPhi);
@@ -104,10 +97,6 @@ SabreDetector::SabreDetector(int detID, double Rin, double Rout, double deltaPhi
 		m_tiltWedgeCoords[i].resize(4);
 	}
 
-	m_deltaRFlat = m_outerR - m_innerR;
-	m_deltaRFlatRing = m_deltaRFlat/s_nRings;
-	m_deltaPhiFlatWedge = m_deltaPhiFlat/s_nWedges;
-
 	CalculateCorners();
 }
 
@@ -123,23 +112,23 @@ void SabreDetector::CalculateCorners()
 	//Generate flat ring corner coordinates
 	for(int i=0; i<s_nRings; i++)
 	{
-		x0 = (m_innerR + m_deltaRFlatRing*(i+1))*std::cos(-m_deltaPhiFlat/2.0);
-		y0 = (m_innerR + m_deltaRFlatRing*(i+1))*std::sin(-m_deltaPhiFlat/2.0);
+		x0 = (s_innerR + s_deltaR*(i+1))*std::cos(-s_deltaPhiTotal/2.0);
+		y0 = (s_innerR + s_deltaR*(i+1))*std::sin(-s_deltaPhiTotal/2.0);
 		z0 = 0.0;
 		m_flatRingCoords[i][0].SetXYZ(x0, y0, z0);
 
-		x1 = (m_innerR + m_deltaRFlatRing*(i))*std::cos(-m_deltaPhiFlat/2.0);
-		y1 = (m_innerR + m_deltaRFlatRing*(i))*std::sin(-m_deltaPhiFlat/2.0);
+		x1 = (s_innerR + s_deltaR*(i))*std::cos(-s_deltaPhiTotal/2.0);
+		y1 = (s_innerR + s_deltaR*(i))*std::sin(-s_deltaPhiTotal/2.0);
 		z1 = 0.0;
 		m_flatRingCoords[i][1].SetXYZ(x1, y1, z1);
 
-		x2 = (m_innerR + m_deltaRFlatRing*(i))*std::cos(m_deltaPhiFlat/2.0);
-		y2 = (m_innerR + m_deltaRFlatRing*(i))*std::sin(m_deltaPhiFlat/2.0);
+		x2 = (s_innerR + s_deltaR*(i))*std::cos(s_deltaPhiTotal/2.0);
+		y2 = (s_innerR + s_deltaR*(i))*std::sin(s_deltaPhiTotal/2.0);
 		z2 = 0.0;
 		m_flatRingCoords[i][2].SetXYZ(x2, y2, z2);
 
-		x3 = (m_innerR + m_deltaRFlatRing*(i+1))*std::cos(m_deltaPhiFlat/2.0);
-		y3 = (m_innerR + m_deltaRFlatRing*(i+1))*std::sin(m_deltaPhiFlat/2.0);
+		x3 = (s_innerR + s_deltaR*(i+1))*std::cos(s_deltaPhiTotal/2.0);
+		y3 = (s_innerR + s_deltaR*(i+1))*std::sin(s_deltaPhiTotal/2.0);
 		z3 = 0.0;
 		m_flatRingCoords[i][3].SetXYZ(x3, y3, z3);
 	}
@@ -147,23 +136,23 @@ void SabreDetector::CalculateCorners()
 	//Generate flat wedge corner coordinates
 	for(int i=0; i<s_nWedges; i++)
 	{
-		x0 = m_outerR * std::cos(-m_deltaPhiFlat/2.0 + i*m_deltaPhiFlatWedge);
-		y0 = m_outerR * std::sin(-m_deltaPhiFlat/2.0 + i*m_deltaPhiFlatWedge);
+		x0 = s_outerR * std::cos(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
+		y0 = s_outerR * std::sin(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
 		z0 = 0.0;
 		m_flatWedgeCoords[i][0].SetXYZ(x0, y0, z0);
 
-		x1 = m_innerR * std::cos(-m_deltaPhiFlat/2.0 + i*m_deltaPhiFlatWedge);
-		y1 = m_innerR * std::sin(-m_deltaPhiFlat/2.0 + i*m_deltaPhiFlatWedge);
+		x1 = s_innerR * std::cos(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
+		y1 = s_innerR * std::sin(-s_deltaPhiTotal/2.0 + i*s_deltaPhi);
 		z1 = 0.0;
 		m_flatWedgeCoords[i][1].SetXYZ(x1, y1, z1);
 
-		x2 = m_innerR * std::cos(-m_deltaPhiFlat/2.0 + (i+1)*m_deltaPhiFlatWedge);
-		y2 = m_innerR * std::sin(-m_deltaPhiFlat/2.0 + (i+1)*m_deltaPhiFlatWedge);
+		x2 = s_innerR * std::cos(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
+		y2 = s_innerR * std::sin(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
 		z2 = 0.0;
 		m_flatWedgeCoords[i][2].SetXYZ(x2, y2, z2);
 
-		x3 = m_outerR * std::cos(-m_deltaPhiFlat/2.0 + (i+1)*m_deltaPhiFlatWedge);
-		y3 = m_outerR * std::sin(-m_deltaPhiFlat/2.0 + (i+1)*m_deltaPhiFlatWedge);
+		x3 = s_outerR * std::cos(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
+		y3 = s_outerR * std::sin(-s_deltaPhiTotal/2.0 + (i+1)*s_deltaPhi);
 		z3 = 0.0;
 		m_flatWedgeCoords[i][3].SetXYZ(x3, y3, z3);
 	}
@@ -322,8 +311,8 @@ ROOT::Math::XYZPoint SabreDetector::GetHitCoordinates(int ringch, int wedgech)
 	if(!CheckRingChannel(ringch) || !CheckWedgeChannel(wedgech))
 		return ROOT::Math::XYZPoint();
 
-	double r_center  = m_innerR + (0.5+ringch)*m_deltaRFlatRing;
-	double phi_center = -m_deltaPhiFlat/2.0 + (0.5+wedgech)*m_deltaPhiFlatWedge;
+	double r_center  = s_innerR + (0.5+ringch)*s_deltaR;
+	double phi_center = -s_deltaPhiTotal/2.0 + (0.5+wedgech)*s_deltaPhi;
 	double x = r_center*std::cos(phi_center);
 	double y = r_center*std::sin(phi_center);
 	double z = 0;
diff --git a/src/Detectors/SabreDetector.h b/src/Detectors/SabreDetector.h
index b9b1d23..b0cde5c 100644
--- a/src/Detectors/SabreDetector.h
+++ b/src/Detectors/SabreDetector.h
@@ -65,7 +65,7 @@ class SabreDetector {
 public:
 
 	SabreDetector();
-	SabreDetector(int detID, double Rin, double Rout, double deltaPhi_flat, double phiCentral, double tiltFromVert, double zdist, double xdist=0, double ydist=0);
+	SabreDetector(int detID, double phiCentral, double tiltFromVert, double zdist, double xdist=0, double ydist=0);
 	~SabreDetector();
 
 	/*Return coordinates of the corners of each ring/wedge in SABRE*/
@@ -84,9 +84,6 @@ public:
 	int GetDetectorID() { return m_detectorID; }
 
 private:
-
-	
-
 	void CalculateCorners();
 
 	/*Performs the transformation to the tilted,rotated,translated frame of the SABRE detector*/
@@ -109,9 +106,9 @@ private:
 	/*Determine if a hit is within the bulk detector*/
 	bool IsInside(double r, double phi)
 	{ 
-		double phi_1 = m_deltaPhiFlat/2.0;
-		double phi_2 = M_PI*2.0 - m_deltaPhiFlat/2.0;
-		return (((r > m_innerR && r < m_outerR) || CheckPositionEqual(r, m_innerR) || CheckPositionEqual(r, m_outerR)) 
+		double phi_1 = s_deltaPhiTotal/2.0;
+		double phi_2 = M_PI*2.0 - s_deltaPhiTotal/2.0;
+		return (((r > s_innerR && r < s_outerR) || CheckPositionEqual(r, s_innerR) || CheckPositionEqual(r, s_outerR)) 
 				&& (phi > phi_2 || phi < phi_1 || CheckAngleEqual(phi, phi_1) || CheckAngleEqual(phi, phi_2)));
 	};
 
@@ -121,57 +118,43 @@ private:
 	*/
 	bool IsRing(double r, int ringch)
 	{
-		double ringtop = m_innerR + m_deltaRFlatRing*(ringch + 1);
-		double ringbottom = m_innerR + m_deltaRFlatRing*(ringch);
+		double ringtop = s_innerR + s_deltaR*(ringch + 1);
+		double ringbottom = s_innerR + s_deltaR*(ringch);
 		return (r>ringbottom && r<ringtop); 
 	};
 
 	inline bool IsRingTopEdge(double r, int ringch)
 	{
-		double ringtop = m_innerR + m_deltaRFlatRing*(ringch + 1);
+		double ringtop = s_innerR + s_deltaR*(ringch + 1);
 		return CheckPositionEqual(r, ringtop); 
 	};
 
 	inline bool IsRingBottomEdge(double r, int ringch)
 	{
-		double ringbottom = m_innerR + m_deltaRFlatRing*(ringch);
+		double ringbottom = s_innerR + s_deltaR*(ringch);
 		return CheckPositionEqual(r, ringbottom); 
 	};
 
 	inline bool IsWedge(double phi, int wedgech)
 	{
-		double wedgetop = -m_deltaPhiFlat/2.0 + m_deltaPhiFlatWedge*(wedgech+1);
-		double wedgebottom = -m_deltaPhiFlat/2.0 + m_deltaPhiFlatWedge*(wedgech);
+		double wedgetop = -s_deltaPhiTotal/2.0 + s_deltaPhi*(wedgech+1);
+		double wedgebottom = -s_deltaPhiTotal/2.0 + s_deltaPhi*(wedgech);
 		return ((phi>wedgebottom && phi<wedgetop));
 	};
 
 	inline bool IsWedgeTopEdge(double phi, int wedgech)
 	{
-		double wedgetop = -m_deltaPhiFlat/2.0 + m_deltaPhiFlatWedge*(wedgech+1);
+		double wedgetop = -s_deltaPhiTotal/2.0 + s_deltaPhi*(wedgech+1);
 		return CheckAngleEqual(phi, wedgetop);
 	}
 
 	inline bool IsWedgeBottomEdge(double phi, int wedgech)
 	{
-		double wedgebottom = -m_deltaPhiFlat/2.0 + m_deltaPhiFlatWedge*(wedgech);
+		double wedgebottom = -s_deltaPhiTotal/2.0 + s_deltaPhi*(wedgech);
 		return CheckAngleEqual(phi, wedgebottom);
 	}
 
-	/*Class constants*/
-	static constexpr int s_nRings = 16;
-	static constexpr int s_nWedges = 8;
-	static constexpr double s_deg2rad = M_PI/180.0;
-	/*These are implicitly the width of the spacing between detector active strips*/
-	static constexpr double s_positionTol = 0.0001; //0.1 mm position tolerance
-	static constexpr double s_angularTol = 0.1*M_PI/180.0; // 0.1 degree angular tolerance
-
 	/*Class data*/
-	double m_outerR;
-	double m_innerR;
-	double m_deltaRFlat;
-	double m_deltaRFlatRing;
-	double m_deltaPhiFlat;
-	double m_deltaPhiFlatWedge;
 	double m_centerPhi;
 	double m_tilt;
 	ROOT::Math::Translation3D m_translation;
@@ -183,6 +166,18 @@ private:
 	std::vector<std::vector<ROOT::Math::XYZPoint>> m_flatRingCoords, m_flatWedgeCoords;
 	std::vector<std::vector<ROOT::Math::XYZPoint>> m_tiltRingCoords, m_tiltWedgeCoords;
 
+	/*Class constants*/
+	static constexpr double s_deg2rad = M_PI/180.0;
+	static constexpr int s_nRings = 16;
+	static constexpr int s_nWedges = 8;
+	static constexpr double s_outerR = 0.1351;
+	static constexpr double s_innerR = 0.0326;
+	static constexpr double s_deltaR = (s_outerR - s_innerR) / s_nRings;
+	static constexpr double s_deltaPhiTotal = 54.4 * s_deg2rad;
+	static constexpr double s_deltaPhi = (s_deltaPhiTotal / s_nWedges);
+	/*These are implicitly the width of the spacing between detector active strips*/
+	static constexpr double s_positionTol = 0.0001; //0.1 mm position tolerance
+	static constexpr double s_angularTol = 0.1*M_PI/180.0; // 0.1 degree angular tolerance
 };
 
 
diff --git a/src/Detectors/SabreEfficiency.cpp b/src/Detectors/SabreEfficiency.cpp
index 5d0a7b2..0ce0619 100644
--- a/src/Detectors/SabreEfficiency.cpp
+++ b/src/Detectors/SabreEfficiency.cpp
@@ -13,7 +13,7 @@ SabreEfficiency::SabreEfficiency() :
 {
 
 	for(int i=0; i<s_nDets; i++)
-		m_detectors.emplace_back(i, s_innerR, s_outerR, s_deltaPhi*s_deg2rad, s_centerPhiList[i]*s_deg2rad, s_tilt*s_deg2rad, s_zOffset);
+		m_detectors.emplace_back(i, s_centerPhiList[i]*s_deg2rad, s_tilt*s_deg2rad, s_zOffset);
 	//Only 0, 1, 4 valid in degrader land
 	m_degradedDetectors[0] = true;
 	m_degradedDetectors[1] = true;
diff --git a/src/Detectors/SabreEfficiency.h b/src/Detectors/SabreEfficiency.h
index 193f0f9..7c43fb5 100644
--- a/src/Detectors/SabreEfficiency.h
+++ b/src/Detectors/SabreEfficiency.h
@@ -32,11 +32,8 @@ private:
     bool m_degradedDetectors[5];
 
 	//Sabre constants
-	static constexpr double s_innerR = 0.0326;
-    static constexpr double s_outerR = 0.1351;
     static constexpr double s_tilt = 40.0;
     static constexpr double s_zOffset = -0.1245;
-    static constexpr double s_deltaPhi = 54.4; //delta phi for each det
     static constexpr int s_nDets = 5;
     static constexpr double s_centerPhiList[s_nDets] = {306.0, 18.0, 234.0, 162.0, 90.0};
     static constexpr double s_deg2rad = M_PI/180.0;