#include <PhotonVisibilityService.h>

Public Member Functions
	~PhotonVisibilityService ()

	PhotonVisibilityService (fhicl::ParameterSet const &pset)

void	reconfigure (fhicl::ParameterSet const &p)

double	GetQuenchingFactor (double dQdx) const

template<typename Point >
bool	HasVisibility (Point const &p, bool wantReflected=false) const

template<typename Point >
float	GetVisibility (Point const &p, unsigned int OpChannel, bool wantReflected=false) const

template<typename Point >
MappedCounts_t	GetAllVisibilities (Point const &p, bool wantReflected=false) const

void	LoadLibrary () const

void	StoreLibrary ()

void	StoreLightProd (int VoxID, double N)

void	RetrieveLightProd (int &VoxID, double &N) const

void	SetLibraryEntry (int VoxID, OpDetID_t libOpChannel, float N, bool wantReflected=false)

float	GetLibraryEntry (int VoxID, OpDetID_t libOpChannel, bool wantReflected=false) const

bool	HasLibraryEntries (int VoxID, bool wantReflected=false) const

phot::IPhotonLibrary::Counts_t	GetLibraryEntries (int VoxID, bool wantReflected=false) const

template<typename Point >
MappedT0s_t	GetReflT0s (Point const &p) const

void	SetLibraryReflT0Entry (int VoxID, int OpChannel, float value)

phot::IPhotonLibrary::Counts_t	GetLibraryReflT0Entries (int VoxID) const

float	GetLibraryReflT0Entry (int VoxID, OpDetID_t libOpChannel) const

template<typename Point >
MappedParams_t	GetTimingPar (Point const &p) const

void	SetLibraryTimingParEntry (int VoxID, int OpChannel, float value, size_t parnum)

phot::IPhotonLibrary::Params_t	GetLibraryTimingParEntries (int VoxID) const

float	GetLibraryTimingParEntry (int VoxID, OpDetID_t libOpChannel, size_t npar) const

template<typename Point >
MappedFunctions_t	GetTimingTF1 (Point const &p) const

void	SetLibraryTimingTF1Entry (int VoxID, int OpChannel, TF1 const &func)

phot::IPhotonLibrary::Functions_t	GetLibraryTimingTF1Entries (int VoxID) const

void	SetDirectLightPropFunctions (TF1 const *functions[8], double &d_break, double &d_max, double &tf1_sampling_factor) const

void	SetReflectedCOLightPropFunctions (TF1 const *functions[5], double &t0_max, double &t0_break_point) const

void	LoadTimingsForVUVPar (std::vector< std::vector< double >>(&v)[7], double &step_size, double &max_d, double &min_d, double &vuv_vgroup_mean, double &vuv_vgroup_max, double &inflexion_point_distance, double &angle_bin_timing_vuv) const

void	LoadTimingsForVISPar (std::vector< double > &distances, std::vector< double > &radial_distances, std::vector< std::vector< std::vector< double >>> &cut_off, std::vector< std::vector< std::vector< double >>> &tau, double &vis_vmean, double &angle_bin_timing_vis) const

void	LoadVUVSemiAnalyticProperties (bool &isFlatPDCorr, bool &isDomePDCorr, double &delta_angulo_vuv, double &radius) const

void	LoadGHFlat (std::vector< std::vector< double >> &GHvuvpars_flat, std::vector< double > &border_corr_angulo_flat, std::vector< std::vector< double >> &border_corr_flat) const

void	LoadGHDome (std::vector< std::vector< double >> &GHvuvpars_dome, std::vector< double > &border_corr_angulo_dome, std::vector< std::vector< double >> &border_corr_dome) const

void	LoadVisSemiAnalyticProperties (double &delta_angulo_vis, double &radius) const

void	LoadVisParsFlat (std::vector< double > &vis_distances_x_flat, std::vector< double > &vis_distances_r_flat, std::vector< std::vector< std::vector< double >>> &vispars_flat) const

void	LoadVisParsDome (std::vector< double > &vis_distances_x_dome, std::vector< double > &vis_distances_r_dome, std::vector< std::vector< std::vector< double >>> &vispars_dome) const

bool	IsBuildJob () const

bool	UseParameterization () const

bool	StoreReflected () const

bool	StoreReflT0 () const

bool	IncludeParPropTime () const

size_t	ParPropTimeNpar () const

std::string	ParPropTimeFormula () const

bool	IncludePropTime () const

bool	UseNhitsModel () const

bool	ApplyVISBorderCorrection () const

std::string	VISBorderCorrectionType () const

const sim::PhotonVoxelDef &	GetVoxelDef () const

size_t	NOpChannels () const

Static Public Member Functions
template<typename Point >
static double	DistanceToOpDet (Point const &p, unsigned int OpDet)

template<typename Point >
static double	SolidAngleFactor (Point const &p, unsigned int OpDet)

Private Types
using	LibraryIndex_t = phot::IPhotonMappingTransformations::LibraryIndex_t
	Type of optical library index. More...

Private Member Functions
geo::Point_t	LibLocation (geo::Point_t const &p) const

int	VoxelAt (geo::Point_t const &p) const

float	doGetVisibilityOfOpLib (geo::Point_t const &p, LibraryIndex_t libIndex, bool wantReflected=false) const

Private Attributes
int	fCurrentVoxel

double	fCurrentValue

float	fXmin

float	fXmax

float	fYmin

float	fYmax

float	fZmin

float	fZmax

int	fNx

int	fNy

int	fNz

bool	fUseCryoBoundary

bool	fLibraryBuildJob

bool	fDoNotLoadLibrary

bool	fParameterization

bool	fHybrid

bool	fStoreReflected

bool	fStoreReflT0

bool	fIncludePropTime

bool	fUseNhitsModel

bool	fApplyVISBorderCorrection

std::string	fVISBorderCorrectionType

bool	fParPropTime

size_t	fParPropTime_npar

std::string	fParPropTime_formula

int	fParPropTime_MaxRange

bool	fInterpolate

bool	fReflectOverZeroX

TF1 *	fparslogNorm = nullptr

TF1 *	fparslogNorm_far = nullptr

TF1 *	fparsMPV = nullptr

TF1 *	fparsMPV_far = nullptr

TF1 *	fparsWidth = nullptr

TF1 *	fparsCte = nullptr

TF1 *	fparsCte_far = nullptr

TF1 *	fparsSlope = nullptr

double	fD_break

double	fD_max

double	fTF1_sampling_factor

TF1 *	fparslogNorm_refl = nullptr

TF1 *	fparsMPV_refl = nullptr

TF1 *	fparsWidth_refl = nullptr

TF1 *	fparsCte_refl = nullptr

TF1 *	fparsSlope_refl = nullptr

double	fT0_max

double	fT0_break_point

std::vector< double >	fDistances_landau

std::vector< std::vector< double > >	fNorm_over_entries

std::vector< std::vector< double > >	fMpv

std::vector< std::vector< double > >	fWidth

std::vector< double >	fDistances_exp

std::vector< std::vector< double > >	fSlope

std::vector< std::vector< double > >	fExpo_over_Landau_norm

double	fstep_size

double	fmax_d

double	fmin_d

double	fvuv_vgroup_mean

double	fvuv_vgroup_max

double	finflexion_point_distance

double	fangle_bin_timing_vuv

std::vector< double >	fDistances_refl

std::vector< double >	fDistances_radial_refl

std::vector< std::vector< std::vector< double > > >	fCut_off

std::vector< std::vector< std::vector< double > > >	fTau

double	fvis_vmean

double	fangle_bin_timing_vis

bool	fIsFlatPDCorr

bool	fIsDomePDCorr

double	fdelta_angulo_vuv

std::vector< std::vector< double > >	fGHvuvpars_flat

std::vector< double >	fborder_corr_angulo_flat

std::vector< std::vector< double > >	fborder_corr_flat

std::vector< std::vector< double > >	fGHvuvpars_dome

std::vector< double >	fborder_corr_angulo_dome

std::vector< std::vector< double > >	fborder_corr_dome

double	fdelta_angulo_vis

std::vector< double >	fvis_distances_x_flat

std::vector< double >	fvis_distances_r_flat

std::vector< std::vector< std::vector< double > > >	fvispars_flat

std::vector< double >	fvis_distances_x_dome

std::vector< double >	fvis_distances_r_dome

std::vector< std::vector< std::vector< double > > >	fvispars_dome

double	fradius

std::string	fLibraryFile

IPhotonLibrary *	fTheLibrary

sim::PhotonVoxelDef	fVoxelDef

std::unique_ptr< phot::IPhotonMappingTransformations >	fMapping
	Mapping of detector space into library space. More...

Implementation functions
bool	doHasVisibility (geo::Point_t const &p, bool wantReflected=false) const

float	doGetVisibility (geo::Point_t const &p, unsigned int OpChannel, bool wantReflected=false) const

MappedCounts_t	doGetAllVisibilities (geo::Point_t const &p, bool wantReflected=false) const

MappedT0s_t	doGetReflT0s (geo::Point_t const &p) const

MappedParams_t	doGetTimingPar (geo::Point_t const &p) const

MappedFunctions_t	doGetTimingTF1 (geo::Point_t const &p) const

static double	DistanceToOpDetImpl (geo::Point_t const &p, unsigned int OpDet)

static double	SolidAngleFactorImpl (geo::Point_t const &p, unsigned int OpDet)

Detailed Description

Definition at line 32 of file PhotonVisibilityService.h.

Member Typedef Documentation

using phot::PhotonVisibilityService::LibraryIndex_t = phot::IPhotonMappingTransformations::LibraryIndex_t

private

Type of optical library index.

Definition at line 35 of file PhotonVisibilityService.h.

Constructor & Destructor Documentation

phot::PhotonVisibilityService::~PhotonVisibilityService ( )

Definition at line 49 of file PhotonVisibilityService_service.cc.

   {
     delete fparslogNorm;
     delete fparslogNorm_far;
     delete fparsMPV;
     delete fparsMPV_far;
     delete fparsWidth;
     delete fparsCte;
     delete fparsCte_far;
     delete fparsSlope;
     delete fparslogNorm_refl;
     delete fparsMPV_refl;
     delete fparsWidth_refl;
     delete fparsCte_refl;
     delete fparsSlope_refl;
     delete fTheLibrary;
   }

phot::PhotonVisibilityService::PhotonVisibilityService ( fhicl::ParameterSet const & pset )

Definition at line 68 of file PhotonVisibilityService_service.cc.

     :
 
     fCurrentVoxel(0)
     , fCurrentValue(0.)
     , fXmin(0.)
     , fXmax(0.)
     , fYmin(0.)
     , fYmax(0.)
     , fZmin(0.)
     , fZmax(0.)
     , fNx(0)
     , fNy(0)
     , fNz(0)
     , fUseCryoBoundary(false)
     , fLibraryBuildJob(false)
     , fDoNotLoadLibrary(false)
     , fParameterization(false)
     , fHybrid(false)
     , fStoreReflected(false)
     , fStoreReflT0(false)
     , fIncludePropTime(false)
     , fUseNhitsModel(false)
     , fParPropTime(false)
     , fParPropTime_npar(0)
     , fParPropTime_formula()
     , fParPropTime_MaxRange()
     , fInterpolate(false)
     , fReflectOverZeroX(false)
     , fparslogNorm(nullptr)
     , fparslogNorm_far(nullptr)
     , fparsMPV(nullptr)
     , fparsMPV_far(nullptr)
     , fparsWidth(nullptr)
     , fparsCte(nullptr)
     , fparsCte_far(nullptr)
     , fparsSlope(nullptr)
     , fD_break(0.0)
     , fD_max(0.0)
     , fTF1_sampling_factor(0.0)
     , fparslogNorm_refl(nullptr)
     , fparsMPV_refl(nullptr)
     , fparsWidth_refl(nullptr)
     , fparsCte_refl(nullptr)
     , fparsSlope_refl(nullptr)
     , fT0_max(0.0)
     , fT0_break_point(0.0)
     , fLibraryFile()
     , fTheLibrary(nullptr)
     , fVoxelDef()
   {
     this->reconfigure(pset);
 
     if (pset.has_key("ReflectOverZeroX")) { // legacy parameter warning
       if (pset.has_key("Mapping")) {
         throw art::Exception(art::errors::Configuration)
           << "`PhotonVisbilityService` configuration specifies both `Mapping` and "
              "`ReflectOverZeroX`."
              " Please remove the latter (and use `PhotonMappingXMirrorTransformations` tool).";
       }
       else {
         mf::LogWarning("PhotonVisbilityService")
           << "Please update the configuration of `PhotonVisbilityService` service"
              " replacing `ReflectOverZeroX` with tool configuration:"
              "\n  Mapping: { tool_type: \"PhotonMappingXMirrorTransformations\" }";
       }
     } // if
     fhicl::ParameterSet mapDefaultSet;
     mapDefaultSet.put("tool_type",
                       fReflectOverZeroX ? "PhotonMappingXMirrorTransformations" :
                                           "PhotonMappingIdentityTransformations");
     fMapping = art::make_tool<phot::IPhotonMappingTransformations>(
       pset.get<fhicl::ParameterSet>("Mapping", mapDefaultSet));
 
     mf::LogInfo("PhotonVisibilityService") << "PhotonVisbilityService initializing" << std::endl;
   }

Member Function Documentation

bool phot::PhotonVisibilityService::ApplyVISBorderCorrection ( ) const

inline

Definition at line 206 of file PhotonVisibilityService.h.

     {
       return fApplyVISBorderCorrection;
     }

template<typename Point >

static double phot::PhotonVisibilityService::DistanceToOpDet	(	Point const &	p,
		unsigned int	OpDet
	)

inlinestatic

Definition at line 47 of file PhotonVisibilityService.h.

     {
       return DistanceToOpDetImpl(geo::vect::toPoint(p), OpDet);
     }

double phot::PhotonVisibilityService::DistanceToOpDetImpl	(	geo::Point_t const &	p,
		unsigned int	OpDet
	)

staticprivate

Definition at line 428 of file PhotonVisibilityService_service.cc.

   {
     art::ServiceHandle<geo::Geometry const> geom;
     return geom->OpDetGeoFromOpDet(OpDet).DistanceToPoint(p);
   }

auto phot::PhotonVisibilityService::doGetAllVisibilities	(	geo::Point_t const &	p,
		bool	wantReflected = `false`
	)		const

private

Definition at line 400 of file PhotonVisibilityService_service.cc.

   {
     phot::IPhotonLibrary::Counts_t data{};
 
     // first we fill a container of visibilities in the library index space
     // (it is directly the values of the library unless interpolation is
     //  requested)
     if (fInterpolate) {
       // this is a punch into multithreading face:
       static std::vector<float> ret;
       ret.resize(fMapping->libraryMappingSize(p));
       for (std::size_t libIndex = 0; libIndex < ret.size(); ++libIndex) {
         ret[libIndex] = doGetVisibilityOfOpLib(p, LibraryIndex_t(libIndex), wantReflected);
       }
       data = &ret.front();
     }
     else {
       auto const VoxID = VoxelAt(p);
       data = GetLibraryEntries(VoxID, wantReflected);
     }
     return fMapping->applyOpDetMapping(p, data);
   }

auto phot::PhotonVisibilityService::doGetReflT0s ( geo::Point_t const & p ) const

private

Definition at line 571 of file PhotonVisibilityService_service.cc.

   {
     // both the input and the output go through mapping to apply needed symmetries.
     int const VoxID = VoxelAt(p);
     phot::IPhotonLibrary::Counts_t const& data = GetLibraryReflT0Entries(VoxID);
     return fMapping->applyOpDetMapping(p, data);
   }

auto phot::PhotonVisibilityService::doGetTimingPar ( geo::Point_t const & p ) const

private

Definition at line 618 of file PhotonVisibilityService_service.cc.

   {
     int const VoxID = VoxelAt(p);
     phot::IPhotonLibrary::Params_t const& params = GetLibraryTimingParEntries(VoxID);
     return fMapping->applyOpDetMapping(p, params);
   }

auto phot::PhotonVisibilityService::doGetTimingTF1 ( geo::Point_t const & p ) const

private

Definition at line 626 of file PhotonVisibilityService_service.cc.

   {
     int const VoxID = VoxelAt(p);
     phot::IPhotonLibrary::Functions_t const& functions = GetLibraryTimingTF1Entries(VoxID);
     return fMapping->applyOpDetMapping(p, functions);
   }

float phot::PhotonVisibilityService::doGetVisibility	(	geo::Point_t const &	p,
		unsigned int	OpChannel,
		bool	wantReflected = `false`
	)		const

private

Definition at line 478 of file PhotonVisibilityService_service.cc.

   {
     // here we quietly confuse op. det. channel (interface) and op. det. (library)
     LibraryIndex_t const libIndex = fMapping->opDetToLibraryIndex(p, OpChannel);
     return doGetVisibilityOfOpLib(p, libIndex, wantReflected);
   }

float phot::PhotonVisibilityService::doGetVisibilityOfOpLib	(	geo::Point_t const &	p,
		LibraryIndex_t	libIndex,
		bool	wantReflected = `false`
	)		const

private

Definition at line 447 of file PhotonVisibilityService_service.cc.

   {
     if (!fInterpolate) { return GetLibraryEntry(VoxelAt(p), libIndex, wantReflected); }
 
     // In case we're outside the bounding box we'll get a empty optional list.
     auto const neis = GetVoxelDef().GetNeighboringVoxelIDs(LibLocation(p));
     if (!neis) return 0.0;
 
     // Sum up all the weighted neighbours to get interpolation behaviour
     float vis = 0.0;
     for (const sim::PhotonVoxelDef::NeiInfo& n : neis.value()) {
       if (n.id < 0) continue;
       vis += n.weight * GetLibraryEntry(n.id, libIndex, wantReflected);
     }
     return vis;
   }

bool phot::PhotonVisibilityService::doHasVisibility	(	geo::Point_t const &	p,
		bool	wantReflected = `false`
	)		const

private

Definition at line 469 of file PhotonVisibilityService_service.cc.

   {
     return HasLibraryEntries(VoxelAt(p), wantReflected);
   }

template<typename Point >

MappedCounts_t phot::PhotonVisibilityService::GetAllVisibilities	(	Point const &	p,
		bool	wantReflected = `false`
	)		const

inline

Definition at line 74 of file PhotonVisibilityService.h.

     {
       return doGetAllVisibilities(geo::vect::toPoint(p), wantReflected);
     }

phot::IPhotonLibrary::Counts_t phot::PhotonVisibilityService::GetLibraryEntries	(	int	VoxID,
		bool	wantReflected = `false`
	)		const

Definition at line 530 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     if (!wantReflected)
       return fTheLibrary->GetCounts(VoxID);
     else
       return fTheLibrary->GetReflCounts(VoxID);
   }

float phot::PhotonVisibilityService::GetLibraryEntry	(	int	VoxID,
		OpDetID_t	libOpChannel,
		bool	wantReflected = `false`
	)		const

Definition at line 553 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     if (!wantReflected)
       return fTheLibrary->GetCount(VoxID, libOpChannel);
     else
       return fTheLibrary->GetReflCount(VoxID, libOpChannel);
   }

phot::IPhotonLibrary::Counts_t phot::PhotonVisibilityService::GetLibraryReflT0Entries ( int VoxID ) const

Definition at line 582 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     return fTheLibrary->GetReflT0s(VoxID);
   }

float phot::PhotonVisibilityService::GetLibraryReflT0Entry	(	int	VoxID,
		OpDetID_t	libOpChannel
	)		const

Definition at line 606 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     return fTheLibrary->GetReflT0(VoxID, libOpChannel);
   }

phot::IPhotonLibrary::Params_t phot::PhotonVisibilityService::GetLibraryTimingParEntries ( int VoxID ) const

Definition at line 636 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     return lib->GetTimingPars(VoxID);
   }

float phot::PhotonVisibilityService::GetLibraryTimingParEntry	(	int	VoxID,
		OpDetID_t	libOpChannel,
		size_t	npar
	)		const

Definition at line 689 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     return lib->GetTimingPar(VoxID, libOpChannel, npar);
   }

phot::IPhotonLibrary::Functions_t phot::PhotonVisibilityService::GetLibraryTimingTF1Entries ( int VoxID ) const

Definition at line 647 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     return lib->GetTimingTF1s(VoxID);
   }

double phot::PhotonVisibilityService::GetQuenchingFactor ( double dQdx ) const

Definition at line 388 of file PhotonVisibilityService_service.cc.

   {
     // for now, no quenching
     return 1.0;
   }

template<typename Point >

MappedT0s_t phot::PhotonVisibilityService::GetReflT0s ( Point const & p ) const

inline

Definition at line 92 of file PhotonVisibilityService.h.

     {
       return doGetReflT0s(geo::vect::toPoint(p));
     }

template<typename Point >

MappedParams_t phot::PhotonVisibilityService::GetTimingPar ( Point const & p ) const

inline

Definition at line 102 of file PhotonVisibilityService.h.

     {
       return doGetTimingPar(geo::vect::toPoint(p));
     }

template<typename Point >

MappedFunctions_t phot::PhotonVisibilityService::GetTimingTF1 ( Point const & p ) const

inline

Definition at line 112 of file PhotonVisibilityService.h.

     {
       return doGetTimingTF1(geo::vect::toPoint(p));
     }

template<typename Point >

float phot::PhotonVisibilityService::GetVisibility	(	Point const &	p,
		unsigned int	OpChannel,
		bool	wantReflected = `false`
	)		const

inline

Definition at line 67 of file PhotonVisibilityService.h.

     {
       return doGetVisibility(geo::vect::toPoint(p), OpChannel, wantReflected);
     }

const sim::PhotonVoxelDef& phot::PhotonVisibilityService::GetVoxelDef ( ) const

inline

Definition at line 217 of file PhotonVisibilityService.h.

     {
       return fVoxelDef;
     }

bool phot::PhotonVisibilityService::HasLibraryEntries	(	int	VoxID,
		bool	wantReflected = `false`
	)		const

Definition at line 543 of file PhotonVisibilityService_service.cc.

   {
     if (!fTheLibrary) LoadLibrary();
     return fTheLibrary->isVoxelValid(VoxID);
   }

template<typename Point >

bool phot::PhotonVisibilityService::HasVisibility	(	Point const &	p,
		bool	wantReflected = `false`
	)		const

inline

Definition at line 60 of file PhotonVisibilityService.h.

     {
       return doHasVisibility(geo::vect::toPoint(p), wantReflected);
     }

bool phot::PhotonVisibilityService::IncludeParPropTime ( ) const

inline

Definition at line 180 of file PhotonVisibilityService.h.

     {
       return fParPropTime;
     }

bool phot::PhotonVisibilityService::IncludePropTime ( ) const

inline

Definition at line 196 of file PhotonVisibilityService.h.

     {
       return fIncludePropTime;
     }

bool phot::PhotonVisibilityService::IsBuildJob ( ) const

inline

Definition at line 160 of file PhotonVisibilityService.h.

     {
       return fLibraryBuildJob;
     }

geo::Point_t phot::PhotonVisibilityService::LibLocation ( geo::Point_t const & p ) const

private

Definition at line 850 of file PhotonVisibilityService_service.cc.

   {
     return fMapping->detectorToLibrary(p);
   }

void phot::PhotonVisibilityService::LoadGHDome	(	std::vector< std::vector< double >> &	GHvuvpars_dome,
		std::vector< double > &	border_corr_angulo_dome,
		std::vector< std::vector< double >> &	border_corr_dome
	)		const

Definition at line 810 of file PhotonVisibilityService_service.cc.

   {
     if (!fIsDomePDCorr) return;
     GHvuvpars_dome = fGHvuvpars_dome;
     border_corr_angulo_dome = fborder_corr_angulo_dome;
     border_corr_dome = fborder_corr_dome;
   }

void phot::PhotonVisibilityService::LoadGHFlat	(	std::vector< std::vector< double >> &	GHvuvpars_flat,
		std::vector< double > &	border_corr_angulo_flat,
		std::vector< std::vector< double >> &	border_corr_flat
	)		const

Definition at line 801 of file PhotonVisibilityService_service.cc.

   {
     if (!fIsFlatPDCorr) return;
     GHvuvpars_flat = fGHvuvpars_flat;
     border_corr_angulo_flat = fborder_corr_angulo_flat;
     border_corr_flat = fborder_corr_flat;
   }

void phot::PhotonVisibilityService::LoadLibrary ( ) const

Definition at line 147 of file PhotonVisibilityService_service.cc.

   {
     // Don't do anything if the library has already been loaded.
 
     if (fTheLibrary == 0) {
 
       if ((!fLibraryBuildJob) && (!fDoNotLoadLibrary)) {
         std::string LibraryFileWithPath;
         cet::search_path sp("FW_SEARCH_PATH");
 
         if (!sp.find_file(fLibraryFile, LibraryFileWithPath))
           throw cet::exception("PhotonVisibilityService")
             << "Unable to find photon library in " << sp.to_string() << "\n";
 
         if (!fParameterization) {
           art::ServiceHandle<geo::Geometry const> geom;
 
           mf::LogInfo("PhotonVisibilityService")
             << "PhotonVisibilityService Loading photon library from file " << LibraryFileWithPath
             << " for " << GetVoxelDef().GetNVoxels() << " voxels and " << geom->NOpDets()
             << " optical detectors." << std::endl;
 
           if (fHybrid) {
             fTheLibrary = new PhotonLibraryHybrid(LibraryFileWithPath, GetVoxelDef());
           }
           else {
             PhotonLibrary* lib = new PhotonLibrary;
             fTheLibrary = lib;
 
             size_t NVoxels = GetVoxelDef().GetNVoxels();
             lib->LoadLibraryFromFile(LibraryFileWithPath,
                                      NVoxels,
                                      fStoreReflected,
                                      fStoreReflT0,
                                      fParPropTime_npar,
                                      fParPropTime_MaxRange);
 
             // if the library does not have metadata, we supply some;
             // otherwise we check that it's compatible with the configured one
             // (and shrug if it's not); overriding configured metadata
             // from the one in the library is currently not supported
             if (!lib->hasVoxelDef())
               lib->SetVoxelDef(GetVoxelDef());
             else if (GetVoxelDef() != lib->GetVoxelDef()) {
               // this might become a fatal error in the future if some protocol
               // is imposed... it may also be possible to check only the size
               // rather than the coordinates, which may allow for translations
               // of the geometry volumes in world space.
               mf::LogWarning("PhotonVisbilityService")
                 << "Photon library reports the geometry:\n"
                 << lib->GetVoxelDef() << "while PhotonVisbilityService is configured with:\n"
                 << GetVoxelDef();
             } // if metadata
           }
         }
       }
       else {
         art::ServiceHandle<geo::Geometry const> geom;
 
         size_t NOpDets = geom->NOpDets();
         size_t NVoxels = GetVoxelDef().GetNVoxels();
         if (fLibraryBuildJob) {
           mf::LogInfo("PhotonVisibilityService")
             << " Vis service running library build job.  Please ensure "
             << " job contains LightSource, LArG4, SimPhotonCounter";
         }
 
         art::TFileDirectory* pDir = nullptr;
         try {
           pDir = art::ServiceHandle<art::TFileService>().get();
         }
         catch (art::Exception const& e) {
           if (e.categoryCode() != art::errors::ServiceNotFound) throw;
           if (fLibraryBuildJob) {
             throw art::Exception(e.categoryCode(), "", e)
               << "PhotonVisibilityService: "
                  "service `TFileService` is required when building a photon library.\n";
           }
         }
 
         PhotonLibrary* lib = new PhotonLibrary(pDir);
         fTheLibrary = lib;
 
         lib->CreateEmptyLibrary(NVoxels, NOpDets, fStoreReflected, fStoreReflT0, fParPropTime_npar);
         lib->SetVoxelDef(GetVoxelDef());
       }
     }
   }

void phot::PhotonVisibilityService::LoadTimingsForVISPar	(	std::vector< double > &	distances,
		std::vector< double > &	radial_distances,
		std::vector< std::vector< std::vector< double >>> &	cut_off,
		std::vector< std::vector< std::vector< double >>> &	tau,
		double &	vis_vmean,
		double &	angle_bin_timing_vis
	)		const

Definition at line 775 of file PhotonVisibilityService_service.cc.

   {
     distances = fDistances_refl;
     radial_distances = fDistances_radial_refl;
     cut_off = fCut_off;
     tau = fTau;
 
     vis_vmean = fvis_vmean;
     angle_bin_timing_vis = fangle_bin_timing_vis;
   }

void phot::PhotonVisibilityService::LoadTimingsForVUVPar	(	std::vector< std::vector< double >>(&)	v[7],
		double &	step_size,
		double &	max_d,
		double &	min_d,
		double &	vuv_vgroup_mean,
		double &	vuv_vgroup_max,
		double &	inflexion_point_distance,
		double &	angle_bin_timing_vuv
	)		const

Definition at line 748 of file PhotonVisibilityService_service.cc.

   {
     v[0] = std::vector(1, fDistances_landau);
     v[1] = fNorm_over_entries;
     v[2] = fMpv;
     v[3] = fWidth;
     v[4] = std::vector(1, fDistances_exp);
     v[5] = fSlope;
     v[6] = fExpo_over_Landau_norm;
 
     step_size = fstep_size;
     max_d = fmax_d;
     min_d = fmin_d;
     vuv_vgroup_mean = fvuv_vgroup_mean;
     vuv_vgroup_max = fvuv_vgroup_max;
     inflexion_point_distance = finflexion_point_distance;
     angle_bin_timing_vuv = fangle_bin_timing_vuv;
   }

void phot::PhotonVisibilityService::LoadVisParsDome	(	std::vector< double > &	vis_distances_x_dome,
		std::vector< double > &	vis_distances_r_dome,
		std::vector< std::vector< std::vector< double >>> &	vispars_dome
	)		const

Definition at line 834 of file PhotonVisibilityService_service.cc.

   {
     if (!fIsDomePDCorr) return;
     vis_distances_x_dome = fvis_distances_x_dome;
     vis_distances_r_dome = fvis_distances_r_dome;
     vispars_dome = fvispars_dome;
   }

void phot::PhotonVisibilityService::LoadVisParsFlat	(	std::vector< double > &	vis_distances_x_flat,
		std::vector< double > &	vis_distances_r_flat,
		std::vector< std::vector< std::vector< double >>> &	vispars_flat
	)		const

Definition at line 825 of file PhotonVisibilityService_service.cc.

   {
     if (!fIsFlatPDCorr) return;
     vis_distances_x_flat = fvis_distances_x_flat;
     vis_distances_r_flat = fvis_distances_r_flat;
     vispars_flat = fvispars_flat;
   }

void phot::PhotonVisibilityService::LoadVisSemiAnalyticProperties	(	double &	delta_angulo_vis,
		double &	radius
	)		const

Definition at line 819 of file PhotonVisibilityService_service.cc.

   {
     delta_angulo_vis = fdelta_angulo_vis;
     radius = fradius;
   }

void phot::PhotonVisibilityService::LoadVUVSemiAnalyticProperties	(	bool &	isFlatPDCorr,
		bool &	isDomePDCorr,
		double &	delta_angulo_vuv,
		double &	radius
	)		const

Definition at line 791 of file PhotonVisibilityService_service.cc.

   {
     isFlatPDCorr = fIsFlatPDCorr;
     isDomePDCorr = fIsDomePDCorr;
     delta_angulo_vuv = fdelta_angulo_vuv;
     radius = fradius;
   }

size_t phot::PhotonVisibilityService::NOpChannels ( ) const

Definition at line 702 of file PhotonVisibilityService_service.cc.

   {
     // the last word about the number of channels belongs to the mapping;
     // this should be also the same answer as `geo::GeometryCore::NOpDets()`.
     return fMapping->opDetMappingSize();
   }

std::string phot::PhotonVisibilityService::ParPropTimeFormula ( ) const

inline

Definition at line 190 of file PhotonVisibilityService.h.

     {
       return fParPropTime_formula;
     }

size_t phot::PhotonVisibilityService::ParPropTimeNpar ( ) const

inline

Definition at line 185 of file PhotonVisibilityService.h.

     {
       return fParPropTime_npar;
     }

void phot::PhotonVisibilityService::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 256 of file PhotonVisibilityService_service.cc.

   {
 
     art::ServiceHandle<geo::Geometry const> geom;
 
     // Library details
     fLibraryBuildJob = p.get<bool>("LibraryBuildJob", false);
     fParameterization = p.get<bool>("DUNE10ktParameterization", false);
     fHybrid = p.get<bool>("HybridLibrary", false);
     fLibraryFile = p.get<std::string>("LibraryFile", "");
     fDoNotLoadLibrary = p.get<bool>("DoNotLoadLibrary");
     fStoreReflected = p.get<bool>("StoreReflected", false);
     fStoreReflT0 = p.get<bool>("StoreReflT0", false);
     // Parametrizations (time and Nhits)
     fIncludePropTime = p.get<bool>("IncludePropTime", false);
     fUseNhitsModel = p.get<bool>("UseNhitsModel", false);
     fApplyVISBorderCorrection = p.get<bool>("ApplyVISBorderCorrection", false);
     fVISBorderCorrectionType = p.get<std::string>("VIS_BORDER_correction_type", "");
 
     // Voxel parameters
     fUseCryoBoundary = p.get<bool>("UseCryoBoundary", false);
     fInterpolate = p.get<bool>("Interpolate", false);
     fReflectOverZeroX = p.get<bool>("ReflectOverZeroX", false);
 
     fParPropTime = p.get<bool>("ParametrisedTimePropagation", false);
     fParPropTime_npar = p.get<size_t>("ParametrisedTimePropagationNParameters", 0);
     fParPropTime_formula = p.get<std::string>("ParametrisedTimePropagationFittedFormula", "");
     fParPropTime_MaxRange = p.get<int>("ParametrisedTimePropagationMaxRange", 200);
 
     if (!fParPropTime) { fParPropTime_npar = 0; }
 
     if (!fUseNhitsModel) {
 
       if (fUseCryoBoundary) {
         double CryoBounds[6];
         geom->CryostatBoundaries(CryoBounds);
         fXmin = CryoBounds[0];
         fXmax = CryoBounds[1];
         fYmin = CryoBounds[2];
         fYmax = CryoBounds[3];
         fZmin = CryoBounds[4];
         fZmax = CryoBounds[5];
       }
       else {
         fXmin = p.get<double>("XMin");
         fXmax = p.get<double>("XMax");
         fYmin = p.get<double>("YMin");
         fYmax = p.get<double>("YMax");
         fZmin = p.get<double>("ZMin");
         fZmax = p.get<double>("ZMax");
       }
 
       fNx = p.get<int>("NX");
       fNy = p.get<int>("NY");
       fNz = p.get<int>("NZ");
 
       fVoxelDef = sim::PhotonVoxelDef(fXmin, fXmax, fNx, fYmin, fYmax, fNy, fZmin, fZmax, fNz);
     }
 
     if (fIncludePropTime) {
 
       // load VUV arrival time distribution parametrization (no detector dependent at first order)
       std::cout << "Loading the VUV time parametrization" << std::endl;
       fDistances_landau = p.get<std::vector<double>>("Distances_landau");
       fNorm_over_entries = p.get<std::vector<std::vector<double>>>("Norm_over_entries");
       fMpv = p.get<std::vector<std::vector<double>>>("Mpv");
       fWidth = p.get<std::vector<std::vector<double>>>("Width");
       fDistances_exp = p.get<std::vector<double>>("Distances_exp");
       fSlope = p.get<std::vector<std::vector<double>>>("Slope");
       fExpo_over_Landau_norm = p.get<std::vector<std::vector<double>>>("Expo_over_Landau_norm");
       fstep_size = p.get<double>("step_size");
       fmax_d = p.get<double>("max_d");
       fmin_d = p.get<double>("min_d");
       fvuv_vgroup_mean = p.get<double>("vuv_vgroup_mean");
       fvuv_vgroup_max = p.get<double>("vuv_vgroup_max");
       finflexion_point_distance = p.get<double>("inflexion_point_distance");
       fangle_bin_timing_vuv = p.get<double>("angle_bin_timing_vuv");
 
       if (fStoreReflected) {
 
         // load VIS arrival time distribution paramterisation
         std::cout << "Loading the VIS time paramterisation" << std::endl;
         fDistances_refl = p.get<std::vector<double>>("Distances_refl");
         fDistances_radial_refl = p.get<std::vector<double>>("Distances_radial_refl");
         fCut_off = p.get<std::vector<std::vector<std::vector<double>>>>("Cut_off");
         fTau = p.get<std::vector<std::vector<std::vector<double>>>>("Tau");
         fvis_vmean = p.get<double>("vis_vmean");
         fangle_bin_timing_vis = p.get<double>("angle_bin_timing_vis");
       }
     }
 
     if (fUseNhitsModel) {
       std::cout << "Loading semi-analytic mode models" << std::endl;
       // VUV
       fIsFlatPDCorr = p.get<bool>("FlatPDCorr", false);
       fIsDomePDCorr = p.get<bool>("DomePDCorr", false);
       fdelta_angulo_vuv = p.get<double>("delta_angulo_vuv");
       if(fIsFlatPDCorr) {
         fGHvuvpars_flat = p.get<std::vector<std::vector<double>>>("GH_PARS_flat");
         fborder_corr_angulo_flat = p.get<std::vector<double>>("GH_border_angulo_flat");
         fborder_corr_flat = p.get<std::vector<std::vector<double>>>("GH_border_flat");
       }
       if(fIsDomePDCorr) {
         fGHvuvpars_dome = p.get<std::vector<std::vector<double>>>("GH_PARS_dome");
         fborder_corr_angulo_dome = p.get<std::vector<double>>("GH_border_angulo_dome");
         fborder_corr_dome = p.get<std::vector<std::vector<double>>>("GH_border_dome");
       }
 
       if (fStoreReflected) {
         fdelta_angulo_vis = p.get<double>("delta_angulo_vis");
         if(fIsFlatPDCorr) {
           fvis_distances_x_flat = p.get<std::vector<double>>("VIS_distances_x_flat");
           fvis_distances_r_flat = p.get<std::vector<double>>("VIS_distances_r_flat");
           fvispars_flat = p.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_flat");
         }
         if(fIsDomePDCorr) {
           fvis_distances_x_dome = p.get<std::vector<double>>("VIS_distances_x_dome");
           fvis_distances_r_dome = p.get<std::vector<double>>("VIS_distances_r_dome");
           fvispars_dome = p.get<std::vector<std::vector<std::vector<double>>>>("VIS_correction_dome");
         }
       }
       // optical detector information
       fradius = p.get<double>("PMT_radius", 10.16);
     }
 
     return;
   }

void phot::PhotonVisibilityService::RetrieveLightProd	(	int &	VoxID,
		double &	N
	)		const

Definition at line 501 of file PhotonVisibilityService_service.cc.

   {
     N = fCurrentValue;
     VoxID = fCurrentVoxel;
   }

void phot::PhotonVisibilityService::SetDirectLightPropFunctions	(	TF1 const *	functions[8],
		double &	d_break,
		double &	d_max,
		double &	tf1_sampling_factor
	)		const

Definition at line 711 of file PhotonVisibilityService_service.cc.

   {
     functions[0] = fparslogNorm;
     functions[1] = fparsMPV;
     functions[2] = fparsWidth;
     functions[3] = fparsCte;
     functions[4] = fparsSlope;
     functions[5] = fparslogNorm_far;
     functions[6] = fparsMPV_far;
     functions[7] = fparsCte_far;
 
     d_break = fD_break;
     d_max = fD_max;
     tf1_sampling_factor = fTF1_sampling_factor;
   }

void phot::PhotonVisibilityService::SetLibraryEntry	(	int	VoxID,
		OpDetID_t	libOpChannel,
		float	N,
		bool	wantReflected = `false`
	)

Definition at line 510 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
 
     if (!wantReflected)
       lib->SetCount(VoxID, OpChannel, N);
 
     else
       lib->SetReflCount(VoxID, OpChannel, N);
 
     //std::cout<< " PVS logging " << VoxID << " " << OpChannel<<std::endl;
     MF_LOG_DEBUG("PhotonVisibilityService")
       << " PVS logging " << VoxID << " " << OpChannel << std::endl;
   }

void phot::PhotonVisibilityService::SetLibraryReflT0Entry	(	int	VoxID,
		int	OpChannel,
		float	value
	)

Definition at line 592 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     lib->SetReflT0(VoxID, OpChannel, T0);
 
     MF_LOG_DEBUG("PhotonVisibilityService")
       << " PVS logging " << VoxID << " " << OpChannel << std::endl;
   }

void phot::PhotonVisibilityService::SetLibraryTimingParEntry	(	int	VoxID,
		int	OpChannel,
		float	value,
		size_t	parnum
	)

Definition at line 658 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     lib->SetTimingPar(VoxID, OpChannel, par, parnum);
 
     MF_LOG_DEBUG("PhotonVisibilityService")
       << " PVS logging " << VoxID << " " << OpChannel << std::endl;
   }

void phot::PhotonVisibilityService::SetLibraryTimingTF1Entry	(	int	VoxID,
		int	OpChannel,
		TF1 const &	func
	)

Definition at line 675 of file PhotonVisibilityService_service.cc.

   {
     PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
     if (fTheLibrary == 0) LoadLibrary();
 
     lib->SetTimingTF1(VoxID, OpChannel, func);
 
     MF_LOG_DEBUG("PhotonVisibilityService")
       << " PVS logging " << VoxID << " " << OpChannel << std::endl;
   }

void phot::PhotonVisibilityService::SetReflectedCOLightPropFunctions	(	TF1 const *	functions[5],
		double &	t0_max,
		double &	t0_break_point
	)		const

Definition at line 732 of file PhotonVisibilityService_service.cc.

   {
     functions[0] = fparslogNorm_refl;
     functions[1] = fparsMPV_refl;
     functions[2] = fparsWidth_refl;
     functions[3] = fparsCte_refl;
     functions[4] = fparsSlope_refl;
 
     t0_max = fT0_max;
     t0_break_point = fT0_break_point;
   }

template<typename Point >

static double phot::PhotonVisibilityService::SolidAngleFactor	(	Point const &	p,
		unsigned int	OpDet
	)

inlinestatic

Definition at line 53 of file PhotonVisibilityService.h.

     {
       return SolidAngleFactorImpl(geo::vect::toPoint(p), OpDet);
     }

double phot::PhotonVisibilityService::SolidAngleFactorImpl	(	geo::Point_t const &	p,
		unsigned int	OpDet
	)

staticprivate

Definition at line 438 of file PhotonVisibilityService_service.cc.

   {
     art::ServiceHandle<geo::Geometry const> geom;
     return geom->OpDetGeoFromOpDet(OpDet).CosThetaFromNormal(p);
   }

void phot::PhotonVisibilityService::StoreLibrary ( )

Definition at line 238 of file PhotonVisibilityService_service.cc.

   {
     if (fTheLibrary == 0) LoadLibrary();
 
     if (fLibraryBuildJob) {
 
       if (fHybrid) {
         std::cout << "This is would be building a Hybrid Library. Not defined. " << std::endl;
       }
       mf::LogInfo("PhotonVisibilityService") << " Vis service "
                                              << " Storing Library entries to file..." << std::endl;
       PhotonLibrary* lib = dynamic_cast<PhotonLibrary*>(fTheLibrary);
       lib->StoreLibraryToFile(fLibraryFile, fStoreReflected, fStoreReflT0, fParPropTime_npar);
     }
   }

void phot::PhotonVisibilityService::StoreLightProd	(	int	VoxID,
		double	N
	)

Definition at line 490 of file PhotonVisibilityService_service.cc.

   {
     fCurrentVoxel = VoxID;
     fCurrentValue = N;
     mf::LogInfo("PhotonVisibilityService")
       << " PVS notes production of " << N << " photons at Vox " << VoxID << std::endl;
   }

bool phot::PhotonVisibilityService::StoreReflected ( ) const

inline

Definition at line 170 of file PhotonVisibilityService.h.

     {
       return fStoreReflected;
     }

bool phot::PhotonVisibilityService::StoreReflT0 ( ) const

inline

Definition at line 175 of file PhotonVisibilityService.h.

     {
       return fStoreReflT0;
     }

bool phot::PhotonVisibilityService::UseNhitsModel ( ) const

inline

Definition at line 201 of file PhotonVisibilityService.h.

     {
       return fUseNhitsModel;
     }

bool phot::PhotonVisibilityService::UseParameterization ( ) const

inline

Definition at line 165 of file PhotonVisibilityService.h.

     {
       return fParameterization;
     }

std::string phot::PhotonVisibilityService::VISBorderCorrectionType ( ) const

inline

Definition at line 211 of file PhotonVisibilityService.h.

     {
       return fVISBorderCorrectionType;
     }

int phot::PhotonVisibilityService::VoxelAt ( geo::Point_t const & p ) const

inlineprivate

Definition at line 323 of file PhotonVisibilityService.h.

     {
       return fVoxelDef.GetVoxelID(LibLocation(p));
     }

Member Data Documentation

double phot::PhotonVisibilityService::fangle_bin_timing_vis

private

Definition at line 284 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fangle_bin_timing_vuv

private

Definition at line 278 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fApplyVISBorderCorrection

private

Definition at line 244 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fborder_corr_angulo_dome

private

Definition at line 296 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fborder_corr_angulo_flat

private

Definition at line 292 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fborder_corr_dome

private

Definition at line 297 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fborder_corr_flat

private

Definition at line 293 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fCurrentValue

private

Definition at line 225 of file PhotonVisibilityService.h.

int phot::PhotonVisibilityService::fCurrentVoxel

private

Definition at line 224 of file PhotonVisibilityService.h.

std::vector<std::vector<std::vector<double> > > phot::PhotonVisibilityService::fCut_off

private

Definition at line 282 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fD_break

private

Definition at line 262 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fD_max

private

Definition at line 262 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fdelta_angulo_vis

private

Definition at line 300 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fdelta_angulo_vuv

private

Definition at line 289 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fDistances_exp

private

Definition at line 275 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fDistances_landau

private

Definition at line 271 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fDistances_radial_refl

private

Definition at line 281 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fDistances_refl

private

Definition at line 280 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fDoNotLoadLibrary

private

Definition at line 237 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fExpo_over_Landau_norm

private

Definition at line 277 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fGHvuvpars_dome

private

Definition at line 295 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fGHvuvpars_flat

private

Definition at line 291 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fHybrid

private

Definition at line 239 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fIncludePropTime

private

Definition at line 242 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::finflexion_point_distance

private

Definition at line 278 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fInterpolate

private

Definition at line 251 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fIsDomePDCorr

private

Definition at line 287 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fIsFlatPDCorr

private

Definition at line 287 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fLibraryBuildJob

private

Definition at line 236 of file PhotonVisibilityService.h.

std::string phot::PhotonVisibilityService::fLibraryFile

private

Definition at line 313 of file PhotonVisibilityService.h.

std::unique_ptr<phot::IPhotonMappingTransformations> phot::PhotonVisibilityService::fMapping

private

Mapping of detector space into library space.

Definition at line 318 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fmax_d

private

Definition at line 278 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fmin_d

private

Definition at line 278 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fMpv

private

Definition at line 273 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fNorm_over_entries

private

Definition at line 272 of file PhotonVisibilityService.h.

int phot::PhotonVisibilityService::fNx

private

Definition at line 232 of file PhotonVisibilityService.h.

int phot::PhotonVisibilityService::fNy

private

Definition at line 232 of file PhotonVisibilityService.h.

int phot::PhotonVisibilityService::fNz

private

Definition at line 232 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fParameterization

private

Definition at line 238 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fParPropTime

private

Definition at line 247 of file PhotonVisibilityService.h.

std::string phot::PhotonVisibilityService::fParPropTime_formula

private

Definition at line 249 of file PhotonVisibilityService.h.

int phot::PhotonVisibilityService::fParPropTime_MaxRange

private

Definition at line 250 of file PhotonVisibilityService.h.

size_t phot::PhotonVisibilityService::fParPropTime_npar

private

Definition at line 248 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsCte = nullptr

private

Definition at line 259 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsCte_far = nullptr

private

Definition at line 260 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsCte_refl = nullptr

private

Definition at line 266 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparslogNorm = nullptr

private

Definition at line 254 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparslogNorm_far = nullptr

private

Definition at line 255 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparslogNorm_refl = nullptr

private

Definition at line 263 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsMPV = nullptr

private

Definition at line 256 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsMPV_far = nullptr

private

Definition at line 257 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsMPV_refl = nullptr

private

Definition at line 264 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsSlope = nullptr

private

Definition at line 261 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsSlope_refl = nullptr

private

Definition at line 267 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsWidth = nullptr

private

Definition at line 258 of file PhotonVisibilityService.h.

TF1* phot::PhotonVisibilityService::fparsWidth_refl = nullptr

private

Definition at line 265 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fradius

private

Definition at line 311 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fReflectOverZeroX

private

Definition at line 252 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fSlope

private

Definition at line 276 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fstep_size

private

Definition at line 278 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fStoreReflected

private

Definition at line 240 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fStoreReflT0

private

Definition at line 241 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fT0_break_point

private

Definition at line 268 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fT0_max

private

Definition at line 268 of file PhotonVisibilityService.h.

std::vector<std::vector<std::vector<double> > > phot::PhotonVisibilityService::fTau

private

Definition at line 283 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fTF1_sampling_factor

private

Definition at line 262 of file PhotonVisibilityService.h.

IPhotonLibrary* phot::PhotonVisibilityService::fTheLibrary

mutableprivate

Definition at line 314 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fUseCryoBoundary

private

Definition at line 234 of file PhotonVisibilityService.h.

bool phot::PhotonVisibilityService::fUseNhitsModel

private

Definition at line 243 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fvis_distances_r_dome

private

Definition at line 307 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fvis_distances_r_flat

private

Definition at line 303 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fvis_distances_x_dome

private

Definition at line 306 of file PhotonVisibilityService.h.

std::vector<double> phot::PhotonVisibilityService::fvis_distances_x_flat

private

Definition at line 302 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fvis_vmean

private

Definition at line 284 of file PhotonVisibilityService.h.

std::string phot::PhotonVisibilityService::fVISBorderCorrectionType

private

Definition at line 245 of file PhotonVisibilityService.h.

std::vector<std::vector<std::vector<double> > > phot::PhotonVisibilityService::fvispars_dome

private

Definition at line 308 of file PhotonVisibilityService.h.

std::vector<std::vector<std::vector<double> > > phot::PhotonVisibilityService::fvispars_flat

private

Definition at line 304 of file PhotonVisibilityService.h.

sim::PhotonVoxelDef phot::PhotonVisibilityService::fVoxelDef

private

Definition at line 315 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fvuv_vgroup_max

private

Definition at line 278 of file PhotonVisibilityService.h.

double phot::PhotonVisibilityService::fvuv_vgroup_mean

private

Definition at line 278 of file PhotonVisibilityService.h.

std::vector<std::vector<double> > phot::PhotonVisibilityService::fWidth

private

Definition at line 274 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fXmax

private

Definition at line 229 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fXmin

private

Definition at line 229 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fYmax

private

Definition at line 230 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fYmin

private

Definition at line 230 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fZmax

private

Definition at line 231 of file PhotonVisibilityService.h.

float phot::PhotonVisibilityService::fZmin

private

Definition at line 231 of file PhotonVisibilityService.h.

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

larsim/larsim/PhotonPropagation/PhotonVisibilityService.h
larsim/larsim/PhotonPropagation/PhotonVisibilityService_service.cc

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Implementation functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation