#include <Doxymodules_exoticphysics.h>

Inheritance diagram for XAluminumElectrodeSensitivity:

Public Member Functions
	XAluminumElectrodeSensitivity (const G4String &)

virtual	~XAluminumElectrodeSensitivity ()

virtual void	Initialize (G4HCofThisEvent *)

virtual G4bool	ProcessHits (G4Step , G4TouchableHistory )

virtual void	EndOfEvent (G4HCofThisEvent *)

XAluminumElectrodeHitsCollection *	GetHitsCollection ()

Protected Member Functions
void	WriteHitInfo (const XAluminumElectrodeHit *aHit)

Private Attributes
XAluminumElectrodeHitsCollection *	fHitsCollection

G4int	fHCID

Static Private Attributes
static std::fstream *	fWriter = 0

static std::fstream *	fWriter2 = 0

Detailed Description

Definition at line 47 of file Doxymodules_exoticphysics.h.

Constructor & Destructor Documentation

◆ XAluminumElectrodeSensitivity()

XAluminumElectrodeSensitivity::XAluminumElectrodeSensitivity ( const G4String & name )

Definition at line 52 of file XAluminumElectrodeSensitivity.cc.

 : G4VSensitiveDetector(name) {
  collectionName.insert("XAluminumElectrodeHit");
  fHCID = -1;
 
  G4AutoLock lockIt(&theMutex);                // Only one thread opens files!
  fWriter = new std::fstream("caustic.ssv",std::fstream::out|std::fstream::ate);
  if (!fWriter->is_open()) {
    G4cerr << "XAluminumElectrodeSensitivity::Constructor:"
           << "\n\tFailed to open caustic.ssv for appending data."
           << "\n\tCreating caustic.ssv" << G4endl;
    fWriter->open("caustic.ssv");
  }
 
  fWriter2 = new std::fstream("timing.ssv",std::fstream::out|std::fstream::ate);
  if (!fWriter2->is_open()) {
    G4cerr << "XAluminumElectrodeSensitivity::Constructor: "
           << "\n\tFailed to open timing.ssv for appending data."
           << "\n\tCreating timing.ssv." << G4endl;
    fWriter2->open("timing.ssv");
  }
 
  if (!(fWriter->is_open() && fWriter2->is_open())) {
    G4cerr << "XAluminumElectrodeSensitivity::Constructor: "
           << "\nERROR: COULD NOT CREATE OUTPUT FILES FOR WRITING" << G4endl;
  }
}

◆ ~XAluminumElectrodeSensitivity()

XAluminumElectrodeSensitivity::~XAluminumElectrodeSensitivity ( )

virtual

Definition at line 83 of file XAluminumElectrodeSensitivity.cc.

                                                              {
  G4AutoLock lockIt(&theMutex);                // Only one thread deletes!
 
  if (fWriter) {
    fWriter->close();
    delete fWriter; fWriter = 0;
  }
 
  if (fWriter2) {
    fWriter2->close();
    delete fWriter2; fWriter2 = 0;
  }
}

Member Function Documentation

◆ Initialize()

void XAluminumElectrodeSensitivity::Initialize ( G4HCofThisEvent * HCE )

virtual

Definition at line 106 of file XAluminumElectrodeSensitivity.cc.

{
  fHitsCollection =
    new XAluminumElectrodeHitsCollection(SensitiveDetectorName,
                                         collectionName[0]);
  if (fHCID<0)
  { fHCID = G4SDManager::GetSDMpointer()->GetCollectionID(fHitsCollection); }
  HCE->AddHitsCollection(fHCID,fHitsCollection);
}

◆ ProcessHits()

G4bool XAluminumElectrodeSensitivity::ProcessHits	(	G4Step *	aStep,
		G4TouchableHistory *
	)

virtual

Definition at line 118 of file XAluminumElectrodeSensitivity.cc.

{
  //if(aStep->GetTrack()->GetDefinition()!=Phonon::PhononDefinition()) return true;
  G4double edp = aStep->GetNonIonizingEnergyDeposit();
  if(edp==0.) return true;
 
  G4StepPoint* preStepPoint = aStep->GetPreStepPoint();
  G4StepPoint* postStepPoint = aStep->GetPostStepPoint();
  G4TouchableHistory* theTouchable
    = (G4TouchableHistory*)(preStepPoint->GetTouchable());
  G4ThreeVector fWorldPos = postStepPoint->GetPosition();
  G4ThreeVector fLocalPos
    = theTouchable->GetHistory()->GetTopTransform().TransformPoint(fWorldPos);
 
  XAluminumElectrodeHit* aHit = new XAluminumElectrodeHit();
  aHit->fTime = postStepPoint->GetGlobalTime();
  aHit->fEdep = edp;
  aHit->fWorldPos = fWorldPos;
  aHit->fLocalPos = fLocalPos;
 
  fHitsCollection->insert(aHit);
 
  return true;
}

◆ EndOfEvent()

void XAluminumElectrodeSensitivity::EndOfEvent ( G4HCofThisEvent * )

virtual

Definition at line 146 of file XAluminumElectrodeSensitivity.cc.

                                                                 {
  if (!fHitsCollection || fHitsCollection->GetSize()==0) return;
 
  for (size_t i=0; i<fHitsCollection->GetSize(); i++) {
    WriteHitInfo(dynamic_cast<XAluminumElectrodeHit*>(fHitsCollection->GetHit(i)));
  }
}

◆ GetHitsCollection()

XAluminumElectrodeHitsCollection * XAluminumElectrodeSensitivity::GetHitsCollection ( )

Definition at line 100 of file XAluminumElectrodeSensitivity.cc.

                                                 {
  return fHitsCollection;
}

◆ WriteHitInfo()

void XAluminumElectrodeSensitivity::WriteHitInfo ( const XAluminumElectrodeHit * aHit )

protected

Definition at line 156 of file XAluminumElectrodeSensitivity.cc.

                                                {
  if (!aHit) return;
 
  G4AutoLock lockIt(&theMutex);          // Only one event can write at a time
 
  *fWriter        << aHit->fWorldPos.getX()/mm
           << "," << aHit->fWorldPos.getY()/mm
           << "," << aHit->fWorldPos.getZ()/mm
           << "\n";
 
  *fWriter2 << aHit->fTime/ns << " " << aHit->fEdep/eV << "\n";
}