MuonWallSD Class Reference

#include <MuonWallSD.h>

Inheritance diagram for MuonWallSD:

Collaboration diagram for MuonWallSD:

Public Member Functions
	MuonWallSD (const std::string &name, const std::string &hitCollectionName, int verbose)
	~MuonWallSD ()=default
void	StartOfAthenaEvent ()
void	Initialize (G4HCofThisEvent *) override final
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override final
void	EndOfAthenaEvent ()

Private Attributes
const TileTBID *	m_tileTBID {}
int	m_nhits [s_nCell]
TileSimHit *	m_hit [s_nCell]
Identifier	m_id [s_nCell]
SG::WriteHandle< TileHitVector >	m_HitColl

Static Private Attributes
static const int	s_nCellMu = 14
static const int	s_nCellS = 4
static const int	s_nCell = s_nCellMu+s_nCellS

Detailed Description

Definition at line 32 of file MuonWallSD.h.

Constructor & Destructor Documentation

MuonWallSD()

MuonWallSD::MuonWallSD	(	const std::string &	name,
		const std::string &	hitCollectionName,
		int	verbose
	)

Definition at line 27 of file MuonWallSD.cxx.

    : G4VSensitiveDetector(name),
    m_nhits(),
    m_hit(),
    m_HitColl(hitCollectionName)
{
  verboseLevel = std::max(verboseLevel, verbose);
 
  SmartIF<StoreGateSvc> detStore{Gaudi::svcLocator()->service("DetectorStore")};
  if ( !detStore ) {
    G4ExceptionDescription description;
    description << "Constructor: DetectorStoreSvc not found!";
    G4Exception("MuonWallSD", "NoDetStore", FatalException, description);
    abort();
  } else if (verboseLevel >= 5) {
    G4cout << "DetectorStoreSvc initialized" << G4endl;
  }
 
  if (detStore->retrieve(m_tileTBID).isFailure()) {
    G4ExceptionDescription description;
    description << "Constructor: No TileTBID helper!";
    G4Exception("MuonWallSD", "NoTileTBIDHelper", FatalException, description);
    abort();
  } else if (verboseLevel >= 5) {
    G4cout << "TileTBID helper retrieved" << G4endl;
  }
 
  int type=TileTBID::ADC_TYPE, module=TileTBID::BACK_WALL;
  for (int channel=0; channel<s_nCellMu; ++channel) {
    m_id[channel] = m_tileTBID->channel_id(type,module,channel);
  }
 
  module=TileTBID::CRACK_WALL;
  for (int channel=0; channel<s_nCellS; ++channel) {
    m_id[channel+s_nCellMu] = m_tileTBID->channel_id(type,module,channel);
  }
}

~MuonWallSD()

MuonWallSD::~MuonWallSD ( )

default

Member Function Documentation

EndOfAthenaEvent()

void MuonWallSD::EndOfAthenaEvent

(

)

Definition at line 142 of file MuonWallSD.cxx.

                                  {
  for (int ind = 0; ind < s_nCell; ++ind) {
    int nhit = m_nhits[ind];
    if (nhit > 0) {
      if (verboseLevel >= 5) {
        G4cout << "Cell id=" << m_tileTBID->to_string(m_id[ind])
               << " nhit=" << nhit
               << " ene=" << m_hit[ind]->energy() << G4endl;
      }
      m_HitColl->Insert(TileHit(m_hit[ind]));
      delete m_hit[ind];
    } else if (verboseLevel >= 10) {
      G4cout << "Cell id=" << m_tileTBID->to_string(m_id[ind])
             << " nhit=0" << G4endl;
    }
  }
 
  if (verboseLevel >= 5) {
    G4cout << "Total number of hits is " << m_HitColl->size() << G4endl;
  }
  return ;
}

Initialize()

void MuonWallSD::Initialize ( G4HCofThisEvent *  )

finaloverride

Definition at line 73 of file MuonWallSD.cxx.

                                              {
  if (verboseLevel >= 5) {
    G4cout << "MuonWallSD::Initialize()" << G4endl;
  }
 
  if (!m_HitColl.isValid()) {
    m_HitColl = std::make_unique<TileHitVector>(m_HitColl.name());
  }
}

ProcessHits()

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

finaloverride

Definition at line 83 of file MuonWallSD.cxx.

                                                                   {
  if (verboseLevel >= 10) {
    G4cout << "MuonWallSD::ProcessHits" << G4endl;
  }
 
  const G4TouchableHistory* theTouchable = (G4TouchableHistory*)(aStep->GetPreStepPoint()->GetTouchable());
  const G4VPhysicalVolume* physVol = theTouchable->GetVolume();
  const G4LogicalVolume* logiVol = physVol->GetLogicalVolume();
  const G4String nameLogiVol = logiVol->GetName();
  const G4int nScinti = physVol->GetCopyNo();
 
  const G4double edep = aStep->GetTotalEnergyDeposit() * aStep->GetTrack()->GetWeight();
  G4double stepl = 0.;
 
  if (aStep->GetTrack()->GetDefinition()->GetPDGCharge() != 0.){ // FIXME not-equal check on double
 
    stepl = aStep->GetStepLength();
  }
 
  if ((edep == 0.) && (stepl == 0.)) { //FIXME equality check on double
 
    return false;
  }
 
  int ind;
 
  if(nameLogiVol.find("MuScintillatorLayer") !=G4String::npos) {
    // for muon wall, nScinti-1 is the correct indice.
    ind = nScinti-1;
  } else if(nameLogiVol.find("S1") !=G4String::npos) {
    ind = s_nCellMu + 0;
  } else if(nameLogiVol.find("S2") !=G4String::npos) {
    ind = s_nCellMu + 1;
  } else if(nameLogiVol.find("S3") !=G4String::npos) {
    ind = s_nCellMu + 2;
  } else {
    ind = s_nCellMu + 3;
  }
 
  if (verboseLevel >= 10) {
    G4cout << ((m_nhits[ind] > 0)?"Additional hit in ":"First hit in ")
           << ((ind<s_nCellMu)?"MuonWall ":"beam counter S")
           << ((ind<s_nCellMu)?nScinti:(ind-s_nCellMu+1))
           << " time=" << aStep->GetPostStepPoint()->GetGlobalTime()
           << " ene=" << edep << G4endl;
  }
 
  if ( m_nhits[ind] > 0 ) {
    m_hit[ind]->add(edep,0.0,0.0);
  } else {
    // First hit in a cell
    m_hit[ind] = new TileSimHit(m_id[ind],edep,0.0,0.0);
  }
 
  ++m_nhits[ind];
 
  return true;
}

StartOfAthenaEvent()

void MuonWallSD::StartOfAthenaEvent

(

)

Definition at line 65 of file MuonWallSD.cxx.

                                    {
  if (verboseLevel >= 5) {
    G4cout << "Initializing SD" << G4endl;
  }
 
  memset(m_nhits, 0, sizeof(m_nhits));
}

Member Data Documentation

m_hit

TileSimHit* MuonWallSD::m_hit[s_nCell]

private

Definition at line 52 of file MuonWallSD.h.

m_HitColl

SG::WriteHandle<TileHitVector> MuonWallSD::m_HitColl

private

Definition at line 55 of file MuonWallSD.h.

m_id

Identifier MuonWallSD::m_id[s_nCell]

private

Definition at line 53 of file MuonWallSD.h.

m_nhits

int MuonWallSD::m_nhits[s_nCell]

private

Definition at line 51 of file MuonWallSD.h.

m_tileTBID

const TileTBID* MuonWallSD::m_tileTBID {}

private

Definition at line 45 of file MuonWallSD.h.

s_nCell

const int MuonWallSD::s_nCell = s_nCellMu+s_nCellS

staticprivate

Definition at line 49 of file MuonWallSD.h.

s_nCellMu

const int MuonWallSD::s_nCellMu = 14

staticprivate

Definition at line 47 of file MuonWallSD.h.

s_nCellS

const int MuonWallSD::s_nCellS = 4

staticprivate

Definition at line 48 of file MuonWallSD.h.

---

The documentation for this class was generated from the following files:

• MuonWallSD.h
• MuonWallSD.cxx