catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/clib_build/src/ClipPlane.cpp

@@ -0,0 +1,83 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include "ClipPlane.h"
+#include <cmath>
+
+ClipPlane::ClipPlane() {
+  intersect = 0;
+}
+
+ClipPlane::~ClipPlane() {
+}
+
+ClipPlane::ClipPlane(Vec3 anormal, double aintersect) {
+  normal = anormal;
+  intersect = aintersect;
+}
+
+void ClipPlane::PrintMe(std::ostream& c) {
+  c << "Clip Plane normal: " << normal << "\n";
+  c << "Clip Plane intersection: " << intersect << "\n";
+}
+
+std::ostream& operator<<(std::ostream& c, ClipPlane& p) {
+  p.PrintMe(c);
+  return c;
+}
+
+std::ostream& operator<<(std::ostream& c, ClipPlaneSet& p) {
+  for (unsigned i=0;i<p.size();i++) {
+    p[i].PrintMe(c);
+    c << "\n";
+  }
+  return c;
+}
+
+// Returns true if there is an intersection, sets intersection time to the
+// time of intersection of the plane and the ray, and sets direction to +/- 1 to
+// indicate which half of the real line to include
+void ClipPlane::GetIntersection(Vec3 src, Vec3 delta, IntersectionSet &T) {
+  // Are we a positive plane or a negative one?
+  double t0;
+  int direction;
+  // Get the sine of the angle between delta and the plane normal
+  double sinang;
+  sinang = delta.Dot(normal);
+  if (fabs(sinang) < 1e-16) {
+    // Ray is essentially parallel to the plane... 
+    if (src.Dot(normal) > intersect) {
+      // Ray is wholly contained in the half space
+      t0 = -INFTY;
+      direction = +1;
+    } else {
+      // Ray is wholly discarded by the half space
+      t0 = -INFTY;
+      direction = -1;
+    }
+  } else {
+    // Ray is not parallel to the plane.  Compute the interesction time
+    t0 = (intersect - src.Dot(normal))/sinang;
+    if (sinang > 0) direction = +1; else direction = -1;
+  }
+  // Update the intersection set... we do this by testing each intersection
+  // time in the set against our t0.  If we are on the clipped side of the
+  // plane, the time is modified.
+  IntersectionSet Copy;
+  for (IntersectionSet::iterator i=T.begin();i!=T.end();i++) {
+    if ((i->time < t0) && (direction == 1)) {
+      Intersection n = *i;
+      n.time = t0;
+      Copy.push_back(n);
+    } else if ((i->time > t0) && (direction == -1)) {
+      Intersection n = *i;
+      n.time = t0;
+      Copy.push_back(n);
+    } else {
+      Copy.push_back(*i);
+    }
+  }
+  T = Copy;
+}
+
+
+

gecatsim/clib_build/src/ClipPlane.h

@@ -0,0 +1,28 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifndef ClipPlane_h
+#define ClipPlane_h
+
+#include <iostream>
+#include <vector>
+#include "MatVec.h"
+#include "Intersection.h"
+
+class ClipPlane {
+ public:
+  Vec3 normal;
+  double intersect;
+  ClipPlane();
+  ~ClipPlane();
+  ClipPlane(Vec3 anormal, double intersect);
+  void PrintMe(std::ostream& c);
+  void GetIntersection(Vec3 src, Vec3 delta, IntersectionSet &T);
+};
+
+typedef std::vector<ClipPlane> ClipPlaneSet;
+
+std::ostream& operator<<(std::ostream& c, ClipPlane& p);
+std::ostream& operator<<(std::ostream& c, ClipPlaneSet& p);
+
+#endif
+

gecatsim/clib_build/src/CrossSection.cpp

@@ -0,0 +1,179 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include "CrossSection.hpp"
+#include <float.h>
+#include <stdlib.h>
+#include <sstream>
+#include <fstream>
+#include <math.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+//--------------------
+CrossSection::CrossSection(){
+  this->MaxZ = 100;
+}
+
+//--------------------
+bool  CrossSection::print(int Z, ostream& os){
+  
+  bool RetVal;
+  if(this->TheData.count(Z)){
+    
+    map<double, double> ThisCrossSection = this->TheData[Z];
+    
+    for (map<double, double>::iterator iter = ThisCrossSection.begin(); 
+	 iter != ThisCrossSection.end(); iter++){
+      os << iter->first << " " << iter->second << endl;
+    }
+    RetVal = true;
+  }
+  else
+    RetVal = false;
+
+  return RetVal;
+  
+}
+//--------------------
+double CrossSection::GetValue(int Z, double Energy){
+  
+  double RetVal;
+  map<double, double> ThisCrossSection = this->TheData[Z];
+  map<double, double>::iterator LesserIter = ThisCrossSection.begin();
+  map<double, double>::iterator GreaterIter = --(ThisCrossSection.end());
+  double LesserStep = FLT_MAX, GreaterStep = FLT_MAX;
+  for (map<double, double>::iterator iter = ThisCrossSection.begin(); 
+       iter != ThisCrossSection.end(); iter++){
+    double ThisEnergy = iter->first;
+    if((ThisEnergy <= Energy) && (Energy - ThisEnergy) < LesserStep){
+      LesserStep = Energy - ThisEnergy;
+      LesserIter = iter;
+    }
+    if((ThisEnergy >= Energy) && (ThisEnergy - Energy) < GreaterStep){
+      GreaterStep = ThisEnergy - Energy;
+      GreaterIter = iter;
+    }
+  }
+  // linearly interpolate
+  if(LesserIter == GreaterIter)
+    RetVal = LesserIter->second;
+  else if(Energy > GreaterIter->first)
+    RetVal = GreaterIter->second;
+  else if(Energy < LesserIter->first)
+    RetVal = LesserIter->second;
+  else{
+    double E2 = GreaterIter->first;
+    double sigma2 = GreaterIter->second;
+    double E1 = LesserIter->first;
+    double sigma1 = LesserIter->second;
+    double logSigma = (log(sigma1)*log(E2/Energy) + log(sigma2)*log(Energy/E1))/log(E2/E1);
+    RetVal = exp(logSigma);
+  }
+  return RetVal;
+}
+//--------------------
+bool CrossSection::load(string FileBase){
+
+  double Energy, CS;
+  stringstream CSDataPath;
+  CSDataPath << FileBase << "-all.dat";
+  //test if file already exists
+  struct stat file_exists;
+  if (0==stat(CSDataPath.str().c_str(), &file_exists)) {
+      //cout << "Cross section database " << CSDataPath.str() << " already exists, will directly read." << endl;
+      ifstream ifs;
+      ifs.open(CSDataPath.str().c_str(), ios::binary);
+      ifs.seekg(0, ifs.end);
+      int db_size = ifs.tellg();
+      ifs.seekg(0, ifs.beg);
+
+      char* buffer = new char[db_size];
+      ifs.read(buffer, db_size);
+      char* this_pt = buffer;
+
+      int Z, num;
+      double eng, xsec;
+      while(this_pt < buffer+db_size) {
+          map<double, double> thisEntry;
+          Z = *(int*) this_pt;
+          this_pt += 4;
+          num = *(int*) this_pt; 
+          this_pt += 4;
+          for (int i=0; i<num; ++i) {
+              eng = *(double*) this_pt;
+              this_pt += 8;
+              xsec = *(double*) this_pt;
+              this_pt += 8;
+              thisEntry[eng] = xsec;
+          }
+          this->TheData[Z] = thisEntry;
+      }
+      ifs.close();
+      delete buffer;
+  }
+  else {
+    cout << "Generating cross section database: " << CSDataPath.str() << endl;
+    // cout << "You should only see this notice once." << endl;
+    ofstream ofs;
+    ofs.open(CSDataPath.str().c_str(), ios::binary);
+    ofs.seekp(0, ios::beg);
+    //#pragma omp parallel for 
+    for (unsigned int Z = 1; Z <= this->MaxZ; Z++){
+      map < double, double > ThisEntry;
+      stringstream FileName;
+      FileName << FileBase << "-" << Z << ".dat";
+      ifstream IF(FileName.str().c_str());
+      /*      while(IF >> Energy >> CS){
+        if(Energy > 0)
+      ThisEntry[Energy] = CS;
+      } */
+      string curLine;
+      while(!IF.eof())
+      {
+          getline(IF, curLine);
+      	if (curLine[0] == '%')
+      	{
+      		continue;
+      	}
+          std::stringstream ss(curLine, std::stringstream::in);
+          ss >> Energy >> CS;
+          if(Energy > 0)
+          {
+              ThisEntry[Energy] = CS;
+          }
+      }
+      if( ThisEntry.size() == 0) {
+        //ofs.close();
+        cerr << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl 
+         << "failed to load data for " << FileName.str() << "\n"
+         << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl ;
+      }
+      this->TheData[Z] = ThisEntry;
+
+      //now write this->theData to file
+      ofs.write((char*)&Z, sizeof(Z));
+      int map_size = ThisEntry.size();
+      ofs.write((char*)&map_size, sizeof(map_size));
+      if (map_size>0) {
+          map<double, double>::iterator it;
+          for (it = ThisEntry.begin(); it != ThisEntry.end(); ++it) {
+              ofs.write((char*)&(it->first), sizeof(double));
+              ofs.write((char*)&(it->second), sizeof(double));
+          }
+      }
+    }
+    ofs.close();
+  }
+  return true;
+}
+
+//bool  CrossSection::write(ostream& f){
+//  map < double, double >::iterator it2;
+//  map <int, < double, double >>::iterator it1;
+//  for (it1=this->TheData.begin(); it1!=this->TheData.end(); it1++) {
+//    for (it2=it1->second.begin(); it2!=it2->second.end(); it2++) {
+//        f.write((char*)&it2, sizeof(it2));
+//    }
+//  }
+//  return true;
+//}

gecatsim/clib_build/src/CrossSection.hpp

@@ -0,0 +1,27 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifndef __CrossSection_hpp__
+#define __CrossSection_hpp__
+
+#include <map>
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+class CrossSection {
+  typedef map < int, map < double, double > > CrossSectionData_t;
+private:
+  CrossSectionData_t TheData;
+  string             name;
+  unsigned int       MaxZ;
+
+public:
+  CrossSection();
+  bool  load(string FileBase);
+  bool  print(int Z, ostream& os);
+  double GetValue(int Z, double Energy);
+};
+
+#endif
+

gecatsim/clib_build/src/CrossSectionHandler.cpp

@@ -0,0 +1,160 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include "CrossSectionHandler.hpp"
+#include <math.h>
+#include <assert.h>
+
+// This is the atomic mass table as extracted from RIVL.
+const float AtomicMass[93] = {0,1.00794,4.002602,6.941,9.012182,10.811,12.0107,14.0067,15.9994,18.9984032,20.1797,22.989770,24.3050,26.981538,28.0855,30.973761,32.065,35.453,39.948,39.0983,40.078,44.955910,47.867,50.9415,51.9961,54.938049,55.845,58.933200,58.6934,63.546,65.39,69.723,72.64,74.92160,78.96,79.904,83.80,85.4678,87.62,88.90585,91.224,92.90638,95.94,98.9062546,101.07,102.90550,106.42,107.8682,112.411,114.818,118.710,121.760,127.60,126.90447,131.293,132.90545,137.327,138.9055,140.116,140.90765,144.24,145,150.36,151.964,157.25,158.92534,162.50,164.93032,167.259,168.93421,173.04,174.967,178.49,180.9479,183.84,186.207,190.23,192.217,195.078,196.96655,200.59,204.3833,207.2,208.98038,209,210,222,223,226.0254026,227.0277470,232.0381,231.03588,238.02891};
+
+
+float GetAtomicMass(int Z) {
+  return AtomicMass[Z];
+}
+
+void BaseDiscreteTable::InitializeTable(int numZ, float MinX, float MaxX, float DeltX) {
+  mMaxX = MaxX;
+  mMinX = MinX;
+  mDeltX = DeltX;
+  NumZ = numZ;
+  NumX = (int) ((MaxX - MinX)/DeltX+1);
+  mValues = MatrixAllocate(NumZ,NumX);
+}
+
+Mat BaseDiscreteTable::GetRawTable() {
+  return mValues;
+}
+
+int BaseDiscreteTable::MapXToBin(float x) {
+  return((int) rint((x-mMinX)/mDeltX));
+}
+
+float BaseDiscreteTable::GetValue(int Z, float X) {
+  int Xbin = MapXToBin(X);
+  if (Xbin < 0) return 0;
+  assert(Xbin < NumX);
+  return mValues[Z][Xbin];
+}
+
+
+void DiscreteTable::InitializeTable(Phantom *phantom, CrossSection& cs, 
+				    float MinX, float MaxX, float DeltX) {
+  mMaxX = MaxX;
+  mMinX = MinX;
+  mDeltX = DeltX;
+  // Get the list of Z that appear in the phantom
+  vector<int> stlZList = phantom->GetZList();
+  NumZ = stlZList.size();
+  ZList = IVecAllocate(NumZ);
+  for (unsigned i=0;i<stlZList.size();i++)
+    ZList[i] = stlZList[i];
+ // Build the map of Z to index
+  mZmap = IVecAllocate(MaxZ);
+  for (int i=0;i<NumZ;i++) 
+    mZmap[ZList[i]] = i;
+  NumX = (int) ((MaxX - MinX)/DeltX+1);
+  mValues = MatrixAllocate(NumZ,NumX);
+  for (int j=0;j<NumZ;j++) {
+    int Z = ZList[j];
+    for (int i=0;i<NumX;i++) {
+      float X = MinX + i*DeltX;
+      mValues[j][i] = cs.GetValue(Z,X);
+    }
+  }
+}
+
+int DiscreteTable::MapXToBin(float x) {
+  return((int) rint((x-mMinX)/mDeltX));
+}
+
+float DiscreteTable::GetValue(int Z, float X) {
+  int Xbin = MapXToBin(X);
+  if (Xbin < 0) return Z;
+  assert(Xbin < NumX);
+  return mValues[mZmap[Z]][Xbin];
+}
+
+void CrossSectionHandler::InitializeHandler(Phantom *phantom, CrossSection& cs,
+					    float MinEnergy, float MaxEnergy,
+					    float DeltEnergy) {
+  mMaxEnergy = MaxEnergy;
+  mMinEnergy = MinEnergy;
+  mDeltEnergy = DeltEnergy;
+  mPhantom = phantom;
+  // Get the list of Z that appear in the phantom
+  vector<int> stlZList = phantom->GetZList();
+  NumZ = stlZList.size();
+  ZList = IVecAllocate(NumZ);
+  for (unsigned i=0;i<stlZList.size();i++)
+    ZList[i] = stlZList[i];
+  // Build the map of Z to index
+  mZmap = IVecAllocate(MaxZ);
+  for (int i=0;i<NumZ;i++) 
+    mZmap[ZList[i]] = i;
+  NumE = (int) ((MaxEnergy - MinEnergy)/DeltEnergy+1);
+  mCSDiscreteZvsEBarns = MatrixAllocate(NumZ,NumE);
+  mCSDiscreteZvsEMAC = MatrixAllocate(NumZ,NumE);
+  for (int j=0;j<NumZ;j++) {
+    int Z = ZList[j];
+    for (int i=0;i<NumE;i++) {
+      float Energy = MinEnergy + i*DeltEnergy;
+      mCSDiscreteZvsEBarns[j][i] = cs.GetValue(Z,Energy/1.e6);
+      mCSDiscreteZvsEMAC[j][i] = mCSDiscreteZvsEBarns[j][i]*0.6022/AtomicMass[Z]/10.0;
+    }
+  }
+  rhoStore = VecAllocate(NumZ);
+}
+
+int CrossSectionHandler::MapEnergyToBin(float Energy) {
+  return((int) rint((Energy-mMinEnergy)/mDeltEnergy));
+}
+
+float CrossSectionHandler::GetIntegratedCrossSectionBarns(int Z, float Energy) {
+  int Ebin = MapEnergyToBin(Energy);
+  if (Ebin < 0) return 1e10;
+  assert(Ebin < NumE);
+  return mCSDiscreteZvsEBarns[mZmap[Z]][Ebin];
+}
+
+float CrossSectionHandler::GetIntegratedCrossSectionMAC(int Z, float Energy) {
+  int Ebin = MapEnergyToBin(Energy);
+  if (Ebin < 0) return 1e10;
+  assert(Ebin < NumE);
+  return mCSDiscreteZvsEMAC[mZmap[Z]][Ebin];
+}
+
+float CrossSectionHandler::GetIntegratedCrossSectionMAC(Photon &p) {
+  mPhantom->GetDensities(p,rhoStore);
+  int Ebin = MapEnergyToBin(p.GetEnergy());
+  assert(Ebin < NumE);
+  float CS = 0;
+  for (int i=0;i<NumZ;i++) 
+    CS += mCSDiscreteZvsEMAC[mZmap[ZList[i]]][Ebin]*rhoStore[i];
+  return CS;
+}
+
+float CrossSectionHandler::GetIntegratedCrossSectionMuL(float Energy, Vec rhoL) {
+  int Ebin = MapEnergyToBin(Energy);
+  assert(Ebin < NumE);
+  float CS = 0;
+  for (int i=0;i<NumZ;i++) 
+    CS += mCSDiscreteZvsEMAC[mZmap[ZList[i]]][Ebin]*rhoL[i];
+  return CS;
+}
+
+vector<float> CrossSectionHandler::GetZProbabilities(Photon &p) {
+  vector<float> ret;
+  mPhantom->GetDensities(p,rhoStore);
+  float totalCS = GetIntegratedCrossSectionMAC(p);
+  int Ebin = MapEnergyToBin(p.GetEnergy());
+  assert(Ebin < NumE);
+  for (int i=0;i<NumZ;i++)
+    ret.push_back(mCSDiscreteZvsEMAC[mZmap[ZList[i]]][Ebin]*rhoStore[i]/totalCS);
+  return ret;
+}
+
+int CrossSectionHandler::GetRandomAtom(Photon &p) {
+  return 1;
+}
+
+

gecatsim/clib_build/src/CrossSectionHandler.hpp

@@ -0,0 +1,72 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#ifndef __CrossSectionHandler_hpp__
+#define __CrossSectionHandler_hpp__
+
+#include "Phantom.hpp"
+#include "Volume.hpp"
+#include <vector>
+#include "Photon.hpp"
+#include "CrossSection.hpp"
+
+const int MaxZ = 92;
+
+class BaseDiscreteTable {
+  Mat mValues;
+  float mMinX;
+  float mMaxX;
+  float mDeltX;
+  int NumZ;
+  int NumX;
+  int MapXToBin(float x);
+public:
+  void InitializeTable(int numZ, float MinX, float MaxX, float DeltX);
+  Mat GetRawTable();
+  float GetValue(int Z, float X);
+};
+
+class DiscreteTable {
+  Mat mValues;
+  float mMinX;
+  float mMaxX;
+  float mDeltX;
+  int NumZ;
+  int NumX;
+  IVec mZmap;
+  IVec ZList;
+  int MapXToBin(float x);
+public:
+  void InitializeTable(Phantom *phantom, CrossSection& cs, 
+		       float MinX, float MaxX, float DeltX);
+  float GetValue(int Z, float X);
+};
+
+class CrossSectionHandler {
+  Phantom *mPhantom;
+  Mat mCSDiscreteZvsEBarns;
+  Mat mCSDiscreteZvsEMAC;
+  IVec mZmap;
+  IVec ZList;
+  int NumZ;
+  int NumE;
+  int MapEnergyToBin(float Energy);
+  Vec rhoStore;
+  float mMaxEnergy;
+  float mMinEnergy;
+  float mDeltEnergy;
+public:
+  void InitializeHandler(Phantom *phantom, CrossSection& cs, 
+			 float MinEnergy, float MaxEnergy,
+			 float DeltEnergy);
+  int GetRandomAtom(Photon &p);
+  vector<float> GetZProbabilities(Photon &p);
+  float GetIntegratedCrossSectionBarns(int Z, float Energy);
+  float GetIntegratedCrossSectionMAC(int Z, float Energy);
+  float GetIntegratedCrossSectionMAC(Photon &p);
+  float GetIntegratedCrossSectionMuL(float Energy, Vec rhoL);
+};
+
+float GetAtomicMass(int Z);
+
+#endif
+

gecatsim/clib_build/src/Cube.cpp

@@ -0,0 +1,144 @@
+// Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+#include "Cube.h"
+#include <math.h>
+
+Cube::Cube() : BaseObject() {
+}
+
+Cube::~Cube() {
+}
+
+void Cube::WriteVRML(std::ostream& c) {
+  xform.WriteVRMLCode(c);
+  c << "Shape { appearance USE App1 geometry Box { size 1.0 1.0 1.0 } }\n";
+  xform.CloseVRMLCode(c);  
+}
+
+void Cube::PrintMe(std::ostream& c) {
+  c << "Object Cube \n";
+  BaseObject::PrintMe(c);
+}
+
+double Cube::CalculateBoundingRadius() {
+  return sqrt(3.0/4.0);
+}
+
+IntersectionSet Cube::ObjectVoxelIntersect(Vec3 src, Vec3 det) {
+	return IntersectionSet();
+}
+
+void Cube::ObjectPathIntersect(Vec3 src, Vec3 delta, IntersectionSet &T) {
+  double times[6];
+  char planes[6];
+  double coefAX = delta.x;
+  double coefAY = delta.y;
+  double coefAZ = delta.z;
+  double coefBXMinus = src.x + 1.0/2.0;
+  double coefBXPlus = src.x - 1.0/2.0;
+  double coefBYMinus = src.y + 1.0/2.0;
+  double coefBYPlus = src.y - 1.0/2.0;
+  double coefBZMinus = src.z + 1.0/2.0;
+  double coefBZPlus = src.z - 1.0/2.0;
+  // Determine if the ray is parallel to one set of the planes.
+  int noIntersectionFlag = 0;
+  if (coefAX == 0.0)  // The ray is parallel to the plane.
+    {
+      if (((-1.0/2.0) <= src.x) && (src.x <= (1.0/2.0)))
+	{
+	  times[0] = -INFTY;
+	  times[1] = INFTY;
+	  planes[0] = 'x';
+	  planes[1] = 'x';
+	}
+      else  // The ray is outside the 2 planes.
+	{
+	  noIntersectionFlag = 1;
+	}
+    }
+  else  // The ray intersects the 2 planes.
+    {
+      times[0] = -coefBXMinus/coefAX;
+      times[1] = -coefBXPlus/coefAX;
+      planes[0] = 'x';
+      planes[1] = 'x';
+    }
+  if (!noIntersectionFlag)
+    {
+      if (coefAY == 0.0)  // The ray is parallel to the planes.
+	{
+	  if (((-1.0/2.0) <= src.y) && (src.y <= (1.0/2.0)))
+	    {
+	      times[2] = -2.0 * INFTY;
+	      times[3] = 2.0 * INFTY;
+	      planes[2] = 'y';
+	      planes[3] = 'y';
+	    }
+	  else  // The ray is outside the planes.
+	    {
+	      noIntersectionFlag = 1;
+	    }
+	}
+      else  // The ray intersects the 2 planes.
+	{
+	  times[2] = -coefBYMinus/coefAY;
+	  times[3] = -coefBYPlus/coefAY;
+	  planes[2] = 'y';
+	  planes[3] = 'y';
+	}
+    }
+
+  if (!noIntersectionFlag)
+    {
+      if (coefAZ == 0.0)  // The ray is parallel to te 2 planes.
+	{
+	  if (((-1.0/2.0) <= src.z) && (src.z <= (1.0/2.0)))
+	    {
+	      times[4] = -3.0 * INFTY;
+	      times[5] = 3.0 * INFTY;
+	      planes[4] = 'z';
+	      planes[5] = 'z';
+	    }
+	  else   // The ray is outside the 2 planes.
+	    {
+	      noIntersectionFlag = 1;
+	    }
+	}
+      else  // The ray intersects the 2 planes.
+	{
+	  times[4] = -coefBZMinus/coefAZ;
+	  times[5] = -coefBZPlus/coefAZ;
+	  planes[4] = 'z';
+	  planes[5] = 'z';
+	}
+    }
+  // Order the times, if necessary.
+  if (!noIntersectionFlag)
+    {
+      for (int i=0;i<5;i++)
+	for (int j=0;j<5;j++)
+	  {
+	    if (times[j] > times[j+1])
+	      {
+		double tempTime;
+		char tempPlane;
+		
+		tempTime = times[j];
+		tempPlane = planes[j];
+		times[j] = times[j+1];
+		planes[j] = planes[j+1];
+		times[j+1] = tempTime;
+		planes[j+1] = tempPlane;
+	      }
+	  }
+      // Check for valid combinations.  Basically, the first 3 letters of the "planes" string
+      // cannot contain 2 of the same letters.
+      if ((planes[0] != planes[1]) && (planes[1] != planes[2]) && (planes[0] != planes[2]))
+	{
+	  T.push_back(Intersection(my_ID,times[2],true,density,priority,material));
+	  T.push_back(Intersection(my_ID,times[3],false,density,priority,material));
+	}
+    }
+}
+
+
+