catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/clib_build/src/analytic_projector.h

@@ -0,0 +1,235 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifndef __YYcode_h__
+#define __YYcode_h__
+
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#define MIN(a,b) (((a) > (b)) ? (b) : (a))
+#define VERY_BIG 1e300
+#define MATERIAL_INDEX_BASIS 1  //can be 1 or zero
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdarg.h>
+#include <pthread.h>
+#include <unistd.h>
+
+// Global Variable Definitions /////////////
+
+int COMPARISON_NUMBER = 0;
+
+//Parameters for Accurate Detector Model, Mingye
+int Accurate_Detector_Model_is_ON = 0;
+int n_col_oversample = 1;
+int n_row_oversample = 1;
+int n_col_oversample_add_xtalk = 1;
+int n_row_oversample_add_xtalk = 1;
+
+struct module_info
+{
+  double *Height;
+  double *Width;
+  int *Pix;
+  double *Coords;
+  int *Sub;
+  double *Sampling;
+  double *Weight;
+  double *sourceWeights;
+  int nSubSources;
+  int maxPixPerModule;
+  int maxSubDets;
+  int moduleOverlapType;
+};
+
+struct module_info modules = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,0,0,0,0};
+
+struct pnt
+{
+  double x;
+  double y;
+  double tan_angle;
+  int index;
+};
+
+struct bounding_info
+{
+  int *vertexStartIndex;
+  double *vertexLocations;
+};
+
+struct bounding_info bounding = {NULL,NULL};
+
+struct phantom_info
+{
+  int numObjects;
+  int *objectType;
+  double *objectCenter;
+  double *shape;
+  double *Qmatrix;
+  int *clipStartIndex;
+  double *clipNormalVector;
+  double *clipDistance;
+  int *nClipPlanes;
+  double *density;
+  int *materialInd;
+  double xbounds[2];
+};
+
+struct phantom_info phantom = {0,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,{0,0}};
+
+struct material_info
+{
+  int materialCount;
+  int eBinCount;
+  double *muTable;
+};
+
+struct material_info materials = {0,0,NULL};
+
+struct projector_args
+{
+  double *Paras; //parameters for Accurate Detector Model, Mingye
+  double subviewWeight;
+  double *thisView;
+  double *sourcePoints;
+  int nSubSources;
+  double *srcHullPoints;
+  int nSrcHullPoints;
+  int *firstDetIndex;
+  int nModulesIn;
+  int *modTypeInds;
+  double *Up;
+  double *Right;
+  double *Center;
+  int UNUSED_tvLength;  
+};
+
+struct height_lims
+{
+  double min;
+  double max;
+};
+
+struct box_lims
+{
+  double minR;
+  double maxR;
+  double minU;
+  double maxU;
+};
+
+double limitLoadAverage = 0;
+int nextModuleInQ;
+int modulesInQ;
+pthread_mutex_t QLock = PTHREAD_MUTEX_INITIALIZER;
+int thread_count;
+pthread_t *t_id = NULL;
+
+static int debug_flag = 1;
+
+struct indexed_list
+{
+  double value;
+  double originalIndex;
+};
+
+//////////////////////////////////////////////
+
+static void dbug(int level,const char *s,...);
+
+double solve_cubic(double *a);
+    
+void cross(double *vec1, double *vec2, double *vecOut);
+
+double magnitude(double r, double i);
+
+void sqrtm(double in_r,double in_i,double *out_r,double *out_i);
+
+void complex_multiply(double r1, double i1, double r2, double i2,double *real_out, double *imag_out);
+
+void solve_cubic_all(double *a,double *zr,double *zi);
+
+int compare_doubles (const void *a, const void *b);
+
+int compIL (const void *a, const void *b);
+
+int solve_quartic2(double *a,double *z);
+
+int solve_quartic(double *a,double *z);
+
+double quadratic_form(double *vec1,double *matrix, double *vec2);
+
+int quartic_intersect(double *a0,double *alpha,double *tc,int obj);
+
+int clip_all(double *a,double *alpha,double rayLength,double *tc2,int out,double *st_list,double *en_list,double *den_list,int *pri_list,int *mat_list,int num_int,int i);
+
+int quadratic_intersect(double *a0,double *alpha,int pars11,double *tc2,int obj);
+
+int* my_memcpyi(int *src, int *dest, int bytes);
+
+double* my_memcpyd(double *src, double *dest, int bytes);
+
+void set_module_info(double *Height, double *Width, int *Pix, double *Coords, int *Sub, double *Sampling, double *Weight, int nModuleTypes, int maxPix, int maxSubDets, int moduleOverlapType, double *sourceWeights, int nSubSources);
+
+void set_bounding_info(int numObjs, int *vertexStartInd, double *vertLocs, int numVerts);
+
+void set_phantom_info(int numObjs, int *objType, int *clipStInd, int *nPlanes, int *matInd, double *objCent, double *shp, double *Qmat, double *clipNormVec, double *clipDist, double *den, int totalNumPlanes);
+
+void set_material_info(int materialCount, int eBinCount, double *muTable);
+
+void intersections_full_list(int *objlist, int lenObjList,double *a,double *alpha,double rayLength,double *t_ends,int *matls,double *dens,int *num_segs);
+
+void make_vol(float *volume, int Nx, double xoff, double dx, int Ny, double yoff, double dy, int Nz, double zoff, double dz, int oversampling);
+
+void intersections(int *objlist,int lenObjList,double *a,double *alpha,double rayLength,double *mb);
+
+int compare_pts (const void *a, const void *b);
+
+int compute_convex_hull_2d(double* x,double* y,int pts,int* list);
+
+void crop_polygon_FMtest(double *x, double *y, int *indexList, int *listLength, double height, double width, int projPoints);
+
+void crop_polygon(double *x, double *y, int *indexList, int *listLength, double height, double width, int projPoints);
+
+void store_height_lims(double *pixel_U, int *indexList, int listLength, int objectNumber, void *boundaries);
+
+void store_half_planes(double *pixel_R, double *pixel_U, int *indexList, int listLength, int objectNumber, void *boundaries);
+
+void store(double *pixel_R, double *pixel_U, int *indexList, int listLength, int objectNumber, void *boundaries);
+
+void compute_object_projections(double *srcHullPoints, int nSrcHullPoints, int moduleTypeIndex, double *up, double *right, double *center, void *boundaries);
+
+int any_objects_1(int moduleNumber, void *boundaries);
+
+int any_objects_2(int moduleNumber, void *boundaries);
+
+void build_object_list1(double *pix_vlims, int *objectList, int *n_objlist, int moduleNumber, double v, void *boundaries);
+
+void build_object_list2(double *pix_vlims, double *pix_ulims, int *objectList, int *n_objlist, int moduleNumber, double *uv, void *boundaries);
+
+void build_object_list3();
+
+void intersections_loop(double *detCenter, double *right, double *up, double *sampling, int nSubDets, double *sourcePoints, int *objectList, int nListObjects, double *thisView, int detIndex, double subviewWeight, double *detWeights);
+
+void set_Accurate_Detector_Model(double *Paras); //Set parameters for Accurate Detector Model, Mingye
+
+void Projector(double *Paras, double subviewWeight, double *thisView, double *sourcePoints, int nSubSources, double *srcHullPoints, int nSrcHullPoints, int *firstDetIndex, int nModulesIn, int *modTypeInds, double *Up, double *Right, double *Center, int UNUSED_tvLength);
+
+void *projector_wrapper(void *pointerIn);
+
+void Projector_threaded(double *Paras, double subviewWeight, double *thisView, double *sourcePoints, int nSubSources, double *srcHullPoints, int nSrcHullPoints, int *firstDetIndex, int nModulesIn, int *modTypeInds, double *Up, double *Right, double *Center, int UNUSED_tvLength, int numThreads, double maxLoadAverage);
+
+void diff(double *d1,double *d2,int len);
+
+void CO(double *c_values);
+
+void COf(float *c_values);
+
+void COi(int *c_values);
+
+void COs(short *c_values);
+
+#endif
+

gecatsim/clib_build/src/compt.cpp

@@ -0,0 +1,400 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include <iostream>
+#include <math.h>
+
+int AirPhotons;
+int PrimaryPhotons;
+int PhotoE;
+int InteractionCount;
+
+float MuAbsorption[75] = {4.08E+03,6.16E+02,1.92E+02,8.21E+01,4.20E+01,2.42E+01,1.51E+01,1.01E+01,7.03E+00,5.10E+00,3.82E+00,2.95E+00,2.32E+00,1.87E+00,1.54E+00,1.29E+00,1.09E+00,9.39E-01,8.18E-01,7.21E-01,6.43E-01,5.79E-01,5.26E-01,4.82E-01,4.45E-01,4.14E-01,3.88E-01,3.65E-01,3.45E-01,3.29E-01,3.14E-01,3.01E-01,2.90E-01,2.80E-01,2.71E-01,2.63E-01,2.56E-01,2.50E-01,2.45E-01,2.40E-01,2.35E-01,2.31E-01,2.27E-01,2.23E-01,2.20E-01,2.17E-01,2.15E-01,2.12E-01,2.10E-01,2.08E-01,2.06E-01,2.04E-01,2.02E-01,2.00E-01,1.99E-01,1.97E-01,1.96E-01,1.94E-01,1.93E-01,1.92E-01,1.91E-01,1.90E-01,1.89E-01,1.88E-01,1.87E-01,1.86E-01,1.85E-01,1.84E-01,1.83E-01,1.82E-01,1.82E-01,1.81E-01,1.80E-01,1.79E-01,1.79E-01};
+
+float MuPhotoElectric[75] = {4.08E+03,6.16E+02,1.92E+02,8.20E+01,4.19E+01,2.41E+01,1.50E+01,9.92E+00,6.88E+00,4.94E+00,3.66E+00,2.78E+00,2.16E+00,1.71E+00,1.37E+00,1.11E+00,9.17E-01,7.64E-01,6.42E-01,5.44E-01,4.65E-01,4.00E-01,3.46E-01,3.01E-01,2.64E-01,2.32E-01,2.06E-01,1.83E-01,1.63E-01,1.46E-01,1.31E-01,1.18E-01,1.07E-01,9.68E-02,8.80E-02,8.03E-02,7.34E-02,6.72E-02,6.17E-02,5.68E-02,5.24E-02,4.84E-02,4.48E-02,4.15E-02,3.86E-02,3.59E-02,3.34E-02,3.12E-02,2.91E-02,2.72E-02,2.55E-02,2.39E-02,2.25E-02,2.11E-02,1.99E-02,1.87E-02,1.77E-02,1.67E-02,1.58E-02,1.49E-02,1.41E-02,1.34E-02,1.27E-02,1.21E-02,1.15E-02,1.09E-02,1.04E-02,9.87E-03,9.41E-03,8.97E-03,8.56E-03,8.17E-03,7.81E-03,7.46E-03,7.14E-03};
+
+float MuCompton[75] = {1.32E-02,4.18E-02,7.07E-02,9.43E-02,1.12E-01,1.26E-01,1.36E-01,1.44E-01,1.50E-01,1.55E-01,1.59E-01,1.62E-01,1.65E-01,1.68E-01,1.70E-01,1.72E-01,1.73E-01,1.75E-01,1.76E-01,1.77E-01,1.78E-01,1.79E-01,1.80E-01,1.81E-01,1.81E-01,1.82E-01,1.82E-01,1.82E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.83E-01,1.82E-01,1.82E-01,1.82E-01,1.82E-01,1.81E-01,1.81E-01,1.81E-01,1.81E-01,1.80E-01,1.80E-01,1.80E-01,1.79E-01,1.79E-01,1.79E-01,1.78E-01,1.78E-01,1.78E-01,1.77E-01,1.77E-01,1.77E-01,1.76E-01,1.76E-01,1.76E-01,1.75E-01,1.75E-01,1.75E-01,1.74E-01,1.74E-01,1.73E-01,1.73E-01,1.73E-01,1.72E-01,1.72E-01,1.72E-01};
+
+// Simple program to compute the scatter off a water cylinder...
+float ShimDistance;
+
+// Return a sample from the Klein Nishina cross-section...  
+// Input energy is in KeV
+float SampleKleinNishina(float Ein) {
+  // Convert the input energy from KeV to rest mass energies.
+  float E = Ein/511;
+  float R;
+  bool accept = false;
+  while (!accept) {
+    // Generate 3 random numbers
+    float v1 = drand48();
+    float v2 = drand48();
+    float v3 = drand48();
+    if (v1 > (1+2*E)/(9+2*E)) {
+      R = (1+2*E)/(1+2*v2*E);
+      float t = (1-R)/E+1;
+      accept = !(v3 > 0.5*(t*t+1/R));
+    } else {
+      R = (1+2*v2*E);
+      accept = !(v3 > 4/R*(1-1/R));
+    }
+  }
+  float Eout = Ein/R;
+  return Eout;
+}
+
+// Given the input and output energies in KeV, calculate the change
+// in polar angle given by
+//  cos theta = 1-(1/Eout - 1/Ein)*511
+float GetScatterPolarAngleCosine(float Ein, float Eout) {
+  float costheta = 1-(1/Eout - 1/Ein)*511;
+  return costheta;
+}
+
+float GetScatterRadialAngle() {
+  return (float)(2*M_PI*drand48());
+}
+
+float GetMuScatter(float E) {
+  return MuCompton[(int) E];
+}
+
+float GetMuPhotoElectric(float E) {
+  return MuPhotoElectric[(int) E];
+}
+
+float GetMuAbsorption(float E) {
+  return MuAbsorption[(int) E];
+}
+
+float GetMeanFreePathLength(float Ein) {
+  return 10.0/MuAbsorption[(int) Ein];
+}
+
+class Vec3 {
+public:
+  float x;
+  float y;
+  float z;
+  void Normalize();
+  Vec3() : x(0), y(0), z(0) {};
+  Vec3(float a, float b, float c) : x(a), y(b), z(c) {};
+  void Print(std::ostream& o);
+};
+
+std::ostream& operator<<(std::ostream& o, Vec3& v) {
+  v.Print(o);
+}
+
+void Vec3::Print(std::ostream& o) {
+  o << "<" << x << "," << y << "," << z << ">";
+}
+
+void Vec3::Normalize() {
+  float t = x*x + y*y + z*z;
+  t = 1/sqrt(t);
+  x *= t;
+  y *= t;
+  z *= t;  
+}
+
+Vec3 phantom;
+
+class Photon {
+  Vec3 pos;
+  Vec3 dir;
+  float Energy;
+  bool Escaped;
+public:
+  Photon();
+  bool HasEscaped();
+  void SetPosition(Vec3 ipos);
+  void SetDirection(Vec3 idir);
+  void SetEnergy(float E);
+  float GetEnergy() {return Energy;};
+  void Advance(float dist);
+  void Intersect(Vec3 ellipse, float &tmin, float &tmax);
+  void Step(Vec3 ellipse);
+  void Setup(Vec3 ellipse);
+  void Interact();
+  void DoCompton();
+  void DoPhotoElectric();
+  void RotateDirectionVector(float theta, float phi);
+  bool IsAlive();
+  void Print(std::ostream& o);
+};
+
+bool Photon::HasEscaped() {
+  return Escaped;
+}
+
+void Photon::Print(std::ostream& o) {
+  o << "Pos: " << pos << " Dir: " << dir << " Energy " << Energy << "\n";
+}
+
+Photon::Photon() {
+  Escaped = false;
+}
+
+void Photon::SetPosition(Vec3 ipos) {
+  pos = ipos;
+}
+void Photon::SetDirection(Vec3 idir) {
+  dir = idir;
+}
+
+void Photon::SetEnergy(float E) {
+  Energy = E;
+}
+
+bool Photon::IsAlive() {
+  return (Energy>0);
+}
+
+void Photon::DoPhotoElectric() {
+  // Kill the photon.
+  Energy = 0;
+  Escaped = true;
+}
+
+void Photon::DoCompton() {
+  // Sample the Klein-Nishina distribution to get our new energy
+  float Enew = SampleKleinNishina(Energy);
+  // Get the scatter polar angle
+  float costheta = GetScatterPolarAngleCosine(Energy, Enew);
+  float phi = GetScatterRadialAngle();
+  // Change our direction based on the angles
+  RotateDirectionVector(costheta,phi);
+  // Adjust our energy
+  Energy = Enew;
+}
+
+void Photon::RotateDirectionVector(float costheta, float phi) {
+  // Now, compute a new direction based on these two angles...  This is
+  // somewhat tricky.  For a given vector [a,b,c], there are three
+  // vectors that are orthogonal to it:
+  // [c,0,-a]
+  // [b,-a,0]
+  // [0,c,-b]
+  // For numerical stability reasons, we use the pair of vectors that
+  // includes the maximal value.
+  Vec3 bvec;
+  Vec3 cvec;
+  if ((fabs(dir.x) >= fabs(dir.y)) && (fabs(dir.x) >= fabs(dir.z))) {
+    // Use the following as basis vectors:
+    // [c,0,-a]
+    // [b,-a,0]
+    bvec.x = dir.z;
+    bvec.y = 0;
+    bvec.z = -dir.x;
+    cvec.x = dir.y;
+    cvec.y = -dir.x;
+    cvec.z = 0;
+  } else if ((fabs(dir.y) >= fabs(dir.x)) && (fabs(dir.y) >= fabs(dir.z))) {
+    // Use the following as basis vectors:
+    // [b,-a,0]
+    // [0,c,-b]
+    bvec.x = dir.y;
+    bvec.y = -dir.x;
+    bvec.z = 0;
+    cvec.x = 0;
+    cvec.y = dir.z;
+    cvec.z = -dir.y;
+  } else {
+    // Use the following as basis vectors:
+    // [c,0,-a]
+    // [0,c,-b]
+    bvec.x = dir.z;
+    bvec.y = 0;
+    bvec.z = -dir.x;
+    cvec.x = 0;
+    cvec.y = dir.z;
+    cvec.z = -dir.y;
+  }
+  // Normalize the two vectors
+  bvec.Normalize();
+  cvec.Normalize();
+  // Compute a rotated vector in the plane spanned by bvec and cvec
+  float cosang = cos(phi);
+  float sinang = sin(phi);
+  Vec3 dvec;
+  dvec.x = cosang*bvec.x + sinang*cvec.x;
+  dvec.y = cosang*bvec.y + sinang*cvec.y;
+  dvec.z = cosang*bvec.z + sinang*cvec.z;
+  // Add a scaled version of the current vector (the scaling should be 
+  // cosine(theta))
+  dvec.x += dir.x*costheta;
+  dvec.y += dir.y*costheta;
+  dvec.z += dir.z*costheta;
+  // Normalize dvec
+  dvec.Normalize();
+  // This is the new direction
+  dir.x = dvec.x;
+  dir.y = dvec.y;
+  dir.z = dvec.z;
+}
+
+
+void Photon::Interact() {
+  // An interaction has taken place... We are only tracking Incoherent scattering
+  // and photoelectric absorption.  So we can compute the relative probabilities
+  // as p(scatter) = mu_s/(mu_s+mu_p)
+  // and p(photo) = 1-p(scatter).
+  float mu_s = GetMuScatter(Energy);
+  float mu_p = GetMuPhotoElectric(Energy);
+  if (drand48() < (mu_s/(mu_s+mu_p)))
+    DoCompton();
+  else
+    DoPhotoElectric();
+}
+
+
+void Photon::Advance(float dist) {
+  pos.x += dir.x*dist;
+  pos.y += dir.y*dist;
+  pos.z += dir.z*dist;
+}
+
+
+// The object is an elliptical phantom that is axis aligned.
+// This routines calculates the intersection times (distance along
+// the given ray) to the boundaries of the ellipse.  Returns false
+// if the ray never intersects the ellipse.
+//  ||Dx||^2 < 1
+//  ||D(x0+t*d)||^2 = ||D*x0||^2+t^2*||D*d||^2+t<D*x0,D*d>
+void Photon::Intersect(Vec3 e, float &tmin, float &tmax) {
+  // Transform pos and dir by the axis scaling parameters
+  Vec3 spos;
+  Vec3 sdir;
+  spos.x = pos.x/e.x;
+  spos.y = pos.y/e.y;
+  spos.z = pos.z/e.z;
+  sdir.x = dir.x/e.x;
+  sdir.y = dir.y/e.y;
+  sdir.z = dir.z/e.z;
+  // Compute the coeffs of the quadratic
+  float a, b, c;
+  a = sdir.x*sdir.x+sdir.y*sdir.y+sdir.z*sdir.z;
+  b = 2*(sdir.x*spos.x+sdir.y*spos.y+sdir.z*spos.z);
+  c = spos.x*spos.x+spos.y*spos.y+spos.z*spos.z - 1;
+  // Compute the discriminant
+  float disc = b*b - 4*a*c;
+  if (disc >= 0) {
+    float sqdisc = sqrt(disc);
+    tmin = (-b-sqdisc)/(2*a);
+    tmax = (-b+sqdisc)/(2*a);
+    if (tmax <= 0)
+      Escaped = true;
+  } else {
+    Escaped = true;
+  }
+}
+
+// Step the photon - it has an energy, a position and direction
+// Here's how the routine works....  We start by 
+// calculating the distance in material as seen by the current photon.
+void Photon::Step(Vec3 ellipse) {
+  // Calculate the intersection times
+  float tmin, tmax;
+  Intersect(ellipse,tmin,tmax);
+  if (Escaped) return;
+  float meanFreePathCompton = 10.0/GetMuScatter(Energy);
+  float meanFreePathPhoto = 10.0/GetMuPhotoElectric(Energy);
+  float actualPathCompton = -meanFreePathCompton*log(1.0 - drand48());
+  float actualPathPhoto = -meanFreePathPhoto*log(1.0 - drand48());
+  float actualPath;
+  bool isCompton;
+  if (actualPathCompton < actualPathPhoto) {
+    isCompton = true;
+    actualPath = actualPathCompton;
+  } else {
+    isCompton = false;
+    actualPath = actualPathPhoto;
+  }
+  // If the sample says to leave the 
+  if (actualPath > tmax) {
+    Advance(tmax+ShimDistance); 
+    Escaped = true;
+    std::cout << "Escaped at distance " << tmax << "\n";
+  } else {
+    // OK - advance by the sample length
+    Advance(actualPath);
+    InteractionCount++;
+    if (isCompton) {
+      DoCompton();
+      std::cout << "Compton at distance " << actualPath << " energy is now " << Energy << "\n";
+    } else {
+      DoPhotoElectric();
+      std::cout << "PhotoE at distance " << actualPath << "\n";
+    }
+  }
+}
+
+void SetupTables() {
+  ShimDistance = 1;
+}
+
+void SetupGeometry() {
+  phantom.x = 350/2;
+  phantom.y = 350/2;
+  phantom.z = 10000;
+}
+
+// Advances a photon to the surface of the ellipse - returns false
+// if the photon never intersects the surface..
+void Photon::Setup(Vec3 e) {
+  float tmin, tmax;
+  Intersect(e,tmin, tmax);
+  if (!Escaped)
+  Advance(tmin+ShimDistance);
+}
+
+// Generate a photon.
+Photon GeneratePhoton() {
+  Photon p;
+  // Set the energy - we use 80 kEV for now
+  p.SetEnergy(74);
+  // Set the position - emit from the focal position
+  p.SetPosition(Vec3(0,540,0));
+  // Set the direction - randomly chosen in the fan
+  // Get a random half-radian fan angle in radians
+  float fanang = (2*drand48()-1)*asin(35.0/2.0/540.0);
+  p.SetDirection(Vec3(sin(fanang),-cos(fanang),0));
+  return p;
+}
+
+void RunEvent() {
+  // Start by generating a photon
+  Photon p = GeneratePhoton();
+  // Step the photon into the object
+  p.Setup(phantom);
+  if (p.HasEscaped()) {
+    AirPhotons++;
+    return;
+  }
+  std::cout << "start photon \n";
+  while (!p.HasEscaped())
+    p.Step(phantom);
+  if (p.GetEnergy() == 74)
+    PrimaryPhotons++;
+  else if (p.GetEnergy() == 0)
+    PhotoE++;
+}
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    std::cerr << "Requires a count of events\n";
+    exit(1);
+  }
+  SetupGeometry();
+  SetupTables();
+  int ecount = atoi(argv[1]);
+  for (int i=0;i<ecount;i++)
+    RunEvent();
+  std::cout << "Air Photons = " << AirPhotons << "\n";
+  std::cout << "Primary Photons = " << PrimaryPhotons << "\n";
+  std::cout << "PhotoElectric = " << PhotoE << "\n";
+  std::cout << "Number of Interactions = " << InteractionCount << "\n";
+  return 0;
+}
+
+