TOPGeometryPar Class Reference

Singleton class for TOP Geometry Parameters. More...

#include <TOPGeometryPar.h>

Public Member Functions
virtual	~TOPGeometryPar ()
	Destructor.
void	Initialize (const GearDir &content)
	Initialize from Gearbox (XML)
void	Initialize ()
	Initialize from database.
bool	isValid () const
	check if the geometry is available
const TOPGeometry *	getGeometry () const
	Returns pointer to geometry object using basf2 units.
const FrontEndMapper &	getFrontEndMapper () const
	Returns front-end mapper (mapping of SCROD's to positions within TOP modules)
const ChannelMapper &	getChannelMapper () const
	Returns default channel mapper (mapping of channels to pixels)
const ChannelMapper &	getChannelMapper (ChannelMapper::EType type) const
	Returns channel mapper (mapping of channels to pixels) - Gearbox only.
double	getPMTEfficiencyEnvelope (double energy) const
	Returns PMT efficiency envelope, e.g.
double	getPMTEfficiency (double energy, int moduleID, int pmtID, double x, double y) const
	Returns PMT pixel efficiency, a product of quantum and collection efficiency.
double	getRelativePixelEfficiency (int moduleID, int pixelID) const
	Returns relative pixel efficiency (including CE, RQE and threshold efficiency)
unsigned	getPMTType (int moduleID, int pmtID) const
	Returns PMT type at a given position.
const TOPNominalTTS &	getTTS (int moduleID, int pmtID) const
	Returns TTS of a PMT at given position.
double	getPhaseIndex (double energy) const
	Returns phase refractive index of quartz at given photon energy.
double	getGroupIndex (double energy) const
	Returns group refractive index of quartz at given photon energy.
double	getPhaseIndexDerivative (double energy) const
	Returns the derivative (dn/dE) of phase refractive index of quartz at given photon energy.
double	getGroupIndexDerivative (double energy) const
	Returns the derivative (dn_g/dE) of group refractive index of quartz at given photon energy.
double	getAbsorptionLength (double energy) const
	Returns bulk absorption lenght of quartz at given photon energy.

Static Public Member Functions
static TOPGeometryPar *	Instance ()
	Static method to obtain the pointer to its instance.

Static Public Attributes
static const double	c_hc = 1239.84193
	Planck constant times speed of light in [eV*nm].

Private Member Functions
	TOPGeometryPar ()
	Hidden constructor since it is a singleton class.
void	finalizeInitialization ()
	finalize initialization
TOPGeometry *	createConfiguration (const GearDir &content)
	Create a parameter object from gearbox.
TOPGeoBarSegment	createBarSegment (const GearDir &content, const std::string &serialNumber)
	Create a parameter object from gearbox for bar segment.
TOPGeoMirrorSegment	createMirrorSegment (const GearDir &content, const std::string &serialNumber)
	Create a parameter object from gearbox for mirror segment.
TOPGeoPrism	createPrism (const GearDir &content, const std::string &serialNumber)
	Create a parameter object from gearbox for prism.
std::string	addNumber (const std::string &str, unsigned number)
	Adds number to string.
void	clearCache ()
	Clears cache for PMT dependent QE data - function is used in call backs.
void	setEnvelopeQE () const
	Constructs envelope of quantum efficiency from PMT data.
void	mapPmtQEToPositions () const
	Maps PMT QE data to positions within the detector.
void	mapPmtTypeToPositions () const
	Maps PMT type to positions within the detector.
void	prepareRelEfficiencies () const
	Prepares a map of relative pixel efficiencies.
int	getUniquePmtID (int moduleID, int pmtID) const
	Returns unique PMT ID within the detector.
int	getUniquePixelID (int moduleID, int pixelID) const
	Returns unique pixel ID within the detector.
double	integralOfQE (const std::vector< float > &qe, double ce, double lambdaFirst, double lambdaStep) const
	Returns integral of quantum efficiency over photon energies.
double	refractiveIndex (double lambda) const
	Quartz refractive index (SellMeier equation)

Private Attributes
TOPGeometry *	m_geo = 0
	geometry parameters from Gearbox
DBObjPtr< TOPGeometry > *	m_geoDB = 0
	geometry parameters from database
bool	m_fromDB = false
	parameters from database or Gearbox
bool	m_valid = false
	true if geometry is available
bool	m_oldPayload = false
	true if old payload found in DB
bool	m_BfieldOn = true
	true if B field is on
FrontEndMapper	m_frontEndMapper
	front end electronics mapper
ChannelMapper	m_channelMapperIRS3B
	channel-pixel mapper
ChannelMapper	m_channelMapperIRSX
	channel-pixel mapper
OptionalDBArray< TOPPmtInstallation >	m_pmtInstalled
	PMT installation data.
OptionalDBArray< TOPPmtQE >	m_pmtQEData
	quantum efficiencies
DBObjPtr< TOPCalChannelRQE >	m_channelRQE
	channel relative quantum effi.
DBObjPtr< TOPCalChannelThresholdEff >	m_thresholdEff
	channel threshold effi.
TOPNominalQE	m_envelopeQE
	envelope quantum efficiency
std::map< int, const TOPPmtQE * >	m_pmts
	QE data mapped to positions.
std::map< int, double >	m_relEfficiencies
	pixel relative QE
std::map< int, unsigned >	m_pmtTypes
	PMT types mapped to positions.

Static Private Attributes
static TOPGeometryPar *	s_instance = 0
	Pointer to the class instance.

Detailed Description

Singleton class for TOP Geometry Parameters.

Definition at line 35 of file TOPGeometryPar.h.

Constructor & Destructor Documentation

~TOPGeometryPar()

~TOPGeometryPar ( )

virtual

Destructor.

Definition at line 35 of file TOPGeometryPar.cc.

    {
      if (m_geo) delete m_geo;
      if (m_geoDB) delete m_geoDB;
      s_instance = 0;
    }

TOPGeometryPar()

TOPGeometryPar ( )

inlineprivate

Hidden constructor since it is a singleton class.

Definition at line 182 of file TOPGeometryPar.h.

      {}

Member Function Documentation

addNumber()

std::string addNumber ( const std::string &  str, unsigned  number  )

private

Adds number to string.

Parameters

str	string
number	number to be added

Returns

string with a number

Definition at line 946 of file TOPGeometryPar.cc.

    {
      stringstream ss;
      if (number < 10) {
        ss << str << "0" << number;
      } else {
        ss << str << number;
      }
      string out;
      ss >> out;
      return out;
    }

clearCache()

void clearCache ( )

private

Clears cache for PMT dependent QE data - function is used in call backs.

Definition at line 157 of file TOPGeometryPar.cc.

    {
      m_envelopeQE.clear();
      m_pmts.clear();
      m_relEfficiencies.clear();
      m_pmtTypes.clear();
    }

createBarSegment()

TOPGeoBarSegment createBarSegment ( const GearDir &  content, const std::string &  serialNumber  )

private

Create a parameter object from gearbox for bar segment.

Parameters

content	XML data directory
serialNumber	bar segment serial number

Definition at line 868 of file TOPGeometryPar.cc.

    {
      // dimensions and material
      GearDir params(content, "QuartzBars/QuartzBar[@SerialNumber='" + SN + "']");
      TOPGeoBarSegment bar(params.getLength("Width"),
                           params.getLength("Thickness"),
                           params.getLength("Length"),
                           params.getString("Material"));
      bar.setVendorData(params.getString("Vendor"), SN);
 
      // optical surface
      std::string surfaceName = params.getString("OpticalSurface");
      double sigmaAlpha = params.getDouble("SigmaAlpha");
      GearDir surfaceParams(content, "Modules/Surface[@name='" + surfaceName + "']");
      auto& materials = geometry::Materials::getInstance();
      auto quartzSurface = materials.createOpticalSurfaceConfig(surfaceParams);
      bar.setSurface(quartzSurface, sigmaAlpha);
 
      return bar;
    }

createConfiguration()

TOPGeometry * createConfiguration ( const GearDir &  content )

private

Create a parameter object from gearbox.

Parameters

content

XML data directory

Definition at line 437 of file TOPGeometryPar.cc.

    {
      TOPGeometry* geo = new TOPGeometry("TOPGeometry");
 
      // PMT array
 
      GearDir pmtParams(content, "PMTs/PMT");
      TOPGeoPMT pmt(pmtParams.getLength("ModuleXSize"),
                    pmtParams.getLength("ModuleYSize"),
                    pmtParams.getLength("ModuleZSize") +
                    pmtParams.getLength("WindowThickness") +
                    pmtParams.getLength("BottomThickness"));
      pmt.setWallThickness(pmtParams.getLength("ModuleWall"));
      pmt.setWallMaterial(pmtParams.getString("wallMaterial"));
      pmt.setFillMaterial(pmtParams.getString("fillMaterial"));
      pmt.setSensVolume(pmtParams.getLength("SensXSize"),
                        pmtParams.getLength("SensYSize"),
                        pmtParams.getLength("SensThickness"),
                        pmtParams.getString("sensMaterial"));
      pmt.setNumPixels(pmtParams.getInt("PadXNum"),
                       pmtParams.getInt("PadYNum"));
      pmt.setWindow(pmtParams.getLength("WindowThickness"),
                    pmtParams.getString("winMaterial"));
      pmt.setBottom(pmtParams.getLength("BottomThickness"),
                    pmtParams.getString("botMaterial"));
 
      auto& materials = geometry::Materials::getInstance();
      GearDir reflEdgeSurfParams(pmtParams, "reflectiveEdge/Surface");
      pmt.setReflEdge(pmtParams.getLength("reflectiveEdge/width"),
                      pmtParams.getLength("reflectiveEdge/thickness"),
                      materials.createOpticalSurfaceConfig(reflEdgeSurfParams));
 
      GearDir arrayParams(content, "PMTs");
      TOPGeoPMTArray pmtArray(arrayParams.getInt("nPMTx"),
                              arrayParams.getInt("nPMTy"),
                              arrayParams.getLength("Xgap"),
                              arrayParams.getLength("Ygap"),
                              arrayParams.getString("stackMaterial"),
                              pmt);
      pmtArray.setSiliconeCookie(arrayParams.getLength("siliconeCookie/thickness"),
                                 arrayParams.getString("siliconeCookie/material"));
      pmtArray.setWavelengthFilter(arrayParams.getLength("wavelengthFilter/thickness"),
                                   arrayParams.getString("wavelengthFilter/material"));
      pmtArray.setAirGap(arrayParams.getLength("airGap", 0));
      double decoupledFraction = arrayParams.getDouble("decoupledFraction", 0);
 
      // modules
 
      GearDir moduleParams(content, "Modules");
      GearDir glueParams(moduleParams, "Glue");
      int numModules = moduleParams.getNumberNodes("Module");
      for (int slotID = 1; slotID <= numModules; slotID++) {
        std::string gearName = "Module[@slotID='" + std::to_string(slotID) + "']";
        GearDir slotParams(moduleParams, gearName);
        TOPGeoModule module(slotID,
                            slotParams.getLength("Radius"),
                            slotParams.getAngle("Phi"),
                            slotParams.getLength("BackwardZ"));
        int cNumber = slotParams.getInt("ConstructionNumber");
        module.setModuleCNumber(cNumber);
        module.setName(addNumber(module.getName(), cNumber));
 
        auto prism = createPrism(content, slotParams.getString("Prism"));
        prism.setName(addNumber(prism.getName(), cNumber));
        module.setPrism(prism);
 
        auto barSegment2 = createBarSegment(content, slotParams.getString("BarSegment2"));
        barSegment2.setName(addNumber(barSegment2.getName() + "2-", cNumber));
        barSegment2.setGlue(glueParams.getLength("Thicknes1"),
                            glueParams.getString("GlueMaterial"));
        module.setBarSegment2(barSegment2);
 
        auto barSegment1 = createBarSegment(content, slotParams.getString("BarSegment1"));
        barSegment1.setName(addNumber(barSegment1.getName() + "1-", cNumber));
        barSegment1.setGlue(glueParams.getLength("Thicknes2"),
                            glueParams.getString("GlueMaterial"));
        module.setBarSegment1(barSegment1);
 
        auto mirror = createMirrorSegment(content, slotParams.getString("Mirror"));
        mirror.setName(addNumber(mirror.getName(), cNumber));
        mirror.setGlue(glueParams.getLength("Thicknes3"),
                       glueParams.getString("GlueMaterial"));
        module.setMirrorSegment(mirror);
 
        module.setPMTArray(pmtArray);
        if (decoupledFraction > 0) module.generateDecoupledPMTs(decoupledFraction);
 
        geo->appendModule(module);
      }
 
      // displaced geometry (if defined)
 
      GearDir displacedGeometry(content, "DisplacedGeometry");
      if (displacedGeometry) {
        if (displacedGeometry.getInt("SwitchON") != 0) {
          B2WARNING("TOP: displaced geometry is activated");
          for (const GearDir& slot : displacedGeometry.getNodes("Slot")) {
            int moduleID = slot.getInt("@ID");
            if (!geo->isModuleIDValid(moduleID)) {
              B2WARNING("TOPGeometryPar: DisplacedGeometry.xml: invalid moduleID."
                        << LogVar("moduleID", moduleID));
              continue;
            }
            TOPGeoModuleDisplacement moduleDispl(slot.getLength("x"),
                                                 slot.getLength("y"),
                                                 slot.getLength("z"),
                                                 slot.getAngle("alpha"),
                                                 slot.getAngle("beta"),
                                                 slot.getAngle("gamma"));
            auto& module = const_cast<TOPGeoModule&>(geo->getModule(moduleID));
            module.setModuleDisplacement(moduleDispl);
          }
        }
      }
 
      // displaced PMT arrays (if defined)
 
      GearDir displacedPMTArrays(content, "DisplacedPMTArrays");
      if (displacedPMTArrays) {
        if (displacedPMTArrays.getInt("SwitchON") != 0) {
          B2WARNING("TOP: displaced PMT arrays are activated");
          for (const GearDir& slot : displacedPMTArrays.getNodes("Slot")) {
            int moduleID = slot.getInt("@ID");
            if (!geo->isModuleIDValid(moduleID)) {
              B2WARNING("TOPGeometryPar: DisplacedPMTArrays.xml: invalid moduleID."
                        << LogVar("moduleID", moduleID));
              continue;
            }
            TOPGeoPMTArrayDisplacement arrayDispl(slot.getLength("x"),
                                                  slot.getLength("y"),
                                                  slot.getAngle("alpha"));
            auto& module = const_cast<TOPGeoModule&>(geo->getModule(moduleID));
            module.setPMTArrayDisplacement(arrayDispl);
          }
        }
      }
 
      // broken glues (if any)
 
      GearDir brokenGlues(content, "BrokenGlues");
      if (brokenGlues) {
        if (brokenGlues.getInt("SwitchON") != 0) {
          auto material = brokenGlues.getString("material");
          for (const GearDir& slot : brokenGlues.getNodes("Slot")) {
            int moduleID = slot.getInt("@ID");
            if (!geo->isModuleIDValid(moduleID)) {
              B2WARNING("TOPGeometryPar: BrokenGlues.xml: invalid moduleID."
                        << LogVar("moduleID", moduleID));
              continue;
            }
            auto& module = const_cast<TOPGeoModule&>(geo->getModule(moduleID));
            for (const GearDir& glue : slot.getNodes("Glue")) {
              int glueID = glue.getInt("@ID");
              double fraction = glue.getDouble("fraction");
              if (fraction <= 0) continue;
              double angle = glue.getAngle("angle");
              module.setBrokenGlue(glueID, fraction, angle, material);
            }
          }
        }
      }
 
      // peel-off cookies (if any)
 
      GearDir peelOff(content, "PeelOffCookies");
      if (peelOff) {
        if (peelOff.getInt("SwitchON") != 0) {
          auto material = peelOff.getString("material");
          double thickness = peelOff.getLength("thickness");
          for (const GearDir& slot : peelOff.getNodes("Slot")) {
            int moduleID = slot.getInt("@ID");
            if (!geo->isModuleIDValid(moduleID)) {
              B2WARNING("TOPGeometryPar: PeelOffCookiess.xml: invalid moduleID."
                        << LogVar("moduleID", moduleID));
              continue;
            }
            auto& module = const_cast<TOPGeoModule&>(geo->getModule(moduleID));
            module.setPeelOffRegions(thickness, material);
            for (const GearDir& region : slot.getNodes("Region")) {
              int regionID = region.getInt("@ID");
              double fraction = region.getDouble("fraction");
              if (fraction <= 0) continue;
              double angle = region.getAngle("angle");
              module.appendPeelOffRegion(regionID, fraction, angle);
            }
          }
        }
      }
 
      // front-end electronics geometry
 
      GearDir feParams(content, "FrontEndGeo");
      GearDir fbParams(feParams, "FrontBoard");
      TOPGeoFrontEnd frontEnd;
      frontEnd.setFrontBoard(fbParams.getLength("width"),
                             fbParams.getLength("height"),
                             fbParams.getLength("thickness"),
                             fbParams.getLength("gap"),
                             fbParams.getLength("y"),
                             fbParams.getString("material"));
      GearDir hvParams(feParams, "HVBoard");
      frontEnd.setHVBoard(hvParams.getLength("width"),
                          hvParams.getLength("length"),
                          hvParams.getLength("thickness"),
                          hvParams.getLength("gap"),
                          hvParams.getLength("y"),
                          hvParams.getString("material"));
      GearDir bsParams(feParams, "BoardStack");
      frontEnd.setBoardStack(bsParams.getLength("width"),
                             bsParams.getLength("height"),
                             bsParams.getLength("length"),
                             bsParams.getLength("gap"),
                             bsParams.getLength("y"),
                             bsParams.getString("material"),
                             bsParams.getLength("spacerWidth"),
                             bsParams.getString("spacerMaterial"));
      geo->setFrontEnd(frontEnd, feParams.getInt("numBoardStacks"));
 
      // QBB
 
      GearDir qbbParams(content, "QBB");
      TOPGeoQBB qbb(qbbParams.getLength("width"),
                    qbbParams.getLength("length"),
                    qbbParams.getLength("prismPosition"),
                    qbbParams.getString("material"));
 
      GearDir outerPanelParams(qbbParams, "outerPanel");
      TOPGeoHoneycombPanel outerPanel(outerPanelParams.getLength("width"),
                                      outerPanelParams.getLength("length"),
                                      outerPanelParams.getLength("minThickness"),
                                      outerPanelParams.getLength("maxThickness"),
                                      outerPanelParams.getLength("radius"),
                                      outerPanelParams.getLength("edgeWidth"),
                                      outerPanelParams.getLength("y"),
                                      outerPanelParams.getInt("N"),
                                      outerPanelParams.getString("material"),
                                      outerPanelParams.getString("edgeMaterial"),
                                      "TOPOuterHoneycombPanel");
      qbb.setOuterPanel(outerPanel);
 
      GearDir innerPanelParams(qbbParams, "innerPanel");
      TOPGeoHoneycombPanel innerPanel(innerPanelParams.getLength("width"),
                                      innerPanelParams.getLength("length"),
                                      innerPanelParams.getLength("minThickness"),
                                      innerPanelParams.getLength("maxThickness"),
                                      innerPanelParams.getLength("radius"),
                                      innerPanelParams.getLength("edgeWidth"),
                                      innerPanelParams.getLength("y"),
                                      innerPanelParams.getInt("N"),
                                      innerPanelParams.getString("material"),
                                      innerPanelParams.getString("edgeMaterial"),
                                      "TOPInnerHoneycombPanel");
      qbb.setInnerPanel(innerPanel);
 
      GearDir sideRailsParams(qbbParams, "sideRails");
      TOPGeoSideRails sideRails(sideRailsParams.getLength("thickness"),
                                sideRailsParams.getLength("reducedThickness"),
                                sideRailsParams.getLength("height"),
                                sideRailsParams.getString("material"));
      qbb.setSideRails(sideRails);
 
      GearDir prismEnclParams(qbbParams, "prismEnclosure");
      TOPGeoPrismEnclosure prismEncl(prismEnclParams.getLength("length"),
                                     prismEnclParams.getLength("height"),
                                     prismEnclParams.getAngle("angle"),
                                     prismEnclParams.getLength("bottomThickness"),
                                     prismEnclParams.getLength("sideThickness"),
                                     prismEnclParams.getLength("backThickness"),
                                     prismEnclParams.getLength("frontThickness"),
                                     prismEnclParams.getLength("extensionThickness"),
                                     prismEnclParams.getString("material"));
      qbb.setPrismEnclosure(prismEncl);
 
      GearDir endPlateParams(qbbParams, "forwardEndPlate");
      TOPGeoEndPlate endPlate(endPlateParams.getLength("thickness"),
                              endPlateParams.getLength("height"),
                              endPlateParams.getString("material"),
                              "TOPForwardEndPlate");
      qbb.setEndPlate(endPlate);
 
      GearDir coldPlateParams(qbbParams, "coldPlate");
      TOPGeoColdPlate coldPlate(coldPlateParams.getLength("baseThickness"),
                                coldPlateParams.getString("baseMaterial"),
                                coldPlateParams.getLength("coolThickness"),
                                coldPlateParams.getLength("coolWidth"),
                                coldPlateParams.getString("coolMaterial"));
      qbb.setColdPlate(coldPlate);
 
      geo->setQBB(qbb);
 
      // nominal QE
 
      GearDir qeParams(content, "QE");
      std::vector<float> qeData;
      for (const GearDir& Qeffi : qeParams.getNodes("Qeffi")) {
        qeData.push_back(Qeffi.getDouble(""));
      }
      TOPNominalQE nominalQE(qeParams.getLength("LambdaFirst") / Unit::nm,
                             qeParams.getLength("LambdaStep") / Unit::nm,
                             qeParams.getDouble("ColEffi"),
                             qeData);
      geo->setNominalQE(nominalQE);
 
      // nominal TTS
 
      GearDir ttsParams(content, "PMTs/TTS");
      TOPNominalTTS nominalTTS("TOPNominalTTS");
      for (const GearDir& Gauss : ttsParams.getNodes("Gauss")) {
        nominalTTS.appendGaussian(Gauss.getDouble("fraction"),
                                  Gauss.getTime("mean"),
                                  Gauss.getTime("sigma"));
      }
      nominalTTS.normalize();
      geo->setNominalTTS(nominalTTS);
 
      // PMT type dependent TTS
 
      GearDir pmtTTSParams(content, "TTSofPMTs");
      for (const GearDir& ttsPar : pmtTTSParams.getNodes("TTSpar")) {
        int type = ttsPar.getInt("type");
        double tuneFactor = ttsPar.getDouble("PDEtuneFactor");
        TOPNominalTTS tts("TTS of " + ttsPar.getString("@name") + " PMT");
        tts.setPMTType(type);
        for (const GearDir& Gauss : ttsPar.getNodes("Gauss")) {
          tts.appendGaussian(Gauss.getDouble("fraction"),
                             Gauss.getTime("mean"),
                             Gauss.getTime("sigma"));
        }
        tts.normalize();
        geo->appendTTS(tts);
        geo->appendPDETuningFactor(type, tuneFactor);
      }
 
      // nominal TDC
 
      GearDir tdcParams(content, "TDC");
      if (tdcParams) {
        TOPNominalTDC nominalTDC(tdcParams.getInt("numWindows"),
                                 tdcParams.getInt("subBits"),
                                 tdcParams.getTime("syncTimeBase"),
                                 tdcParams.getInt("numofBunches"),
                                 tdcParams.getTime("offset"),
                                 tdcParams.getTime("pileupTime"),
                                 tdcParams.getTime("doubleHitResolution"),
                                 tdcParams.getTime("timeJitter"),
                                 tdcParams.getDouble("efficiency"));
        nominalTDC.setADCBits(tdcParams.getInt("adcBits"));
        nominalTDC.setAveragePedestal(tdcParams.getInt("averagePedestal"));
        geo->setNominalTDC(nominalTDC);
      } else {
        TOPNominalTDC nominalTDC(pmtParams.getInt("TDCbits"),
                                 pmtParams.getTime("TDCbitwidth"),
                                 pmtParams.getTime("TDCoffset", 0),
                                 pmtParams.getTime("TDCpileupTime", 0),
                                 pmtParams.getTime("TDCdoubleHitResolution", 0),
                                 pmtParams.getTime("TDCtimeJitter", 50e-3),
                                 pmtParams.getDouble("TDCefficiency", 1));
        geo->setNominalTDC(nominalTDC);
      }
 
      // single photon signal shape
 
      GearDir shapeParams(content, "SignalShape");
      if (shapeParams) {
        GearDir noiseBandwidth(shapeParams, "noiseBandwidth");
        TOPSignalShape signalShape(shapeParams.getArray("sampleValues"),
                                   geo->getNominalTDC().getSampleWidth(),
                                   shapeParams.getTime("tailTimeConstant"),
                                   noiseBandwidth.getDouble("pole1") / 1000,
                                   noiseBandwidth.getDouble("pole2") / 1000);
        geo->setSignalShape(signalShape);
      }
 
      // calibration pulse shape
 
      GearDir calpulseParams(content, "CalPulseShape");
      if (calpulseParams) {
        GearDir noiseBandwidth(calpulseParams, "noiseBandwidth");
        TOPSignalShape shape(calpulseParams.getArray("sampleValues"),
                             geo->getNominalTDC().getSampleWidth(),
                             calpulseParams.getTime("tailTimeConstant"),
                             noiseBandwidth.getDouble("pole1") / 1000,
                             noiseBandwidth.getDouble("pole2") / 1000);
        geo->setCalPulseShape(shape);
      }
 
      // wavelength filter bulk transmittance
 
      std::string materialNode = "Materials/Material[@name='TOPWavelengthFilterIHU340']";
      GearDir filterMaterial(content, materialNode);
      if (!filterMaterial) {
        B2FATAL("TOPGeometry: " << materialNode << " not found");
      }
      GearDir property(filterMaterial, "Property[@name='ABSLENGTH']");
      if (!property) {
        B2FATAL("TOPGeometry: " << materialNode << ", Property ABSLENGTH not found");
      }
      int numNodes = property.getNumberNodes("value");
      if (numNodes > 1) {
        double conversion = Unit::convertValue(1, property.getString("@unit", "GeV"));
        std::vector<double> energies;
        std::vector<double> absLengths;
        for (int i = 0; i < numNodes; i++) {
          GearDir value(property, "value", i + 1);
          energies.push_back(value.getDouble("@energy") * conversion / Unit::eV);// [eV]
          absLengths.push_back(value.getDouble() * Unit::mm); // [cm]
        }
        TSpline3 spline("absLen", energies.data(), absLengths.data(), energies.size());
        double lambdaFirst = c_hc / energies.back();
        double lambdaLast = c_hc / energies[0];
        double lambdaStep = 5; // [nm]
        int numSteps = (lambdaLast - lambdaFirst) / lambdaStep + 1;
        const double filterThickness = arrayParams.getLength("wavelengthFilter/thickness");
        std::vector<float> bulkTransmittances;
        for (int i = 0; i < numSteps; i++) {
          double wavelength = lambdaFirst + lambdaStep * i;
          double energy = c_hc / wavelength;
          double absLen = spline.Eval(energy);
          bulkTransmittances.push_back(exp(-filterThickness / absLen));
        }
        TOPWavelengthFilter filter(lambdaFirst, lambdaStep, bulkTransmittances);
        geo->setWavelengthFilter(filter);
      } else {
        B2FATAL("TOPGeometry: " << materialNode
                << ", Property ABSLENGTH has less than 2 nodes");
      }
 
      return geo;
    }

createMirrorSegment()

TOPGeoMirrorSegment createMirrorSegment ( const GearDir &  content, const std::string &  serialNumber  )

private

Create a parameter object from gearbox for mirror segment.

Parameters

content	XML data directory
serialNumber	mirror segment serial number

Definition at line 891 of file TOPGeometryPar.cc.

    {
      // dimensions and material
      GearDir params(content, "Mirrors/Mirror[@SerialNumber='" + SN + "']");
      TOPGeoMirrorSegment mirror(params.getLength("Width"),
                                 params.getLength("Thickness"),
                                 params.getLength("Length"),
                                 params.getString("Material"));
      mirror.setVendorData(params.getString("Vendor"), SN);
      mirror.setRadius(params.getLength("Radius"));
      mirror.setCenterOfCurvature(params.getLength("Xpos"), params.getLength("Ypos"));
 
      // mirror reflective coating
      auto& materials = geometry::Materials::getInstance();
      GearDir coatingParams(params, "Surface");
      mirror.setCoating(params.getLength("mirrorThickness"), "Al",
                        materials.createOpticalSurfaceConfig(coatingParams));
 
      // optical surface
      std::string surfaceName = params.getString("OpticalSurface");
      double sigmaAlpha = params.getDouble("SigmaAlpha");
      GearDir surfaceParams(content, "Modules/Surface[@name='" + surfaceName + "']");
      auto quartzSurface = materials.createOpticalSurfaceConfig(surfaceParams);
      mirror.setSurface(quartzSurface, sigmaAlpha);
 
      return mirror;
    }

createPrism()

TOPGeoPrism createPrism ( const GearDir &  content, const std::string &  serialNumber  )

private

Create a parameter object from gearbox for prism.

Parameters

content	XML data directory
serialNumber	prism serial number

Definition at line 921 of file TOPGeometryPar.cc.

    {
      // dimensions and material
      GearDir params(content, "Prisms/Prism[@SerialNumber='" + SN + "']");
      TOPGeoPrism prism(params.getLength("Width"),
                        params.getLength("Thickness"),
                        params.getLength("Length"),
                        params.getLength("ExitThickness"),
                        0.,
                        params.getString("Material"));
      prism.setAngle(params.getAngle("Angle"));
      prism.setVendorData(params.getString("Vendor"), SN);
 
      // optical surface
      std::string surfaceName = params.getString("OpticalSurface");
      double sigmaAlpha = params.getDouble("SigmaAlpha");
      GearDir surfaceParams(content, "Modules/Surface[@name='" + surfaceName + "']");
      auto& materials = geometry::Materials::getInstance();
      auto quartzSurface = materials.createOpticalSurfaceConfig(surfaceParams);
      prism.setSurface(quartzSurface, sigmaAlpha);
 
      return prism;
    }

finalizeInitialization()

void finalizeInitialization ( )

private

finalize initialization

Definition at line 135 of file TOPGeometryPar.cc.

    {
      // set B field flag
      m_BfieldOn = (BFieldManager::getField(0, 0, 0).R() / Unit::T) > 0.1;
 
      // add call backs for PMT data
      m_pmtInstalled.addCallback(this, &TOPGeometryPar::clearCache);
      m_pmtQEData.addCallback(this, &TOPGeometryPar::clearCache);
 
      // print geometry if the debug level for 'top' is set 10000
      const auto& logSystem = LogSystem::Instance();
      if (logSystem.isLevelEnabled(LogConfig::c_Debug, 10000, "top")) {
        getGeometry()->print();
        if (m_oldPayload) {
          cout << "Envelope QE same as nominal quantum efficiency" << endl << endl;
          return;
        }
        if (m_envelopeQE.isEmpty()) setEnvelopeQE();
        m_envelopeQE.print("Envelope QE");
      }
    }

getAbsorptionLength()

double getAbsorptionLength ( double  energy ) const

inline

Returns bulk absorption lenght of quartz at given photon energy.

Parameters

energy

photon energy [eV]

Returns

bulk absorption lenght

Definition at line 340 of file TOPGeometryPar.h.

    {
      double lambda = c_hc / energy;
      return 15100 * pow(lambda / 405, 4); // Alan Schwartz, 2013 (private comunication)
    }

getChannelMapper() [1/2]

const ChannelMapper & getChannelMapper ( ) const

inline

Returns default channel mapper (mapping of channels to pixels)

Returns

channel mapper object

Definition at line 83 of file TOPGeometryPar.h.

{return m_channelMapperIRSX;}

getChannelMapper() [2/2]

const ChannelMapper & getChannelMapper ( ChannelMapper::EType  type ) const

inline

Returns channel mapper (mapping of channels to pixels) - Gearbox only.

Returns

channel mapper object

Definition at line 89 of file TOPGeometryPar.h.

      {
        switch (type) {
          case ChannelMapper::c_IRS3B: return m_channelMapperIRS3B;
          case ChannelMapper::c_IRSX:  return m_channelMapperIRSX;
          default: return m_channelMapperIRSX;
        }
      }

getFrontEndMapper()

const FrontEndMapper & getFrontEndMapper ( ) const

inline

Returns front-end mapper (mapping of SCROD's to positions within TOP modules)

Returns

front-end mapper object

Definition at line 77 of file TOPGeometryPar.h.

{return m_frontEndMapper;}

getGeometry()

const TOPGeometry * getGeometry

(

)

const

Returns pointer to geometry object using basf2 units.

Returns

pointer to geometry object

Definition at line 165 of file TOPGeometryPar.cc.

    {
      if (!m_valid) B2FATAL("No geometry available for TOP");
 
      TOPGeometry::useBasf2Units();
      if (m_fromDB) {
        return &(**m_geoDB);
      } else {
        return m_geo;
      }
    }

getGroupIndex()

double getGroupIndex

(

double

energy

)

const

Returns group refractive index of quartz at given photon energy.

Parameters

energy

photon energy [eV]

Returns

group refractive index

Definition at line 981 of file TOPGeometryPar.cc.

    {
      double lambda = c_hc / energy;
      double dl = 1.0; // [nm]
      double n = refractiveIndex(lambda);
      double dndl = (refractiveIndex(lambda + dl / 2) - refractiveIndex(lambda - dl / 2)) / dl;
      return n / (1 + lambda / n * dndl);
    }

getGroupIndexDerivative()

double getGroupIndexDerivative ( double  energy ) const

inline

Returns the derivative (dn_g/dE) of group refractive index of quartz at given photon energy.

Parameters

energy

photon energy [eV]

Returns

group refractive index

Definition at line 334 of file TOPGeometryPar.h.

    {
      double dE = 0.01; // [eV]
      return (getGroupIndex(energy + dE / 2) - getGroupIndex(energy - dE / 2)) / dE;
    }

getPhaseIndex()

double getPhaseIndex

(

double

energy

)

const

Returns phase refractive index of quartz at given photon energy.

Parameters

energy

photon energy [eV]

Returns

phase refractive index

Definition at line 975 of file TOPGeometryPar.cc.

    {
      double lambda = c_hc / energy;
      return refractiveIndex(lambda);
    }

getPhaseIndexDerivative()

double getPhaseIndexDerivative ( double  energy ) const

inline

Returns the derivative (dn/dE) of phase refractive index of quartz at given photon energy.

Parameters

energy

photon energy [eV]

Returns

derivative of phase refractive index

Definition at line 328 of file TOPGeometryPar.h.

    {
      double dE = 0.01; // [eV]
      return (getPhaseIndex(energy + dE / 2) - getPhaseIndex(energy - dE / 2)) / dE;
    }

getPMTEfficiency()

double getPMTEfficiency	(	double	energy,
		int	moduleID,
		int	pmtID,
		double	x,
		double	y
	)		const

Returns PMT pixel efficiency, a product of quantum and collection efficiency.

Parameters

energy	photon energy in [eV]
moduleID	slot ID
pmtID	PMT ID
x	photon detection position x in local PMT frame
y	photon detection position y in local PMT frame

Returns

the efficiency

Definition at line 189 of file TOPGeometryPar.cc.

    {
      const auto* geo = getGeometry();
      if (!geo->isModuleIDValid(moduleID)) return 0;
 
      double lambda = c_hc / energy;
 
      if (m_oldPayload) { // filter transmittance is included in nominal QE, return it!
        return geo->getNominalQE().getEfficiency(lambda);
      }
 
      if (m_pmts.empty()) mapPmtQEToPositions();
 
      int id = getUniquePmtID(moduleID, pmtID);
      const auto* pmtQE = m_pmts[id];
      if (!pmtQE) return 0;
 
      const auto& pmtArray = geo->getModule(moduleID).getPMTArray();
      auto pmtPixel = pmtArray.getPMT().getPixelID(x, y);
      if (pmtPixel == 0) return 0;
 
      auto pixelID = pmtArray.getPixelID(pmtID, pmtPixel);
      auto channel = getChannelMapper().getChannel(pixelID);
 
      double RQE = geo->getPDETuningFactor(getPMTType(moduleID, pmtID));
      if (m_channelRQE.isValid()) RQE *= m_channelRQE->getRQE(moduleID, channel);
 
      return pmtQE->getEfficiency(pmtPixel, lambda, m_BfieldOn) * RQE;
 
    }

getPMTEfficiencyEnvelope()

double getPMTEfficiencyEnvelope

(

double

energy

)

const

Returns PMT efficiency envelope, e.g.

at given photon energy the maximum over all PMT's of a product of quantum and collection efficiency.

Parameters

energy

photon energy in [eV]

Returns

the maximal efficiency

Definition at line 177 of file TOPGeometryPar.cc.

    {
      double lambda = c_hc / energy;
 
      if (m_oldPayload) { // filter transmittance is included in nominal QE, return it!
        return getGeometry()->getNominalQE().getEfficiency(lambda);
      }
 
      if (m_envelopeQE.isEmpty()) setEnvelopeQE();
      return m_envelopeQE.getEfficiency(lambda);
    }

getPMTType()

unsigned getPMTType	(	int	moduleID,
		int	pmtID
	)		const

Returns PMT type at a given position.

Parameters

moduleID	slot ID
pmtID	PMT ID

Returns

PMT type

Definition at line 246 of file TOPGeometryPar.cc.

    {
      if (m_pmtTypes.empty()) mapPmtTypeToPositions();
 
      int id = getUniquePmtID(moduleID, pmtID);
      return m_pmtTypes[id];
    }

getRelativePixelEfficiency()

double getRelativePixelEfficiency	(	int	moduleID,
		int	pixelID
	)		const

Returns relative pixel efficiency (including CE, RQE and threshold efficiency)

Returns

pixel efficiency relative to nominal photocathode

Definition at line 223 of file TOPGeometryPar.cc.

    {
 
      auto channel = getChannelMapper().getChannel(pixelID);
      auto pmtID = getChannelMapper().getPmtID(pixelID);
 
      double RQE = getGeometry()->getPDETuningFactor(getPMTType(moduleID, pmtID));
      if (m_channelRQE.isValid()) RQE *= m_channelRQE->getRQE(moduleID, channel);
 
      double thrEffi = 1.0;
      if (m_thresholdEff.isValid()) thrEffi = m_thresholdEff->getThrEff(moduleID, channel);
 
      if (m_oldPayload) { // nominal QE is used
        return RQE * thrEffi;
      }
 
      if (m_relEfficiencies.empty()) prepareRelEfficiencies();
 
      int id = getUniquePixelID(moduleID, pixelID);
      return m_relEfficiencies[id] * RQE * thrEffi;
    }

getTTS()

const TOPNominalTTS & getTTS	(	int	moduleID,
		int	pmtID
	)		const

Returns TTS of a PMT at given position.

Parameters

moduleID	slot ID
pmtID	PMT ID

Returns

TTS

Definition at line 255 of file TOPGeometryPar.cc.

    {
      auto pmtType = getPMTType(moduleID, pmtID);
      return getGeometry()->getTTS(pmtType);
    }

getUniquePixelID()

int getUniquePixelID ( int  moduleID, int  pixelID  ) const

inlineprivate

Returns unique pixel ID within the detector.

Parameters

moduleID	slot ID
pixelID	pixel ID

Returns

unique ID

Definition at line 270 of file TOPGeometryPar.h.

      {
        return (moduleID << 16) + pixelID;
      }

getUniquePmtID()

int getUniquePmtID ( int  moduleID, int  pmtID  ) const

inlineprivate

Returns unique PMT ID within the detector.

Parameters

moduleID	slot ID
pmtID	PMT ID

Returns

unique ID

Definition at line 259 of file TOPGeometryPar.h.

      {
        return (moduleID << 16) + pmtID;
      }

Initialize() [1/2]

void Initialize

(

)

Initialize from database.

Definition at line 89 of file TOPGeometryPar.cc.

    {
      m_fromDB = true;
      m_valid = false;
 
      if (m_geoDB) delete m_geoDB;
      m_geoDB = new DBObjPtr<TOPGeometry>();
 
      if (!m_geoDB->isValid()) {
        B2ERROR("TOPGeometry: no payload found in database");
        return;
      }
      if ((*m_geoDB)->getWavelengthFilter().getName().empty()) {
        m_oldPayload = true;
        B2WARNING("TOPGeometry: obsolete payload revision (pixel independent PDE) - please, check global tag");
      }
      if ((*m_geoDB)->getTTSes().empty()) {
        B2WARNING("TOPGeometry: obsolete payload revision (nominal TTS only) - please, check global tag");
      }
      if ((*m_geoDB)->arePDETuningFactorsEmpty()) {
        B2WARNING("TOPGeometry: old payload revision (before bugfix and update of optical properties)");
      }
 
      // Make sure that we abort as soon as the geometry changes
      m_geoDB->addCallback([]() {
        B2FATAL("Geometry cannot change during processing, "
                "aborting (component TOP)");
      });
 
      m_frontEndMapper.initialize();
      if (!m_frontEndMapper.isValid()) {
        B2ERROR("TOPFrontEndMaps: no payload found in database");
        return;
      }
 
      m_channelMapperIRSX.initialize();
      if (!m_channelMapperIRSX.isValid()) {
        B2ERROR("TOPChannelMaps: no payload found in database");
        return;
      }
      m_valid = true;
 
      finalizeInitialization();
 
    }

Initialize() [2/2]

void Initialize

(

const GearDir &

content

)

Initialize from Gearbox (XML)

Parameters

content

XML data directory

Definition at line 52 of file TOPGeometryPar.cc.

    {
 
      m_fromDB = false;
      m_valid = false;
 
      if (m_geo) delete m_geo;
      m_geo = createConfiguration(content);
      if (!m_geo->isConsistent()) {
        B2ERROR("TOPGeometryPar::createConfiguration: geometry not consistently defined");
        return;
      }
 
      GearDir frontEndMapping(content, "FrontEndMapping");
      m_frontEndMapper.initialize(frontEndMapping);
      if (!m_frontEndMapper.isValid()) {
        return;
      }
 
      GearDir channelMapping0(content, "ChannelMapping[@type='IRS3B']");
      m_channelMapperIRS3B.initialize(channelMapping0);
      if (!m_channelMapperIRS3B.isValid()) {
        return;
      }
 
      GearDir channelMapping1(content, "ChannelMapping[@type='IRSX']");
      m_channelMapperIRSX.initialize(channelMapping1);
      if (!m_channelMapperIRSX.isValid()) {
        return;
      }
      m_valid = true;
 
      finalizeInitialization();
 
    }

Instance()

TOPGeometryPar * Instance ( )

static

Static method to obtain the pointer to its instance.

Returns

pointer to the instance of this class.

Definition at line 43 of file TOPGeometryPar.cc.

    {
      if (!s_instance) {
        s_instance = new TOPGeometryPar();
      }
      return s_instance;
    }

integralOfQE()

double integralOfQE ( const std::vector< float > &  qe, double  ce, double  lambdaFirst, double  lambdaStep  ) const

private

Returns integral of quantum efficiency over photon energies.

Parameters

qe	quantum efficiency data points
ce	collection efficiency data points
lambdaFirst	wavelenght of the first data point [nm]
lambdaStep	wavelength step [nm]

Returns

integral [eV]

Definition at line 419 of file TOPGeometryPar.cc.

    {
      if (qe.empty()) return 0;
 
      double s = 0;
      double lambda = lambdaFirst;
      double f1 = qe[0] / (lambda * lambda);
      for (size_t i = 1; i < qe.size(); i++) {
        lambda += lambdaStep;
        double f2 = qe[i] / (lambda * lambda);
        s += (f1 + f2) / 2;
        f1 = f2;
      }
      return s * c_hc * lambdaStep * ce;
    }

isValid()

bool isValid ( ) const

inline

check if the geometry is available

Returns

true if available

Definition at line 65 of file TOPGeometryPar.h.

{return m_valid;}

mapPmtQEToPositions()

void mapPmtQEToPositions ( ) const

private

Maps PMT QE data to positions within the detector.

Definition at line 340 of file TOPGeometryPar.cc.

    {
      m_pmts.clear();
 
      std::map<std::string, const TOPPmtQE*> map;
      for (const auto& pmt : m_pmtQEData) {
        map[pmt.getSerialNumber()] = &pmt;
      }
      for (const auto& pmt : m_pmtInstalled) {
        int id = getUniquePmtID(pmt.getSlotNumber(), pmt.getPosition());
        m_pmts[id] = map[pmt.getSerialNumber()];
      }
 
      B2INFO("TOPGeometryPar: QE of PMT's mapped to positions, size = " << m_pmts.size());
    }

mapPmtTypeToPositions()

void mapPmtTypeToPositions ( ) const

private

Maps PMT type to positions within the detector.

Definition at line 357 of file TOPGeometryPar.cc.

    {
      for (const auto& pmt : m_pmtInstalled) {
        int id = getUniquePmtID(pmt.getSlotNumber(), pmt.getPosition());
        m_pmtTypes[id] = pmt.getType();
      }
 
      B2INFO("TOPGeometryPar: PMT types mapped to positions, size = "
             << m_pmtTypes.size());
 
 
      std::set<unsigned> types;
      for (const auto& pmt : m_pmtInstalled) {
        types.insert(pmt.getType());
      }
      const auto* geo = getGeometry();
      for (const auto& type : types) {
        if (geo->getTTS(type).getPMTType() != type) {
          B2WARNING("No TTS found for an installed PMT type. Nominal one will be used."
                    << LogVar("PMT type", type));
        }
      }
 
    }

prepareRelEfficiencies()

void prepareRelEfficiencies ( ) const

private

Prepares a map of relative pixel efficiencies.

Definition at line 383 of file TOPGeometryPar.cc.

    {
      m_relEfficiencies.clear();
      if (m_pmts.empty()) mapPmtQEToPositions();
 
      const auto* geo = getGeometry();
 
      const auto& nominalQE = geo->getNominalQE();
      double s0 = integralOfQE(nominalQE.getQE(), nominalQE.getCE(),
                               nominalQE.getLambdaFirst(), nominalQE.getLambdaStep());
 
      for (const auto& module : geo->getModules()) {
        auto moduleID = module.getModuleID();
        const auto& pmtArray = module.getPMTArray();
        int numPMTs = pmtArray.getSize();
        int numPMTPixels = pmtArray.getPMT().getNumPixels();
        for (int pmtID = 1; pmtID <= numPMTs; pmtID++) {
          const auto* pmtQE = m_pmts[getUniquePmtID(moduleID, pmtID)];
          for (int pmtPixel = 1; pmtPixel <= numPMTPixels; pmtPixel++) {
            double s = 0;
            if (pmtQE) {
              s = integralOfQE(pmtQE->getQE(pmtPixel), pmtQE->getCE(m_BfieldOn),
                               pmtQE->getLambdaFirst(), pmtQE->getLambdaStep());
            }
            auto pixelID = pmtArray.getPixelID(pmtID, pmtPixel);
            auto id = getUniquePixelID(moduleID, pixelID);
            m_relEfficiencies[id] = s / s0;
          }
        }
      }
 
      B2INFO("TOPGeometryPar: pixel relative quantum efficiencies have been set, size = "
             << m_relEfficiencies.size());
    }

refractiveIndex()

double refractiveIndex ( double  lambda ) const

private

Quartz refractive index (SellMeier equation)

Parameters

lambda

photon wavelength [nm]

Returns

refractive index

Definition at line 959 of file TOPGeometryPar.cc.

    {
      // parameters of SellMeier equation (Matsuoka-san, 24.11.2018)
      // from the specs of Corning HPFS 7980
      // https://www.corning.com/media/worldwide/csm/documents/5bf092438c5546dfa9b08e423348317b.pdf
      const double b[] = {0.683740494, 0.420323613, 0.585027480};
      const double c[] = {0.00460352869, 0.0133968856, 64.4932732};
 
      double x = pow(lambda * 0.001, 2);
      double y = 1;
      for (int i = 0; i < 3; i++) {
        y += b[i] * x / (x - c[i]);
      }
      return sqrt(y);
    }

setEnvelopeQE()

void setEnvelopeQE ( ) const

private

Constructs envelope of quantum efficiency from PMT data.

Definition at line 262 of file TOPGeometryPar.cc.

    {
      if (m_pmtQEData.getEntries() == 0) {
        B2ERROR("DBArray TOPPmtQEs is empty");
        return;
      }
 
      double lambdaFirst = 0;
      for (const auto& pmt : m_pmtQEData) {
        if (pmt.getLambdaFirst() > 0) {
          lambdaFirst = pmt.getLambdaFirst();
          break;
        }
      }
      if (lambdaFirst == 0) {
        B2ERROR("DBArray TOPPmtQEs: lambdaFirst of all PMT found to be less or equal 0");
        return;
      }
      for (const auto& pmt : m_pmtQEData) {
        if (pmt.getLambdaFirst() > 0) {
          lambdaFirst = std::min(lambdaFirst, pmt.getLambdaFirst());
        }
      }
 
      double lambdaStep = 0;
      for (const auto& pmt : m_pmtQEData) {
        if (pmt.getLambdaStep() > 0) {
          lambdaStep = pmt.getLambdaStep();
          break;
        }
      }
      if (lambdaStep == 0) {
        B2ERROR("DBArray TOPPmtQEs: lambdaStep of all PMT found to be less or equal 0");
        return;
      }
      for (const auto& pmt : m_pmtQEData) {
        if (pmt.getLambdaStep() > 0) {
          lambdaStep = std::min(lambdaStep, pmt.getLambdaStep());
        }
      }
 
      std::map<std::string, const TOPPmtInstallation*> map;
      for (const auto& pmt : m_pmtInstalled) {
        map[pmt.getSerialNumber()] = &pmt;
      }
      const auto* geo = getGeometry();
 
      std::vector<float> envelopeQE;
      for (const auto& pmt : m_pmtQEData) {
        float ce = pmt.getCE(m_BfieldOn);
        auto pmtInstalled = map[pmt.getSerialNumber()];
        if (pmtInstalled) ce *= geo->getPDETuningFactor(pmtInstalled->getType());
        if (pmt.getLambdaFirst() == lambdaFirst and pmt.getLambdaStep() == lambdaStep) {
          const auto& envelope = pmt.getEnvelopeQE();
          if (envelopeQE.size() < envelope.size()) {
            envelopeQE.resize(envelope.size() - envelopeQE.size(), 0);
          }
          for (size_t i = 0; i < std::min(envelopeQE.size(), envelope.size()); i++) {
            envelopeQE[i] = std::max(envelopeQE[i], envelope[i] * ce);
          }
        } else {
          double lambdaLast = pmt.getLambdaLast();
          int nExtra = (lambdaLast - lambdaFirst) / lambdaStep + 1 - envelopeQE.size();
          if (nExtra > 0) envelopeQE.resize(nExtra, 0);
          for (size_t i = 0; i < envelopeQE.size(); i++) {
            float qe = pmt.getEnvelopeQE(lambdaFirst + lambdaStep * i);
            envelopeQE[i] = std::max(envelopeQE[i], qe * ce);
          }
        }
      }
 
      m_envelopeQE.set(lambdaFirst, lambdaStep, 1.0, envelopeQE, "EnvelopeQE");
 
      B2INFO("TOPGeometryPar: envelope of PMT dependent QE has been set");
 
    }

Member Data Documentation

c_hc

const double c_hc = 1239.84193

static

Planck constant times speed of light in [eV*nm].

Definition at line 175 of file TOPGeometryPar.h.

m_BfieldOn

bool m_BfieldOn = true

private

true if B field is on

Definition at line 301 of file TOPGeometryPar.h.

m_channelMapperIRS3B

ChannelMapper m_channelMapperIRS3B

private

channel-pixel mapper

Definition at line 306 of file TOPGeometryPar.h.

m_channelMapperIRSX

ChannelMapper m_channelMapperIRSX

private

channel-pixel mapper

Definition at line 307 of file TOPGeometryPar.h.

m_channelRQE

DBObjPtr<TOPCalChannelRQE> m_channelRQE

private

channel relative quantum effi.

Definition at line 313 of file TOPGeometryPar.h.

m_envelopeQE

TOPNominalQE m_envelopeQE

mutableprivate

envelope quantum efficiency

Definition at line 317 of file TOPGeometryPar.h.

m_fromDB

bool m_fromDB = false

private

parameters from database or Gearbox

Definition at line 298 of file TOPGeometryPar.h.

m_frontEndMapper

FrontEndMapper m_frontEndMapper

private

front end electronics mapper

Definition at line 305 of file TOPGeometryPar.h.

m_geo

TOPGeometry* m_geo = 0

private

geometry parameters from Gearbox

Definition at line 296 of file TOPGeometryPar.h.

m_geoDB

DBObjPtr<TOPGeometry>* m_geoDB = 0

private

geometry parameters from database

Definition at line 297 of file TOPGeometryPar.h.

m_oldPayload

bool m_oldPayload = false

private

true if old payload found in DB

Definition at line 300 of file TOPGeometryPar.h.

m_pmtInstalled

OptionalDBArray<TOPPmtInstallation> m_pmtInstalled

private

PMT installation data.

Definition at line 311 of file TOPGeometryPar.h.

m_pmtQEData

OptionalDBArray<TOPPmtQE> m_pmtQEData

private

quantum efficiencies

Definition at line 312 of file TOPGeometryPar.h.

m_pmts

std::map<int, const TOPPmtQE*> m_pmts

mutableprivate

QE data mapped to positions.

Definition at line 318 of file TOPGeometryPar.h.

m_pmtTypes

std::map<int, unsigned> m_pmtTypes

mutableprivate

PMT types mapped to positions.

Definition at line 320 of file TOPGeometryPar.h.

m_relEfficiencies

std::map<int, double> m_relEfficiencies

mutableprivate

pixel relative QE

Definition at line 319 of file TOPGeometryPar.h.

m_thresholdEff

DBObjPtr<TOPCalChannelThresholdEff> m_thresholdEff

private

channel threshold effi.

Definition at line 314 of file TOPGeometryPar.h.

m_valid

bool m_valid = false

private

true if geometry is available

Definition at line 299 of file TOPGeometryPar.h.

s_instance

TOPGeometryPar * s_instance = 0

staticprivate

Pointer to the class instance.

Definition at line 324 of file TOPGeometryPar.h.

---

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

• top/geometry/include/TOPGeometryPar.h
• top/geometry/src/TOPGeometryPar.cc