SimulationDataStructures.h

Go to the documentation of this file.

//Constructed by Josh Brown.
//brown.ja@berkeley.edu
#ifndef _SIMULATION_DATA_STRUCTURES_H_
#define _SIMULATION_DATA_STRUCTURES_H_
 
 
#ifdef OSLY_PRESENT
#include "OScintLightYield.h"
#endif
 
 
#ifndef  __ROOTCLING__
#include "G4VHit.hh"
#include "G4THitsCollection.hh"
#include "G4Allocator.hh"
#include "G4ThreeVector.hh"
#include "G4Step.hh"
#else
#endif
 
#include <string>
#include <vector>
#include <iostream> 
#include <cmath> 
namespace NSDG4
{
class VertexInfo
{
public:
  float m_x;
  float m_y;
  float m_z;
  float m_kE;
  double m_t;
  // float m_w;
};
 
 
class stepInfo
{
public:
  float m_x;
  float m_y;
  float m_z;
  float m_kE;
  float m_ED;
  double m_t;
  int m_lvID;
  double inline getDeltaL(stepInfo a_rhs);
};
 
 
class ScintEventInfo
{
public:
  int m_lvID;
  double m_amplitude;
  double m_initPartEnergy;
  double m_time;
};
// #ifndef  __ROOTCLING__
// class TrackInfo : public G4VHit
 
// #else
class TrackInfo
// #endif
{
public:
  TrackInfo();
 
  //setters
  void setTrackID(int a_trackID);
  void setParentTrackID(int a_parentTrackID);
  void setlvID(int a_lvID);
  void setLvName(std::string a_lvName);
  void setParticleName(std::string a_particleName);
  void setCreatorProcess(std::string a_creatorProcess);
  void setVertexInfo(const VertexInfo& a_vertexInfo);
  void setPostSteps(const std::vector<stepInfo>& a_postSteps);
 
  //getters
  int getTrackID() const;
  int getParentTrackID() const;
  int getlvID() const;
  std::string getLvName() const;
  std::string getParticleName() const;
  std::string getCreatorProcess() const;
  VertexInfo getVertexInfo() const;
  std::vector<stepInfo> getPostSteps() const;
  std::ostream& printInfo(std::ostream& a_stream=std::cout);
 
 
 
#ifdef OSLY_PRESENT
  double getLight(OScintLightYield& a_ly);
#endif
  double getTotalED();
  double getTime();
  bool fullyStopped(double a_fraction=0.97);
  std::vector<float> getDTheta();
 
  float  getMeanED(float& a_x,
                   float& a_y,
                   float& a_z
                   );
 
//stuff hidden from root used in geant
#ifndef __ROOTCLING__
  void initialize(G4Step* a_step, int a_lvID=0);
  void addStep(G4Step* a_step, int a_lvID=0);
#endif
 
private:
  int m_trackID;
  int m_parentTrackID;
  int m_lvID;
  std::string m_lvName;
  std::string m_particleName;
  std::string m_creatorProcess;
  VertexInfo m_vertexInfo;
  std::vector<stepInfo> m_postSteps;
};
 
 
class FullEvent
{
public:
  std::ostream& printInfo(std::ostream& a_stream=std::cout);  
  std::vector<TrackInfo> m_tracks;
  //for the particle generated at the beginning of the event
  double m_primEnergy;
  double m_primTheta;
  double m_primPhi;
  std::vector<ScintEventInfo> getScintEventInfo(std::string a_lvName
                                               );
  //calculations
  bool hasED();
  bool hasParticles(std::vector<std::string> a_partList,
                    std::string              a_lvName =""
                    );
 
  //this function gets returns a vector of the tracks associated with a 
  //specific logical volume
  std::vector<TrackInfo> getTracks(std::string a_lvName);
  std::vector<TrackInfo> getTracks(std::vector<std::string> a_lvList);
  std::vector<double> getSourcePosition();
  
};
 
#ifndef __ROOTCLING__
class TrackInfoHit : public G4VHit
{
public:
  inline void* operator new(size_t);
  inline void  operator delete(void*);
};
 
typedef G4THitsCollection<TrackInfoHit> TrackInfoHitCollection;
 
extern G4ThreadLocal G4Allocator<TrackInfoHit>* TrackInfoHitAllocator;
 
inline void* TrackInfoHit::operator new(size_t)
{
  if(!TrackInfoHitAllocator)
      TrackInfoHitAllocator = new G4Allocator<TrackInfoHit>;
  return (void *) TrackInfoHitAllocator->MallocSingle();
}
 
inline void TrackInfoHit::operator delete(void *hit)
{
  TrackInfoHitAllocator->FreeSingle((TrackInfoHit*) hit);
}
#endif
 
double stepInfo::getDeltaL(stepInfo a_rhs)
{
  double delX = m_x - a_rhs.m_x;
  double delY = m_y - a_rhs.m_y;
  double delZ = m_z - a_rhs.m_z;
  return std::sqrt(delX*delX+delY*delY+delZ*delZ);
}
 
 
class OpticalPhotonEvent
{
public:
  double m_initialEnergy;
  int m_numberOfBounces;
  bool m_isDetected;
};
 
}
 
#endif