Gabriele Cosmo
589 lines
19 KiB
C++
589 lines
19 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
/*
|
|
* =============================================================================
|
|
*
|
|
* Filename: CexmcEnergyDepositDigitizer.hh
|
|
*
|
|
* Description: digitizes of energy deposit in a single event
|
|
*
|
|
* Version: 1.0
|
|
* Created: 23.11.2009 14:14:47
|
|
* Revision: none
|
|
* Compiler: gcc
|
|
*
|
|
* Author: Alexey Radkov (),
|
|
* Company: PNPI
|
|
*
|
|
* =============================================================================
|
|
*/
|
|
|
|
#ifndef CEXMC_ENERGY_DEPOSIT_DIGITIZER_HH
|
|
#define CEXMC_ENERGY_DEPOSIT_DIGITIZER_HH
|
|
|
|
#include <iosfwd>
|
|
#include <G4VDigitizerModule.hh>
|
|
#include <G4SystemOfUnits.hh>
|
|
#include "CexmcEnergyDepositStore.hh"
|
|
#include "CexmcSimpleRangeWithValue.hh"
|
|
#include "CexmcException.hh"
|
|
#include "CexmcCommon.hh"
|
|
|
|
class G4String;
|
|
class CexmcEnergyDepositDigitizerMessenger;
|
|
|
|
|
|
class CexmcEnergyDepositDigitizer : public G4VDigitizerModule
|
|
{
|
|
public:
|
|
explicit CexmcEnergyDepositDigitizer( const G4String & name );
|
|
|
|
~CexmcEnergyDepositDigitizer();
|
|
|
|
public:
|
|
void Digitize( void );
|
|
|
|
public:
|
|
G4double GetMonitorED( void ) const;
|
|
|
|
G4double GetVetoCounterEDLeft( void ) const;
|
|
|
|
G4double GetVetoCounterEDRight( void ) const;
|
|
|
|
G4double GetCalorimeterEDLeft( void ) const;
|
|
|
|
G4double GetCalorimeterEDRight( void ) const;
|
|
|
|
G4int GetCalorimeterEDLeftMaxX( void ) const;
|
|
|
|
G4int GetCalorimeterEDLeftMaxY( void ) const;
|
|
|
|
G4int GetCalorimeterEDRightMaxX( void ) const;
|
|
|
|
G4int GetCalorimeterEDRightMaxY( void ) const;
|
|
|
|
const CexmcEnergyDepositCalorimeterCollection &
|
|
GetCalorimeterEDLeftCollection( void ) const;
|
|
|
|
const CexmcEnergyDepositCalorimeterCollection &
|
|
GetCalorimeterEDRightCollection( void ) const;
|
|
|
|
public:
|
|
G4bool MonitorHasTriggered( void ) const;
|
|
|
|
G4bool HasTriggered( void ) const;
|
|
|
|
public:
|
|
void SetMonitorThreshold( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetVetoCounterLeftThreshold( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetVetoCounterRightThreshold( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetVetoCountersThreshold( G4double value );
|
|
|
|
void SetCalorimeterLeftThreshold( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetCalorimeterRightThreshold( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetCalorimetersThreshold( G4double value );
|
|
|
|
void SetCalorimeterTriggerAlgorithm(
|
|
CexmcCalorimeterTriggerAlgorithm value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetOuterCrystalsVetoAlgorithm(
|
|
CexmcOuterCrystalsVetoAlgorithm value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void SetOuterCrystalsVetoFraction( G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void ApplyFiniteCrystalResolution( G4bool value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void AddCrystalResolutionRange( G4double bottom, G4double top,
|
|
G4double value,
|
|
G4bool fromMessenger = true );
|
|
|
|
void ClearCrystalResolutionData( G4bool fromMessenger = true );
|
|
|
|
void SetCrystalResolutionData(
|
|
const CexmcEnergyRangeWithDoubleValueList & data );
|
|
|
|
G4double GetMonitorThreshold( void ) const;
|
|
|
|
G4double GetVetoCounterLeftThreshold( void ) const;
|
|
|
|
G4double GetVetoCounterRightThreshold( void ) const;
|
|
|
|
G4double GetCalorimeterLeftThreshold( void ) const;
|
|
|
|
G4double GetCalorimeterRightThreshold( void ) const;
|
|
|
|
CexmcCalorimeterTriggerAlgorithm
|
|
GetCalorimeterTriggerAlgorithm( void ) const;
|
|
|
|
CexmcOuterCrystalsVetoAlgorithm
|
|
GetOuterCrystalsVetoAlgorithm( void ) const;
|
|
|
|
G4double GetOuterCrystalsVetoFraction( void ) const;
|
|
|
|
G4bool IsFiniteCrystalResolutionApplied( void ) const;
|
|
|
|
const CexmcEnergyRangeWithDoubleValueList &
|
|
GetCrystalResolutionData( void ) const;
|
|
|
|
public:
|
|
G4bool IsOuterCrystal( G4int column, G4int row ) const;
|
|
|
|
private:
|
|
void InitializeData( void );
|
|
|
|
private:
|
|
G4double monitorED;
|
|
|
|
G4double vetoCounterEDLeft;
|
|
|
|
G4double vetoCounterEDRight;
|
|
|
|
CexmcEnergyDepositCalorimeterCollection calorimeterEDLeftCollection;
|
|
|
|
CexmcEnergyDepositCalorimeterCollection calorimeterEDRightCollection;
|
|
|
|
G4double calorimeterEDLeft;
|
|
|
|
G4double calorimeterEDRight;
|
|
|
|
G4int calorimeterEDLeftMaxX;
|
|
|
|
G4int calorimeterEDLeftMaxY;
|
|
|
|
G4int calorimeterEDRightMaxX;
|
|
|
|
G4int calorimeterEDRightMaxY;
|
|
|
|
G4bool monitorHasTriggered;
|
|
|
|
G4bool hasTriggered;
|
|
|
|
private:
|
|
G4double monitorEDThreshold;
|
|
|
|
G4double vetoCounterEDLeftThreshold;
|
|
|
|
G4double vetoCounterEDRightThreshold;
|
|
|
|
G4double calorimeterEDLeftThreshold;
|
|
|
|
G4double calorimeterEDRightThreshold;
|
|
|
|
CexmcCalorimeterTriggerAlgorithm calorimeterTriggerAlgorithm;
|
|
|
|
CexmcOuterCrystalsVetoAlgorithm outerCrystalsVetoAlgorithm;
|
|
|
|
G4double outerCrystalsVetoFraction;
|
|
|
|
G4double monitorEDThresholdRef;
|
|
|
|
G4double vetoCounterEDLeftThresholdRef;
|
|
|
|
G4double vetoCounterEDRightThresholdRef;
|
|
|
|
G4double calorimeterEDLeftThresholdRef;
|
|
|
|
G4double calorimeterEDRightThresholdRef;
|
|
|
|
CexmcCalorimeterTriggerAlgorithm calorimeterTriggerAlgorithmRef;
|
|
|
|
CexmcOuterCrystalsVetoAlgorithm outerCrystalsVetoAlgorithmRef;
|
|
|
|
G4double outerCrystalsVetoFractionRef;
|
|
|
|
private:
|
|
G4int nCrystalsInColumn;
|
|
|
|
G4int nCrystalsInRow;
|
|
|
|
private:
|
|
G4bool applyFiniteCrystalResolution;
|
|
|
|
CexmcEnergyRangeWithDoubleValueList crystalResolutionData;
|
|
|
|
private:
|
|
CexmcEnergyDepositDigitizerMessenger * messenger;
|
|
};
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetMonitorED( void ) const
|
|
{
|
|
return monitorED;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetVetoCounterEDLeft( void ) const
|
|
{
|
|
return vetoCounterEDLeft;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetVetoCounterEDRight( void )
|
|
const
|
|
{
|
|
return vetoCounterEDRight;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetCalorimeterEDLeft( void ) const
|
|
{
|
|
return calorimeterEDLeft;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetCalorimeterEDRight( void )
|
|
const
|
|
{
|
|
return calorimeterEDRight;
|
|
}
|
|
|
|
|
|
inline G4int CexmcEnergyDepositDigitizer::GetCalorimeterEDLeftMaxX( void )
|
|
const
|
|
{
|
|
return calorimeterEDLeftMaxX;
|
|
}
|
|
|
|
|
|
inline G4int CexmcEnergyDepositDigitizer::GetCalorimeterEDLeftMaxY( void )
|
|
const
|
|
{
|
|
return calorimeterEDLeftMaxY;
|
|
}
|
|
|
|
|
|
inline G4int CexmcEnergyDepositDigitizer::GetCalorimeterEDRightMaxX( void )
|
|
const
|
|
{
|
|
return calorimeterEDRightMaxX;
|
|
}
|
|
|
|
|
|
inline G4int CexmcEnergyDepositDigitizer::GetCalorimeterEDRightMaxY( void )
|
|
const
|
|
{
|
|
return calorimeterEDRightMaxY;
|
|
}
|
|
|
|
|
|
inline const CexmcEnergyDepositCalorimeterCollection &
|
|
CexmcEnergyDepositDigitizer::GetCalorimeterEDLeftCollection( void ) const
|
|
{
|
|
return calorimeterEDLeftCollection;
|
|
}
|
|
|
|
|
|
inline const CexmcEnergyDepositCalorimeterCollection &
|
|
CexmcEnergyDepositDigitizer::GetCalorimeterEDRightCollection( void ) const
|
|
{
|
|
return calorimeterEDRightCollection;
|
|
}
|
|
|
|
|
|
inline G4bool CexmcEnergyDepositDigitizer::MonitorHasTriggered( void ) const
|
|
{
|
|
return monitorHasTriggered;
|
|
}
|
|
|
|
|
|
inline G4bool CexmcEnergyDepositDigitizer::HasTriggered( void ) const
|
|
{
|
|
return hasTriggered;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetMonitorThreshold(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value < monitorEDThresholdRef );
|
|
else
|
|
monitorEDThresholdRef = value;
|
|
|
|
monitorEDThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetVetoCounterLeftThreshold(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value > vetoCounterEDLeftThresholdRef );
|
|
else
|
|
vetoCounterEDLeftThresholdRef = value;
|
|
|
|
vetoCounterEDLeftThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetVetoCounterRightThreshold(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value > vetoCounterEDRightThresholdRef );
|
|
else
|
|
vetoCounterEDRightThresholdRef = value;
|
|
|
|
vetoCounterEDRightThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetVetoCountersThreshold(
|
|
G4double value )
|
|
{
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value > vetoCounterEDLeftThresholdRef ||
|
|
value > vetoCounterEDRightThresholdRef );
|
|
|
|
vetoCounterEDLeftThreshold = value;
|
|
vetoCounterEDRightThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetCalorimeterLeftThreshold(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value < calorimeterEDLeftThresholdRef );
|
|
else
|
|
calorimeterEDLeftThresholdRef = value;
|
|
|
|
calorimeterEDLeftThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetCalorimeterRightThreshold(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value < calorimeterEDRightThresholdRef );
|
|
else
|
|
calorimeterEDRightThresholdRef = value;
|
|
|
|
calorimeterEDRightThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetCalorimetersThreshold(
|
|
G4double value )
|
|
{
|
|
ThrowExceptionIfProjectIsRead( CexmcBadThreshold,
|
|
value < calorimeterEDLeftThresholdRef ||
|
|
value < calorimeterEDRightThresholdRef );
|
|
|
|
calorimeterEDLeftThreshold = value;
|
|
calorimeterEDRightThreshold = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetCalorimeterTriggerAlgorithm(
|
|
CexmcCalorimeterTriggerAlgorithm value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadCalorimeterTriggerAlgorithm,
|
|
! ( calorimeterTriggerAlgorithmRef ==
|
|
CexmcAllCrystalsMakeEDTriggerThreshold ||
|
|
value == calorimeterTriggerAlgorithmRef ) );
|
|
else
|
|
calorimeterTriggerAlgorithmRef = value;
|
|
|
|
calorimeterTriggerAlgorithm = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetOuterCrystalsVetoAlgorithm(
|
|
CexmcOuterCrystalsVetoAlgorithm value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadOCVetoAlgorithm,
|
|
! ( outerCrystalsVetoAlgorithmRef == CexmcNoOuterCrystalsVeto ||
|
|
value == outerCrystalsVetoAlgorithmRef ) );
|
|
else
|
|
outerCrystalsVetoAlgorithmRef = value;
|
|
|
|
outerCrystalsVetoAlgorithm = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetOuterCrystalsVetoFraction(
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcBadOCVetoFraction,
|
|
value > outerCrystalsVetoFractionRef );
|
|
else
|
|
outerCrystalsVetoFractionRef = value;
|
|
|
|
outerCrystalsVetoFraction = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::ApplyFiniteCrystalResolution(
|
|
G4bool value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcCmdIsNotAllowed );
|
|
|
|
applyFiniteCrystalResolution = value;
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::AddCrystalResolutionRange(
|
|
G4double bottom, G4double top,
|
|
G4double value, G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcCmdIsNotAllowed );
|
|
|
|
/* range boundaries are given in GeV */
|
|
crystalResolutionData.push_back( CexmcEnergyRangeWithDoubleValue(
|
|
bottom * GeV, top * GeV, value ) );
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::ClearCrystalResolutionData(
|
|
G4bool fromMessenger )
|
|
{
|
|
if ( fromMessenger )
|
|
ThrowExceptionIfProjectIsRead( CexmcCmdIsNotAllowed );
|
|
|
|
crystalResolutionData.clear();
|
|
}
|
|
|
|
|
|
inline void CexmcEnergyDepositDigitizer::SetCrystalResolutionData(
|
|
const CexmcEnergyRangeWithDoubleValueList & data )
|
|
{
|
|
ClearCrystalResolutionData( false );
|
|
crystalResolutionData = data;
|
|
}
|
|
|
|
|
|
inline G4bool CexmcEnergyDepositDigitizer::IsOuterCrystal( G4int column,
|
|
G4int row ) const
|
|
{
|
|
return column == 0 || column == nCrystalsInRow - 1 ||
|
|
row == 0 || row == nCrystalsInColumn - 1;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetMonitorThreshold( void ) const
|
|
{
|
|
return monitorEDThreshold;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetVetoCounterLeftThreshold(
|
|
void ) const
|
|
{
|
|
return vetoCounterEDLeftThreshold;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetVetoCounterRightThreshold(
|
|
void ) const
|
|
{
|
|
return vetoCounterEDRightThreshold;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetCalorimeterLeftThreshold(
|
|
void ) const
|
|
{
|
|
return calorimeterEDLeftThreshold;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetCalorimeterRightThreshold(
|
|
void ) const
|
|
{
|
|
return calorimeterEDRightThreshold;
|
|
}
|
|
|
|
|
|
inline CexmcCalorimeterTriggerAlgorithm
|
|
CexmcEnergyDepositDigitizer::GetCalorimeterTriggerAlgorithm(
|
|
void ) const
|
|
{
|
|
return calorimeterTriggerAlgorithm;
|
|
}
|
|
|
|
|
|
inline CexmcOuterCrystalsVetoAlgorithm
|
|
CexmcEnergyDepositDigitizer::GetOuterCrystalsVetoAlgorithm(
|
|
void ) const
|
|
{
|
|
return outerCrystalsVetoAlgorithm;
|
|
}
|
|
|
|
|
|
inline G4double CexmcEnergyDepositDigitizer::GetOuterCrystalsVetoFraction(
|
|
void ) const
|
|
{
|
|
return outerCrystalsVetoFraction;
|
|
}
|
|
|
|
|
|
inline G4bool CexmcEnergyDepositDigitizer::IsFiniteCrystalResolutionApplied(
|
|
void ) const
|
|
{
|
|
return applyFiniteCrystalResolution;
|
|
}
|
|
|
|
|
|
inline const CexmcEnergyRangeWithDoubleValueList &
|
|
CexmcEnergyDepositDigitizer::GetCrystalResolutionData( void ) const
|
|
{
|
|
return crystalResolutionData;
|
|
}
|
|
|
|
|
|
std::ostream & operator<<( std::ostream & out,
|
|
const CexmcEnergyDepositCalorimeterCollection & edCollection );
|
|
|
|
|
|
#endif
|
|
|