catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/clib_build/src/Detector.hpp

@@ -0,0 +1,134 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifndef __Detector_hpp__
+#define __Detector_hpp__
+
+#include "MatVec.h"
+#include "Volume.hpp"
+#include <string>
+#include <stdlib.h>
+#include "Photon.hpp"
+#include <math.h>
+
+class GenericDetector {
+protected:
+  Vec3 *mDetectorCenters;
+  Vec3 *mDetectorNormals;
+  Vec mDetectorCellAreas;
+  Mat mCoherentScatterSignal;
+  Mat mIncoherentScatterSignal;
+  Vec mPrimarySignal;
+  Vec mMCSignal;
+  int mDetectorCellCount;
+  int mNumEvents;
+  int mEcount;
+public:
+  void SetEcount(int maxE) {mEcount = maxE;}
+  void SetNumEvents(int cnt) {mNumEvents = cnt;}
+  int GetCellCount() {return mDetectorCellCount;}
+  Mat GetCoherentSignal() {return mCoherentScatterSignal;}
+  Mat GetIncoherentSignal() {return mIncoherentScatterSignal;}
+  Vec GetPrimarySignal() {return mPrimarySignal;}
+  Vec GetMCSignal() {return mMCSignal;}
+  Vec3* GetCenters() {return mDetectorCenters;}
+  Vec3* GetNormals() {return mDetectorNormals;}
+  Vec GetCellAreas() {return mDetectorCellAreas;}
+  virtual bool RecordPhotonMC(Photon& p, bool isPrimary = false) = 0;
+  virtual float GetEffectiveArea(int cellNum, Vec3 pos, Vec3 dir) {return fabs(mDetectorCellAreas[cellNum]*dir.Dot(mDetectorNormals[cellNum]));}
+  void WriteData(std::string fname, bool MConly, bool PrimaryValid);
+};
+
+class FocallyAlignedXCollimatedDetector : public GenericDetector {
+protected:
+  float mSDD, mSID, mCellWidth, mCellHeight;
+  int mNRows, mNCols;
+  int mNRowsDecimated, mNColsDecimated;
+  float mCenterRow, mCenterCol;
+  float mGridHeight;
+  Vec3* mDetectorToCollimatorUnitVec;
+  Vec3* mDetectorAlongCollimatorUnitVec;
+  bool mDecimated;
+  int mDetColDecimationFactor;
+  int mDetRowDecimationFactor;
+public:
+  FocallyAlignedXCollimatedDetector(float SDD, float SID, float cellWidth, 
+				    float cellHeight, int nrows, int ncols, 
+				    float centerrow, float centercol, 
+				    float gridHeight, int coldecimation,
+				    int rowdecimation, int maxEinKV);
+  virtual ~FocallyAlignedXCollimatedDetector();
+  Vec3* GetToCollimatorUnitVecs() {return mDetectorToCollimatorUnitVec;}
+  Vec3* GetAlongCollimatorUnitVecs() {return mDetectorAlongCollimatorUnitVec;}
+  virtual float GetEffectiveArea(int cellNum, Vec3 pos, Vec3 dir);
+  bool RecordPhotonMC(Photon& p, bool isPrimary);
+  int GetEffectiveRowCount() {return mNRowsDecimated;}
+  int GetEffectiveColCount() {return mNColsDecimated;}
+  int GetFinalRowCount() {return mNRows;}
+  int GetFinalColCount() {return mNCols;}
+  int GetRowDecimationFactor() {return mDetRowDecimationFactor;}
+  int GetColDecimationFactor() {return mDetColDecimationFactor;}
+};
+
+class FocallyAlignedXandZCollimatedDetector : public FocallyAlignedXCollimatedDetector {
+
+  // This type of detector has collimator blades that are focused in x, but not in z
+  // The second set of collimator blades are all parallel to the xy-plane.
+  // If the cone angle of the system is not too large, this is a good approximation of a collimator that is focussed in both directions
+
+public:
+  FocallyAlignedXandZCollimatedDetector(float SDD, float SID, float cellWidth, 
+				    float cellHeight, int nrows, int ncols, 
+				    float centerrow, float centercol, 
+				    float gridHeight, int coldecimation,
+				    int rowdecimation, int maxEinKV) : FocallyAlignedXCollimatedDetector(SDD, SID, cellWidth,
+													 cellHeight, nrows, ncols,
+													 centerrow, centercol,
+													 gridHeight, coldecimation,
+													 rowdecimation, maxEinKV) {}
+  virtual float GetEffectiveArea(int cellNum, Vec3 pos, Vec3 dir);
+};
+
+
+
+// Included flat detector class - Pablo Milioni (GE Healthcare)
+
+class XAlignedZCollimatedDetectorFlat : public GenericDetector {
+  
+  // FIX ME:
+  // This type of detector should have collimator blades that are alligned with the x-axis,
+  // The intersection test for the colimator is not ready yet
+  // Forced mGridHeight = 0
+  
+protected:
+  float mSDD, mSID, mCellWidth, mCellHeight;
+  int mNRows, mNCols;
+  int mNRowsDecimated, mNColsDecimated;
+  float mCenterRow, mCenterCol;
+  float mGridHeight;
+  Vec3* mDetectorToCollimatorUnitVec;
+  Vec3* mDetectorAlongCollimatorUnitVec;
+  bool mDecimated;
+  int mDetColDecimationFactor;
+  int mDetRowDecimationFactor;
+public:
+  XAlignedZCollimatedDetectorFlat(float SDD, float SID, float cellWidth, 
+				    float cellHeight, int nrows, int ncols, 
+				    float centerrow, float centercol, 
+				    float gridHeight, int coldecimation,
+				    int rowdecimation, int maxEinKV);
+  virtual ~XAlignedZCollimatedDetectorFlat();
+  Vec3* GetToCollimatorUnitVecs() {return mDetectorToCollimatorUnitVec;}
+  Vec3* GetAlongCollimatorUnitVecs() {return mDetectorAlongCollimatorUnitVec;}
+  virtual float GetEffectiveArea(int cellNum, Vec3 pos, Vec3 dir);
+  bool RecordPhotonMC(Photon& p, bool isPrimary);
+  int GetEffectiveRowCount() {return mNRowsDecimated;}
+  int GetEffectiveColCount() {return mNColsDecimated;}
+  int GetFinalRowCount() {return mNRows;}
+  int GetFinalColCount() {return mNCols;}
+  int GetRowDecimationFactor() {return mDetRowDecimationFactor;}
+  int GetColDecimationFactor() {return mDetColDecimationFactor;}
+};
+
+
+#endif
+

gecatsim/clib_build/src/Interpolate.cpp

@@ -0,0 +1,58 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifdef WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+extern "C" {
+
+EXPORT void Interpolate(int size,
+		 float *x,
+		 float *y,
+		 int sizenew,
+		 float *xnew,
+		 float *ynew)
+
+{
+  int i, j;
+  float thex;
+
+  if (size == 1){
+    for (i=0;i<sizenew;i++){
+     ynew[i] = y[0];
+    }
+  }
+  else {
+    if (x[1]>x[0]){
+      for (i=0;i<sizenew;i++){
+	thex=xnew[i];
+	for (j=0 ; j < size ; j++){
+	  if (x[j] > thex) {
+	    break;
+	  }
+	}
+	if (j==size) {j--;}
+	if (j==0) {j++;}
+	ynew[i] = y[j]+(thex - x[j])*(y[j-1]- y[j])/(x[j-1]- x[j]);
+      }
+    }
+    else {
+      for (i=0;i<sizenew;i++){
+	thex=xnew[i];
+	for (j=size-1 ; j >= 0 ; j--){
+	  if (x[j] > thex) {
+	    break;
+	  }
+	}
+	if (j<0) {j=0;}
+	if (j==(size-1)) {j--;}
+	ynew[i] = y[j]+(thex- x[j])*(y[j+1]- y[j])/(x[j+1]- x[j]);
+      }
+    }  
+  }
+}
+}
+
+

gecatsim/clib_build/src/Intersection.cpp

@@ -0,0 +1,198 @@
+// Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+#include "Intersection.h"
+#include <vector>
+#include <algorithm>
+#include "MatVec.h"
+#include <math.h>
+
+Intersection::Intersection() {
+}
+
+Intersection::~Intersection() {
+}
+
+Intersection::Intersection(int id, double a_time, bool a_enterSense, 
+			   double a_rho, int a_priority, int a_material) {
+  time = a_time;
+  enterSense = a_enterSense;
+  rho = a_rho;
+  priority = a_priority;
+  material = a_material;
+  ID = id;
+}
+
+void Intersection::PrintMe(std::ostream& c) const {
+  c << "Intersection time " << time << "\r\n";
+  c << "Entry time (vs. exit time) " << enterSense << "\r\n";
+  c << "priority = " << priority << ", ";
+  c << "rho = " << rho << ", ";
+  c << "matl = " << material << "\r\n";
+  c << "object ID = " << ID << "\r\n";
+}
+
+std::ostream& operator<<(std::ostream& c, Intersection& p) {
+  p.PrintMe(c);
+  return c;
+}
+
+std::ostream& operator<<(std::ostream& c, IntersectionSet& p) {
+  IntersectionSet::iterator i;
+  for (i=p.begin();i!=p.end();i++) {
+    i->PrintMe(c);
+    c << "\r\n";
+  }
+  return c;
+}
+
+bool Icmp(const Intersection& a, const Intersection& b) {
+  return (a.time < b.time) || ((a.time == b.time) && a.enterSense);
+}
+
+
+//typedef std::vector<Intersection> hitStackType;
+
+typedef IntersectionSet hitStackType;
+
+void IntersectionSet::GetHitList(double *ptable) {
+
+  if (empty()) return;
+  std::sort(begin(),end(),Icmp);
+
+  hitStackType hitStack;
+
+  //
+  // Calculate pathlength
+  //
+  double previousposition=0.;
+  int currentpriority = 0;
+  double currentrho = 0;
+  int currentmaterial = 0;
+  for (IntersectionSet::iterator nr=begin();nr!=end();nr++) {
+    //
+    // get new data
+    //
+    double position=nr->time;
+    int priority=nr->priority;
+    bool sense=nr->enterSense;
+    if (hitStack.empty()) {
+      currentpriority=0;
+      currentrho=0;
+      currentmaterial=0;
+    } else {
+      currentpriority=hitStack.back().priority;
+      currentrho=hitStack.back().rho;
+      currentmaterial=hitStack.back().material;
+      ptable[currentmaterial-1] += (position-previousposition)*currentrho;
+    }
+    previousposition=position;
+    if (priority > currentpriority) {
+      // PUSH
+      hitStack.push_back(*nr);
+    } else if (priority == currentpriority) {
+      if (hitStack.empty())
+	throw "Error: stack underflow in GetHitList.\r\n";
+      hitStack.pop_back();
+    }
+    else {
+      if (sense) {
+	hitStackType::iterator cp = hitStack.begin();
+	while ((cp != hitStack.end()) && cp->priority < priority)
+	  cp++;
+	// INSERT IN STACK
+	hitStack.insert(cp,*nr);
+      } else {
+	// GET OUT STACK
+	hitStackType::iterator cp = hitStack.begin();
+	while ((cp != hitStack.end()) && cp->priority != priority)
+	  cp++;
+	hitStack.erase(cp);
+      }
+    }
+  }
+  if (!hitStack.empty()) {
+    printf("ERROR\r\n");
+    std::cout << (*this);
+    printf("hitstack...\r\n");
+    std::cout << hitStack;
+    throw "Error: stack not empty on exit of GetHitList.\r\n";
+  }
+}
+
+void IntersectionSet::RenderIntersections(int N, float dX, float* IDmap, int targID) {
+  if (empty()) return;
+
+  std::sort(begin(),end(),Icmp);
+
+  hitStackType hitStack;
+
+  //
+  // Calculate pathlength
+  //
+  double previousposition=0.;
+  int currentpriority = 0;
+  double currentrho = 0;
+  int currentmaterial = 0;
+  int currentID = 0;
+  for (IntersectionSet::iterator nr=begin();nr!=end();nr++) {
+    //
+    // get new data
+    //
+    double position=nr->time;
+    int priority=nr->priority;
+    bool sense=nr->enterSense;
+    if (hitStack.empty()) {
+      currentpriority=0;
+      currentrho=0;
+      currentmaterial=0;
+      currentID = 0;
+    } else {
+      currentpriority=hitStack.back().priority;
+      currentrho=hitStack.back().rho;
+      currentmaterial=hitStack.back().material;
+      currentID = hitStack.back().ID;
+      if (currentmaterial == targID) {
+	float startndx, stopndx;
+	startndx = previousposition/dX;
+	stopndx = position/dX;
+	int firstwhole, lastwhole, firstfrac, lastfrac;
+	firstwhole = (int) ceil(startndx+0.5);
+	lastwhole = (int) floor(stopndx-0.5);
+	firstfrac = (int) ceil(startndx-0.5);
+	lastfrac = (int) floor(stopndx+0.5);
+	IDmap[firstfrac] += currentrho*(firstfrac+0.5-startndx);
+	IDmap[lastfrac] += currentrho*(stopndx-lastfrac+0.5);
+	if (firstfrac == lastfrac)
+	  IDmap[lastfrac] -= currentrho*(1.0);
+	for (int p=firstwhole;p<=lastwhole;p++)
+	  IDmap[p] += currentrho*1.0;
+      }
+    }
+    previousposition=position;
+    if (priority > currentpriority) {
+      // PUSH
+      hitStack.push_back(*nr);
+    } else if (priority == currentpriority) {
+      if (hitStack.empty())
+	throw "Error: stack underflow in RenderIntersections.\n";
+      hitStack.pop_back();
+    }
+    else {
+      if (sense) {
+	hitStackType::iterator cp = hitStack.begin();
+	while ((cp != hitStack.end()) && cp->priority < priority)
+	  cp++;
+	// INSERT IN STACK
+	hitStack.insert(cp,*nr);
+      } else {
+	// GET OUT STACK
+	hitStackType::iterator cp = hitStack.begin();
+	while ((cp != hitStack.end()) && cp->priority != priority)
+	  cp++;
+	hitStack.erase(cp);
+      }
+    }
+  }
+}
+
+

gecatsim/clib_build/src/Intersection.h

@@ -0,0 +1,36 @@
+// Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+#ifndef Intersection_h
+#define Intersection_h
+
+#include <string>
+#include <iostream>
+#include <set>
+#include <vector>
+#include <stdio.h>
+
+class Intersection {
+ public:
+  int ID;
+  double time;
+  bool enterSense;
+  double rho;
+  int priority;
+  int material;
+  Intersection(int id, double a_time, bool enterSense, double a_rho, int a_priority, int a_material);
+  Intersection();
+  ~Intersection();
+  void PrintMe(std::ostream& c) const;
+};
+
+class IntersectionSet : public std::vector<Intersection> {
+ public:
+  void GetHitList(double *ptable);
+  void RenderIntersections(int N, float dX, float* IDmap, int ID);
+};
+
+std::ostream& operator<<(std::ostream& c, Intersection& p);
+std::ostream& operator<<(std::ostream& c, IntersectionSet& p);
+
+#endif
+

gecatsim/clib_build/src/MatVec.cpp

@@ -0,0 +1,262 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include "MatVec.h"
+#include <cmath>
+
+#ifndef M_PI
+#define M_PI 3.1415926535
+#endif
+
+Vec3::Vec3() {
+  x = 0; y = 0; z = 0;
+}
+
+Vec3::Vec3(double xa, double ya, double za)  {
+  x = xa; 
+  y = ya;
+  z = za;
+}
+
+Vec3::~Vec3() {
+}
+
+Vec3 Vec3::Negate() {
+  return Vec3(-x,-y,-z);
+}
+
+Vec3 Vec3::Recip() {
+  if (x == 0 || y == 0 || z == 0)
+    throw "zero encountered in Vec3::Recip!";
+  Vec3 C;
+  C.x = 1.0/x;
+  C.y = 1.0/y;
+  C.z = 1.0/z;
+  return C;
+}
+
+Vec3 Vec3::Subtract(const Vec3& b) {
+  Vec3 C;
+  C.x = x - b.x;
+  C.y = y - b.y;
+  C.z = z - b.z;
+  return C;
+}
+
+void Vec3::Normalize() {
+  double nrm;
+  nrm = Norm();
+  if (nrm == 0)
+    throw "Encountered zero-length vector in Vec3::Normalize routine - probably a source and detector are co-located?";
+  x /= nrm;
+  y /= nrm;
+  z /= nrm;
+}
+
+double Vec3::Dot(const Vec3& b) {
+  return x*b.x + y*b.y + z*b.z;
+}
+
+void Vec3::PrintMe(std::ostream& c) {
+  c << "<" << x << "," << y << "," << z << ">";
+}
+
+double Vec3::Norm() {
+  return sqrt(x*x+y*y+z*z);
+}
+
+Vec3 Vec3::Direction(const Vec3& b) {
+  Vec3 C;
+  C.x = x - b.x;
+  C.y = y - b.y;
+  C.z = z - b.z;
+  double nrm;
+  nrm = C.Norm();
+  C.x /= nrm;
+  C.y /= nrm;
+  C.z /= nrm;
+  return C;
+}
+
+Vec3 Vec3::InverseScale(const Vec3& b) {
+  if (b.x == 0 || b.y == 0 || b.z == 0)
+    throw "Encountered zero in Vec3::InverseScale routine - probably an object dimension is zero?";
+  Vec3 C;
+  C.x = x/b.x;
+  C.y = y/b.y;
+  C.z = z/b.z;
+  return C;
+}
+
+double Vec3::Max() {
+  return std::max(std::max(x,y),z);
+}
+
+Vec3 Vec3::Cross(Vec3 b) {
+  Vec3 C;
+  C.x = y*b.z - z*b.y;
+  C.y = - x*b.z + z*b.x;
+  C.z = x*b.y - y*b.x;
+  return C;
+}
+
+void Vec3::RotateVector(float theta, float phi) {
+  //   G4double dirx = sinTheta * std::cos(phi);
+  //   G4double diry = sinTheta * std::sin(phi);
+  //   G4double dirz = cosTheta ;
+  //   G4ThreeVector photonDirection1(dirx,diry,dirz);
+  //   photonDirection1.rotateUz(photonDirection0);
+  //   aParticleChange.ProposeMomentumDirection(photonDirection1) ;
+
+  double dx = sin(theta)*cos(phi);
+  double dy = sin(theta)*sin(phi);
+  double dz = cos(theta);
+
+  double u1 = x;
+  double u2 = y;
+  double u3 = z;
+
+  double up = u1*u1+u2*u2;
+  if (up > 0) {
+    up = sqrt(up);
+    double px = dx;
+    double py = dy;
+    double pz = dz;
+    dx = (u1*u3*px - u2*py)/up + u1*pz;
+    dy = (u2*u3*px + u1*py)/up + u2*pz;
+    dz =    -up*px +             u3*pz;
+  }
+  else if (u3 < 0.) { dx = -dx; dz = -dz; }      // phi=0  teta=pi
+  else {};
+  
+  x = dx;
+  y = dy;
+  z = dz;
+}
+
+
+Mat4::Mat4() {
+  Zero();
+}
+
+void Mat4::Zero() {
+  int i, j;
+  for (i=0;i<4;i++)
+    for (j=0;j<4;j++)
+      coeff[i][j] = 0.0;
+}
+
+void Mat4::SetIdentity() {
+  Zero();
+  for (int i=0;i<4;i++)
+    coeff[i][i] = 1.0;
+}
+
+Vec3 Mat4::Vec3Multiply(Vec3 B) {
+  Vec3 R;
+  R.x = coeff[0][0]*B.x + coeff[0][1]*B.y + coeff[0][2]*B.z + coeff[0][3];
+  R.y = coeff[1][0]*B.x + coeff[1][1]*B.y + coeff[1][2]*B.z + coeff[1][3];
+  R.z = coeff[2][0]*B.x + coeff[2][1]*B.y + coeff[2][2]*B.z + coeff[2][3];
+  return R;
+}
+
+Vec3 Mat4::Vec3MultiplyZeroConst(Vec3 B) {
+  Vec3 R;
+  R.x = coeff[0][0]*B.x + coeff[0][1]*B.y + coeff[0][2]*B.z;
+  R.y = coeff[1][0]*B.x + coeff[1][1]*B.y + coeff[1][2]*B.z;
+  R.z = coeff[2][0]*B.x + coeff[2][1]*B.y + coeff[2][2]*B.z;
+  return R;
+}
+
+Mat4 Mat4::Mat4MultiplyRight(Mat4 B) {
+  Mat4 C;
+  for (int i=0;i<4;i++)
+    for (int j=0;j<4;j++)
+      for (int k=0;k<4;k++)
+	C.coeff[i][j] += coeff[i][k]*B.coeff[k][j];
+  return C;
+}
+
+Mat4 Mat4::Mat4MultiplyLeft(Mat4 B) {
+  Mat4 C;
+  for (int i=0;i<4;i++)
+    for (int j=0;j<4;j++)
+      for (int k=0;k<4;k++)
+	C.coeff[i][j] += B.coeff[i][k]*coeff[k][j];
+  return C;  
+}
+
+
+Mat4 Mat4::RotateX(double ang) {
+  ang = -ang*M_PI/180;
+  Mat4 C;
+  C.SetIdentity();
+  C.coeff[1][1] = cos(ang);
+  C.coeff[2][2] = cos(ang);
+  C.coeff[2][1] = -sin(ang);
+  C.coeff[1][2] = sin(ang);
+  return C;
+}
+
+Mat4 Mat4::RotateY(double ang) {
+  Mat4 C;
+  ang = -ang*M_PI/180;
+  C.SetIdentity();
+  C.coeff[0][0] = cos(ang);
+  C.coeff[2][2] = cos(ang);
+  C.coeff[0][2] = -sin(ang);
+  C.coeff[2][0] = sin(ang);
+  return C;
+}
+
+Mat4 Mat4::RotateZ(double ang) {
+  Mat4 C;
+  ang = -ang*M_PI/180;
+  C.SetIdentity();
+  C.coeff[0][0] = cos(ang);
+  C.coeff[1][1] = cos(ang);
+  C.coeff[0][1] = sin(ang);
+  C.coeff[1][0] = -sin(ang);
+  return C;
+}
+
+Mat4 Mat4::Translate(Vec3 delta) {
+  Mat4 C;
+  C.SetIdentity();
+  C.coeff[0][3] = -delta.x;
+  C.coeff[1][3] = -delta.y;
+  C.coeff[2][3] = -delta.z;
+  return C;
+}
+
+Mat4 Mat4::Scale(Vec3 gain) {
+  Mat4 C;
+  C.SetIdentity();
+  C.coeff[0][0] = gain.x;
+  C.coeff[1][1] = gain.y;
+  C.coeff[2][2] = gain.z;
+  return C;
+}
+
+Mat4::~Mat4() {
+}
+
+void Mat4::PrintMe(std::ostream& c) {
+  int i, j;
+  for (i=0;i<4;i++) {
+    for (j=0;j<4;j++)
+      c << coeff[i][j] << "  ";
+    c << "\n";
+  }
+}
+
+std::ostream& operator<<(std::ostream& c, Vec3 p) {
+  p.PrintMe(c);
+  return c;
+}
+
+std::ostream& operator<<(std::ostream& c, Mat4 p) {
+  p.PrintMe(c);
+  return c;
+}
+
+