ATLAS Offline Software
Loading...
Searching...
No Matches
TileInfoLoader Class Reference

#include <TileInfoLoader.h>

Inheritance diagram for TileInfoLoader:
Collaboration diagram for TileInfoLoader:

Public Member Functions

 TileInfoLoader (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~TileInfoLoader ()
virtual StatusCode initialize () override
virtual StatusCode finalize () override
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Member Functions

static const InterfaceID & interfaceID ()

Private Member Functions

StatusCode buildDigitsShapesHiLo (TileInfo &info)
StatusCode buildTTL1Shapes (TileInfo &info, const std::string &ShapeFile, int &NBins, int &Time0Bin, int &BinsPerX, std::vector< double > &FullShape, std::vector< double > &Shape)
void buildCovMatrix (TileInfo &info)
 TileInfoLoader (const TileInfoLoader &)
TileInfoLoader & operator= (const TileInfoLoader &)

Private Attributes

Gaudi::Property< std::string > m_tileInfoName
ServiceHandle< StoreGateSvc > m_detStore
TilePulseShapes * m_pulsevar
 Pointer to TilePulseShapes object.
Gaudi::Property< int > m_nSamples {this, "NSamples", 7, "Number of 25ns time slices in TileDigits"}
 Properties to forward to TileInfo.
Gaudi::Property< int > m_iTrigSample {this, "TrigSample", 3, "sample index of t=0 in TileDigits"}
Gaudi::Property< bool > m_tileNoise {this, "TileNoise", true, "true => add noise to TileDigits and TileRawChannels (used in MC generation)"}
Gaudi::Property< bool > m_tileCoherNoise {this, "TileCoherNoise", false, "true => add coherent noise to TileDigits and TileRawChannels (used in MC generation)"}
Gaudi::Property< bool > m_tileZeroSuppress {this, "TileZeroSuppress", false, "true => applies threshold cuts in HitToRC, HitToDigits, RCToCells"}
Gaudi::Property< int > m_noiseScaleIndex {this, "NoiseScaleIndex", 1, "allowed values 0-3 to choose proper ADC->OF noise scale factor for different OF methods"}
Gaudi::Property< double > m_thresholdRawChannel {this, "ThresholdRawChannel", -3.0, "threshold for TileRawChannel [adc] (high gain only, negative -> cut on abs value)"}
Gaudi::Property< double > m_thresholdDigits {this, "ThresholdDigits", -2.0, "threshold for TileDigits [adc] (high gain only, negative -> cut on abs value)"}
Gaudi::Property< double > m_ttL1Calib {this, "TTL1Calib", 4.1, "converts pCb to mV for TTL1"}
Gaudi::Property< double > m_ttL1NoiseSigma {this, "TTL1NoiseSigma", 2.5, "sigma of noise in TTL1 (mV)"}
Gaudi::Property< double > m_ttL1Thresh {this, "TTL1Thresh", 5.0, "threshold cut for TTL1 signals (mV)"}
Gaudi::Property< double > m_ttL1Ped {this, "TTL1Ped", 0.0, "pedestal for TTL1 signals (mV)"}
Gaudi::Property< double > m_ttL1Max {this, "TTL1Max", 1850.0, "max value for TTL1 signals (mV)"}
Gaudi::Property< double > m_MuRcvCalib {this, "MuRcvCalib", 14.20, "converts pCb to ADC counts for MuRcv"}
Gaudi::Property< double > m_MuRcvNoiseSigma {this, "MuRcvNoiseSigma", 2, "sigma of noise in MuRcv (ADC counts)"}
Gaudi::Property< double > m_MuRcvThresh {this, "MuRcvThresh", 5, "threshold cut for MuRcv signals (ADC count)"}
Gaudi::Property< double > m_MuRcvPed {this, "MuRcvPed", 11.73, "pedestal for MuRcv signals (ADC count)"}
Gaudi::Property< double > m_MuRcvMax {this, "MuRcvMax", 255, "max value for MuRcv signals (ADC count)"}
Gaudi::Property< double > m_muL1Calib {this, "MuL1Calib", 204.2, "converts pCb to mV for Mu"}
Gaudi::Property< double > m_muL1NoiseSigma {this, "MuL1NoiseSigma", 15.6, "sigma of noise in Mu (mV)"}
Gaudi::Property< double > m_muL1Thresh {this, "MuL1Thresh", 5.0, "threshold cut for Mu signals (mV)"}
Gaudi::Property< double > m_muL1Ped {this, "MuL1Ped", 0.0, "pedestal for Mu signals (mV)"}
Gaudi::Property< double > m_muL1Max {this, "MuL1Max", 1850.0, "max value for Mu signals (mV)"}
Gaudi::Property< double > m_mbtsL1Calib {this, "MBTSL1Calib", 222.0, "converts pCb to mV for MBTS"}
Gaudi::Property< double > m_mbtsL1NoiseSigma {this, "MBTSL1NoiseSigma", 0.6, "sigma of noise in MBTS (mV)"}
Gaudi::Property< double > m_mbtsL1Thresh {this, "MBTSL1Thresh", 5.0, "threshold cut for MBTS signals (mV)"}
Gaudi::Property< double > m_mbtsL1Ped {this, "MBTSL1Ped", 0.0, "pedestal for MBTS signals (mV)"}
Gaudi::Property< double > m_mbtsL1Max {this, "MBTSL1Max", 1850.0, "max value for MBTS signals (mV)"}
Gaudi::Property< double > m_ttL1CosmicsGain {this, "TTL1CosmicsGain", 5.0, "gain of the Cosmics board"}
Gaudi::Property< double > m_ttL1CosmicsThresh {this, "TTL1CosmicsThresh", 5.0, "threshold in the Cosmics board"}
Gaudi::Property< int > m_ADCmax {this, "ADCmax", 1023, "Maximum ADC value"}
Gaudi::Property< int > m_ADCmaskValue {this, "ADCmaskValue", 2047, "ADC mask value"}
TileWienerFilterWeights * m_WFWeights
 Pointer to Wiener Filtering weights.
Gaudi::Property< std::string > m_digitsShapeFileHi {this, "DigitsShapeFileHi", "pulsehi_physics.dat", "Filename for high gain pulse shape"}
 Filenames of input files.
Gaudi::Property< std::string > m_digitsShapeFileLo {this, "DigitsShapeFileLo", "pulselo_physics.dat", "Filename for low gain pulse shape"}
Gaudi::Property< std::string > m_TTL1ShapeFile {this, "filename_TTL1ShapeFile", "pulse_adder_tower_physics.dat", "Filename for trigger tower pulse shape"}
Gaudi::Property< std::string > m_MuRcvShapeFile {this, "filename_MuRcvShapeFile", "pulse_adder_muonRcv_physics.dat", "Filename for Muon Receiver pulse shape"}
Gaudi::Property< std::string > m_MuL1ShapeFile {this, "filename_MuL1ShapeFile", "pulse_adder_muon_physics.dat", "Filename for muon level1 trigger pulse shape"}
Gaudi::Property< std::string > m_DecoCovaFilePrefix {this, "filename_DecoCovaFilePrefix", "DecoCovaMatrix", "Prefix of the files with decomposed covariance matrices for coherent noise simulation"}
Gaudi::Property< std::string > m_filenameLoCIS {this, "filename_lo_cis", "pulselo_cis_100.dat", "Low gain CIS pulseshape 100pF"}
 Reference pulse shape filenames, forwarded to TilePulseShapes in initialize().
Gaudi::Property< std::string > m_filenameLoCISDer {this, "filename_lo_cis_der", "dpulselo_cis_100.dat", "Low gain CIS pulseshape derivative 100pF"}
Gaudi::Property< std::string > m_filenameSLoCIS {this, "filename_slo_cis", "pulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape 5pF"}
Gaudi::Property< std::string > m_filenameSLoCISDer {this, "filename_slo_cis_der", "dpulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape derivative pF"}
Gaudi::Property< std::string > m_filenameHiCIS {this, "filename_hi_cis", "pulsehi_cis_100.dat", "High gain CIS pulseshape 100pF"}
Gaudi::Property< std::string > m_filenameHiCISDer {this, "filename_hi_cis_der", "dpulsehi_cis_100.dat", "High gain CIS pulseshape derivative 100pF"}
Gaudi::Property< std::string > m_filenameSHiCIS {this, "filename_shi_cis", "pulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape 5pF"}
Gaudi::Property< std::string > m_filenameSHiCISDer {this, "filename_shi_cis_der", "dpulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape derivative 5pF"}
Gaudi::Property< std::string > m_filenameLoPhys {this, "filename_lo_phys", "pulselo_physics.dat", "Low gain physics pulseshape"}
Gaudi::Property< std::string > m_filenameHiPhys {this, "filename_hi_phys", "pulsehi_physics.dat", "High gain physics pulseshape"}
Gaudi::Property< std::string > m_filenameLoPhysDer {this, "filename_lo_phys_der", "dpulselo_physics.dat", "Low gain physics pulseshape derivative"}
Gaudi::Property< std::string > m_filenameHiPhysDer {this, "filename_hi_phys_der", "dpulsehi_physics.dat", "High gain physics pulseshape derivative"}
Gaudi::Property< std::string > m_filenameLoLas {this, "filename_lo_las", "pulselo_laser.dat", "Low gain laser pulseshape"}
Gaudi::Property< std::string > m_filenameHiLas {this, "filename_hi_las", "pulsehi_laser.dat", "High gain laser pulseshape"}
Gaudi::Property< std::string > m_filenameLoLasDer {this, "filename_lo_las_der", "dpulselo_laser.dat", "Low gain laser pulseshape derivative"}
Gaudi::Property< std::string > m_filenameHiLasDer {this, "filename_hi_las_der", "dpulsehi_laser.dat", "High gain laser pulseshape derivative"}
Gaudi::Property< std::string > m_filenameSLeakLo {this, "filename_sleaklo", "leaklo.0230055.12.cap.5.2.dat", "Low gain CIS leakage pulse 5pF"}
Gaudi::Property< std::string > m_filenameLeakLo {this, "filename_leaklo", "leaklo_100.dat", "Low gain CIS leakage pulse 100pF"}
Gaudi::Property< std::string > m_filenameDSLeakLo {this, "filename_dsleaklo", "dsleaklo.0230055.12.cap.5.2.dat", "Derivative low gain CIS leakage pulse 5pF"}
Gaudi::Property< std::string > m_filenameDLeakLo {this, "filename_dleaklo", "dleaklo_100.dat", "Derivative low gain CIS leakage pulse 100pF"}
Gaudi::Property< std::string > m_filenameSLeakHi {this, "filename_sleakhi", "leakhi.0230055.12.cap.5.2.dat", "High gain CIS leakage pulse 5pF"}
Gaudi::Property< std::string > m_filenameLeakHi {this, "filename_leakhi", "leakhi_100.dat", "High gain CIS leakage pulse 100pF"}
Gaudi::Property< std::string > m_filenameDSLeakHi {this, "filename_dsleakhi", "dsleakhi.0230055.12.cap.5.2.dat", "Derivative high gain CIS leakage pulse 5pF"}
Gaudi::Property< std::string > m_filenameDLeakHi {this, "filename_dleakhi", "dleakhi_100.dat", "Derivative high gain CIS leakage pulse 100pF"}
Gaudi::Property< std::string > m_filenameOrigNoise {this, "filename_orig_noise", "noise_digi_orig.dat", "file with noise rms per channel"}
Gaudi::Property< std::string > m_filenameNkNoise {this, "filename_nk_noise", "noise_digi_nk.dat", "file with noise rms per channel"}
Gaudi::Property< bool > m_loadWienerFilterWeights {this, "LoadWienerFilterWeights", false, "Load Wiener filter weights"}
Gaudi::Property< int > m_WFNSamplesPhys {this, "WienerFilterPhysicsNSamples", 7, "Number of samples for Wiener filter physics weights"}
 Forwarded to TileWienerFilterWeights in initialize().
Gaudi::Property< int > m_WFLuminosity {this, "WienerFilterLuminosity", 40, "Luminosity for Wiener filter weights"}
std::string m_calibCntName
std::vector< std::string > m_connectedDrawers

Friends

class SvcFactory< TileInfoLoader >

Detailed Description

Definition at line 55 of file TileInfoLoader.h.

Constructor & Destructor Documentation

◆ TileInfoLoader() [1/2]

TileInfoLoader::TileInfoLoader ( const std::string & name,
ISvcLocator * pSvcLocator )

Definition at line 54 of file TileInfoLoader.cxx.

57 : AthService(name, pSvcLocator)
58 , m_detStore("DetectorStore", name)
59 , m_pulsevar(new TilePulseShapes())
60 , m_WFWeights(new TileWienerFilterWeights())
61{
62}
TilePulseShapes * m_pulsevar
Pointer to TilePulseShapes object.
ServiceHandle< StoreGateSvc > m_detStore
TileWienerFilterWeights * m_WFWeights
Pointer to Wiener Filtering weights.

◆ ~TileInfoLoader()

TileInfoLoader::~TileInfoLoader ( )
virtual

Definition at line 65 of file TileInfoLoader.cxx.

65 {
66//*****************************************************************************
67 delete m_pulsevar;
68 delete m_WFWeights;
69}

◆ TileInfoLoader() [2/2]

TileInfoLoader::TileInfoLoader ( const TileInfoLoader & )
private

Member Function Documentation

◆ buildCovMatrix()

void TileInfoLoader::buildCovMatrix ( TileInfo & info)
private

Definition at line 553 of file TileInfoLoader.cxx.

554{
555// author:F Spano' - beg.
556// TOUPDATE:: In the future maybe read from a root file
557// Read in Covariance Matrix for Hi Gain/Lo Gain - Barrel/Ext Barrel
558// from four external files
559
560// Changed by F. Veloso: full coverage of the Tilecal without using
561// the same correlation matrix for all modules.
562
563 char partstr[10];
564 char gainstr[10];
565 char buff[1024];
566 std::string line;
567
568 // Cicle over 4 partitions, 64 modules and 2 gains
569 for (int part = 0; part < 4; ++part) {
570 // Create DecoCovaria[part]
571// ATH_MSG_DEBUG( "begin DecoCovaria.push_back" );
572 info.m_decoCovaria.push_back(std::vector<std::vector<TMatrixD*> >());
573// ATH_MSG_DEBUG( "DecoCovaria.push_back done" );
574 for (int modu = 0; modu < 64; ++modu) {
575 // Create DecoCovaria[part][modu]
576// ATH_MSG_DEBUG( " begin DecoCovaria[part].push_back" );
577 info.m_decoCovaria[part].push_back(std::vector<TMatrixD*>());
578// ATH_MSG_DEBUG( " DecoCovaria[part].push_back done" );
579
580 for (int gain = 0; gain < 2; ++gain) {
581// ATH_MSG_DEBUG( " part=" << part << " modu=" << modu << " gain=" << gain );
582
583 // Open file which corresponds to DecoCovaria[part][modu][gain]
584 if (part == 0) sprintf(partstr, "EBA");
585 else if (part == 1) sprintf(partstr, "LBA");
586 else if (part == 2) sprintf(partstr, "LBC");
587 else sprintf(partstr, "EBC");
588
589 if (gain == 0) sprintf(gainstr, "Hi");
590 else sprintf(gainstr, "Lo");
591
592 sprintf(buff, "%s%s%02d%s.txt", m_DecoCovaFilePrefix.value().c_str(), partstr, modu + 1, gainstr);
593 std::string file = PathResolver::find_file(buff, "DATAPATH");
594// ATH_MSG_DEBUG( " buff=" << buff << " file=" << file.c_str() );
595
596 if (file.empty()) {
597 ATH_MSG_WARNING( "Could not find input file " << buff );
598 } else {
599 ATH_MSG_DEBUG( "Reading file " << file );
600
601 std::ifstream cov_file(file.c_str());
602
603 if (!cov_file.is_open()) {
604 ATH_MSG_WARNING( "Can't read input files, setting tileCoherNoise flag to FALSE" );
605
606 info.m_tileCoherNoise = false;
607 return;
608 } else {
609
610 ATH_MSG_DEBUG( " **** Start of Decomposed Covariance Matrix Read Out" );
611
612 if (std::getline(cov_file, line)) {
613 ATH_MSG_DEBUG( "Matrix is being loaded: " << line );
614 }
615
616 //define Matrix dimension
617 int dima = 0;
618 if (std::getline(cov_file, line)) {
619 if (sscanf(line.c_str(), "%80d", &dima) == 1)
620 ATH_MSG_DEBUG( "The Dimension of the matrix is " << dima );
621 }
622
623 // define Matrix: at this level we cannot initialize it with a given one
624 TMatrixD* pDecoCova = new TMatrixD(dima, dima);
625
626 // load tokens to be searched for in a string
627 char* word;
628 char* saveptr;
629 const char* TOKENS = { " \t\n" };
630
631 // read Matrix
632 int row = 0;
633 while (std::getline(cov_file, line) && row < dima) {
634 ATH_MSG_DEBUG( "line " << row << " is " << line );
635
636 strncpy(buff, line.c_str(), 1023);
637 for (int column = 0; column < dima; column++) {
638 // Check for comment lines
639 if (*buff == '!' || *buff == '*') continue;
640 //
641 if (column == 0) {
642 word = strtok_r(buff, TOKENS, &saveptr);
643 } else {
644 word = strtok_r(nullptr, TOKENS, &saveptr);
645 }
646 double pippo = (word) ? atof(word) : 0.0;
647 // int nread = sscanf(buff, "%1f", &pippo);
648 ATH_MSG_VERBOSE( "elem " << column << " is " << pippo );
649 (*pDecoCova)(row, column) = pippo;
650 }
651 row++;
652 }
653
654 cov_file.close();
655 // Fill DecoCovaria[part][modu][gain]
656 info.m_decoCovaria[part][modu].push_back(pDecoCova);
657
658 }
659 }
660 }
661 }
662 }
663}
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
Gaudi::Property< std::string > m_DecoCovaFilePrefix
double atof(std::string_view str)
Converts a string into a double / float.
row
Appending html table to final .html summary file.
TFile * file

◆ buildDigitsShapesHiLo()

StatusCode TileInfoLoader::buildDigitsShapesHiLo ( TileInfo & info)
private

Definition at line 241 of file TileInfoLoader.cxx.

241 {
242
243 ATH_MSG_DEBUG( "In buildDigitsShapesHiLo" );
244
245 // Read in Shape profile of digits signal from external file.
246
247 double It0;
248 double dbuff;
249 std::string line;
250
251 // Hi gain
252 ATH_MSG_DEBUG( " **** Start of High gain Pulse shapes in TileInfo " );
253
254 // Find the full path to filename:
255 std::string file_hi = PathResolver::find_file(m_digitsShapeFileHi, "DATAPATH");
256 ATH_MSG_DEBUG( "Reading file " << file_hi );
257
258 //=== Test if files are there and can be opened
259 if (file_hi.empty()) {
260 ATH_MSG_ERROR( "Could not find input file " << m_digitsShapeFileHi.value() );
261 return StatusCode::FAILURE;
262 }
263
264 std::ifstream shape_file_hi(file_hi.c_str());
265 if (!shape_file_hi.is_open()) {
266 ATH_MSG_ERROR( "Could not open input file " << file_hi );
267 return StatusCode::FAILURE;
268 }
269
270 if (std::getline(shape_file_hi, line)) {
271 ATH_MSG_DEBUG( endmsg << line );
272 }
273
274 if (std::getline(shape_file_hi, line)) {
275 if (sscanf(line.c_str(), "%80d", &info.m_digitsNBinsHi) == 1)
276 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsNBinsHi << " number of bins in shaping function" );
277 }
278
279 if (std::getline(shape_file_hi, line)) {
280 if (sscanf(line.c_str(), "%80d", &info.m_digitsTime0BinHi) == 1)
281 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsTime0BinHi << " index of in-time bin" );
282 }
283
284 if (std::getline(shape_file_hi, line)) {
285 if (sscanf(line.c_str(), "%80d", &info.m_digitsBinsPerXHi) == 1)
286 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsBinsPerXHi << " bins per beam crossing" );
287 }
288
289 // Read in the Hi gain shape vector.
290 info.m_digitsFullShapeHi.resize(info.m_digitsNBinsHi, 0.);
291 size_t jt = 0;
292 while (std::getline(shape_file_hi, line) && jt < info.m_digitsFullShapeHi.size()) {
293 int nread = sscanf(line.c_str(), "%80lf %80lf", &It0, &dbuff);
294 if (nread > 1) info.m_digitsFullShapeHi[jt++] = dbuff;
295 ATH_MSG_VERBOSE( "t= " << It0 << " a= " << dbuff );
296 }
297
298 shape_file_hi.close();
299
300 // Lo gain
301 ATH_MSG_DEBUG( " **** Start of Low gain Pulse shapes in TileInfo " );
302
303 // Find the full path to filename:
304 std::string file_lo = PathResolver::find_file(m_digitsShapeFileLo, "DATAPATH");
305 ATH_MSG_DEBUG( "Reading file " << file_lo );
306
307 //=== Test if files are there and can be opened
308 if (file_lo.empty()) {
309 ATH_MSG_ERROR( "Could not find input file " << m_digitsShapeFileLo.value() );
310 return StatusCode::FAILURE;
311 }
312
313 std::ifstream shape_file_lo(file_lo.c_str());
314 if (!shape_file_lo.is_open()) {
315 ATH_MSG_ERROR( "Could not open input file " << file_lo );
316 return StatusCode::FAILURE;
317 }
318
319 if (std::getline(shape_file_lo, line)) {
320 ATH_MSG_DEBUG( endmsg << line );
321 }
322
323 if (std::getline(shape_file_lo, line)) {
324 if (sscanf(line.c_str(), "%80d", &info.m_digitsNBinsLo) == 1)
325 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsNBinsLo << " number of bins in shaping function" );
326 }
327
328 if (std::getline(shape_file_lo, line)) {
329 if (sscanf(line.c_str(), "%80d", &info.m_digitsTime0BinLo) == 1)
330 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsTime0BinLo << " index of in-time bin" );
331 }
332
333 if (std::getline(shape_file_lo, line)) {
334 if (sscanf(line.c_str(), "%80d", &info.m_digitsBinsPerXLo) == 1)
335 ATH_MSG_DEBUG( std::setw(3) << info.m_digitsBinsPerXLo << " bins per beam crossing" );
336 }
337
338 // Read in the Lo gain shape vector.
339 info.m_digitsFullShapeLo.resize(info.m_digitsNBinsLo, 0.);
340 jt = 0;
341 while (std::getline(shape_file_lo, line) && jt < info.m_digitsFullShapeLo.size()) {
342 int nread = sscanf(line.c_str(), "%80lf %80lf", &It0, &dbuff);
343 if (nread > 1) info.m_digitsFullShapeLo[jt++] = dbuff;
344 ATH_MSG_VERBOSE( "t= " << It0 << " a= " << dbuff );
345 }
346
347 shape_file_lo.close();
348
349 //find the greatest value in digitsFullShape (should equal info.m_digitsTime0Bin)
350 int it0_hi = 0;
351 int it0_lo = 0;
352 double peak_hi = 0;
353 double peak_lo = 0;
354 for (int i = 0; i < info.m_digitsNBinsHi; i++) {
355 if (info.m_digitsFullShapeHi[i] > peak_hi) {
356 peak_hi = info.m_digitsFullShapeHi[i];
357 it0_hi = i;
358 }
359 }
360
361 for (int i = 0; i < info.m_digitsNBinsLo; i++) {
362 if (info.m_digitsFullShapeLo[i] > peak_lo) {
363 peak_lo = info.m_digitsFullShapeLo[i];
364 it0_lo = i;
365 }
366 }
367
368 if (msgLvl(MSG::DEBUG)) {
369 msg(MSG::DEBUG) << " High Gain: Peak value = " << peak_hi
370 << " at bin = " << it0_hi
371 << ", info.m_digitsTime0BinHi = " << info.m_digitsTime0BinHi << endmsg;
372
373 msg(MSG::DEBUG) << " Low Gain: Peak value = " << peak_lo
374 << " at bin = " << it0_lo
375 << ", info.m_digitsTime0BinLow = " << info.m_digitsTime0BinLo << endmsg;
376 }
377
378 // Create vector of time profiles at beam crossings.
379 info.m_digitsShapeHi.resize(info.m_nSamples, 0.);
380 info.m_digitsShapeLo.resize(info.m_nSamples, 0.);
381// ATH_MSG_DEBUG( " Pasa el resize y va a entrar en el lopp" );
382
383 for (int i = 0; i < info.m_nSamples; i++) {
384 int j = info.m_digitsTime0BinHi + (i - info.m_iTrigSample) * info.m_digitsBinsPerXHi;
385 if (j < 0) j = 0;
386 if (j >= info.m_digitsNBinsHi) j = info.m_digitsNBinsHi-1;
387 info.m_digitsShapeHi[i] = info.m_digitsFullShapeHi[j];
388 int k = info.m_digitsTime0BinLo + (i - info.m_iTrigSample) * info.m_digitsBinsPerXLo;
389 if (k < 0) k = 0;
390 if (k >= info.m_digitsNBinsLo) k = info.m_digitsNBinsLo-1;
391 info.m_digitsShapeLo[i] = info.m_digitsFullShapeLo[k];
392 }
393
394 if (msgLvl(MSG::DEBUG)) {
395 msg(MSG::DEBUG) << " Shaping profile at beam crossings: "
396 << " Number of samples = " << info.m_nSamples
397 << ", Sample at Time 0 = " << info.m_iTrigSample << endmsg;
398
399 msg(MSG::DEBUG) << " High gain Shape factor = ";
400 for (int i = 0; i < info.m_nSamples; i++) {
401 msg(MSG::DEBUG) << std::setiosflags(std::ios::fixed)
402 << std::setiosflags(std::ios::showpoint) << std::setw(9) << std::setprecision(5)
403 << info.m_digitsShapeHi[i];
404 }
405
406 msg(MSG::DEBUG) << endmsg;
407
408 msg(MSG::DEBUG) << " Low gain Shape factor = ";
409 for (int i = 0; i < info.m_nSamples; i++) {
410 msg(MSG::DEBUG) << std::setiosflags(std::ios::fixed)
411 << std::setiosflags(std::ios::showpoint) << std::setw(9) << std::setprecision(5)
412 << info.m_digitsShapeLo[i];
413 }
414 msg(MSG::DEBUG) << endmsg;
415
416 }
417
418 // Create vector of derivatives from shaping vector.
419 info.m_digitsDerivativeHi.resize(info.m_digitsNBinsHi, 0.);
420 info.m_digitsDerivativeLo.resize(info.m_digitsNBinsLo, 0.);
421 for (int i = 1; i < info.m_digitsNBinsHi - 1; i++) {
422 info.m_digitsDerivativeHi[i] = (info.m_digitsFullShapeHi[i + 1]
423 - info.m_digitsFullShapeHi[i - 1]) / 2;
424 }
425
426 for (int i = 1; i < info.m_digitsNBinsLo - 1; i++) {
427 info.m_digitsDerivativeLo[i] = (info.m_digitsFullShapeLo[i + 1]
428 - info.m_digitsFullShapeLo[i - 1]) / 2;
429 }
430
431 return StatusCode::SUCCESS;
432}
#define endmsg
#define ATH_MSG_ERROR(x,...)
bool msgLvl(const MSG::Level lvl) const
MsgStream & msg() const
Gaudi::Property< std::string > m_digitsShapeFileHi
Filenames of input files.
Gaudi::Property< std::string > m_digitsShapeFileLo
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)

◆ buildTTL1Shapes()

StatusCode TileInfoLoader::buildTTL1Shapes ( TileInfo & info,
const std::string & ShapeFile,
int & NBins,
int & Time0Bin,
int & BinsPerX,
std::vector< double > & FullShape,
std::vector< double > & Shape )
private

Definition at line 435 of file TileInfoLoader.cxx.

438 {
439
440 // Read in Shape profile of signal from external file.
441 ATH_MSG_DEBUG( " **** Start of TTL1 shapes in TileInfo " );
442
443 // Find the full path to filename:
444 std::string file = PathResolver::find_file(ShapeFile, "DATAPATH");
445 ATH_MSG_DEBUG( "Reading file " << file );
446
447 if (file.empty()) {
448 ATH_MSG_ERROR( "Could not find input file " << ShapeFile );
449 return StatusCode::FAILURE;
450 }
451
452 std::ifstream shape_file(file.c_str());
453 if (!shape_file.is_open()) {
454 ATH_MSG_ERROR( "Could not open input file " << file );
455 return StatusCode::FAILURE;
456 }
457
458 double It0;
459 double dbuff;
460 std::string line;
461
462 if (std::getline(shape_file, line)) {
463 ATH_MSG_DEBUG( endmsg << MSG::DEBUG << line );
464
465 }
466
467 if (std::getline(shape_file, line)) {
468 if (sscanf(line.c_str(), "%80d", &NBins) == 1)
469 ATH_MSG_DEBUG( std::setw(3) << NBins << " number of bins in shaping function" );
470 }
471
472 if (std::getline(shape_file, line)) {
473 if (sscanf(line.c_str(), "%80d", &Time0Bin) == 1)
474 ATH_MSG_DEBUG( std::setw(3) << Time0Bin << " index of in-time bin" );
475 }
476
477 if (std::getline(shape_file, line)) {
478 if (sscanf(line.c_str(), "%80d", &BinsPerX) == 1)
479 ATH_MSG_DEBUG( BinsPerX << " bins per beam crossing" );
480 }
481
482 // Read in the ttl1shape vector.
483 FullShape.resize(NBins, 0.);
484 size_t jt = 0;
485 while (std::getline(shape_file, line) && jt < FullShape.size()) {
486 int nread = sscanf(line.c_str(), "%80lf %80lf", &It0, &dbuff);
487 if (nread > 1) FullShape[jt++] = dbuff;
488 ATH_MSG_VERBOSE( "t= " << It0 << " a= " << dbuff );
489 }
490
491 shape_file.close();
492
493 // Print out ttl1shape values.
494 int nline = (NBins - 1) / 8 + 1;
495 if (msgLvl(MSG::DEBUG)) {
496 for (int jline = 0; jline < nline; jline++) {
497 int j1 = 8 * jline;
498 int j2 = j1 + 8;
499 if (j2 > NBins) j2 = NBins;
500 msg(MSG::DEBUG) << " " << std::setw(3) << j1 << " ";
501
502 for (int i = j1; i < j2; i++) {
503 msg(MSG::DEBUG) << std::setiosflags(std::ios::fixed)
504 << std::setiosflags(std::ios::showpoint) << std::setw(9) << std::setprecision(5)
505 << FullShape[i];
506 }
507 msg(MSG::DEBUG) << endmsg;
508 }
509 }
510
511 //find the greatest value in ttl1shape (should equal Time0Bin)
512 int it0 = 0;
513 double peak = 0;
514 for (int i = 0; i < NBins; i++) {
515 if (FullShape[i] > peak) {
516 peak = FullShape[i];
517 it0 = i;
518 }
519 }
520
521 ATH_MSG_DEBUG( " Peak value = " << peak
522 << " at bin = " << it0
523 << ", Time0Bin = " << Time0Bin );
524
525
526 // Create vector of time profiles at beam crossings.
527 Shape.resize(info.m_nSamples, 0.);
528 for (int i = 0; i < info.m_nSamples; i++) {
529 int j = Time0Bin + (i - info.m_iTrigSample) * BinsPerX;
530 if (j < 0) j = 0;
531 if (j >= NBins) j = NBins-1;
532 Shape[i] = FullShape[j];
533 }
534
535 if (msgLvl(MSG::DEBUG)) {
536 msg(MSG::DEBUG) << " TileInfo: profile at beam crossings: "
537 << " Number of samples = " << info.m_nSamples
538 << ", Sample at Time 0 = " << info.m_iTrigSample << endmsg;
539
540 msg(MSG::DEBUG) << " Shape factor = ";
541 for (int i = 0; i < info.m_nSamples; i++) {
542 msg(MSG::DEBUG) << std::setiosflags(std::ios::fixed)
543 << std::setiosflags(std::ios::showpoint) << std::setw(9) << std::setprecision(5)
544 << Shape[i];
545 }
546 msg(MSG::DEBUG) << endmsg;
547 }
548
549 return StatusCode::SUCCESS;
550}

◆ finalize()

StatusCode TileInfoLoader::finalize ( )
overridevirtual

Definition at line 230 of file TileInfoLoader.cxx.

230 {
231//****************************************************************************
232
233 ATH_MSG_DEBUG( "TileInfoLoader::finalize()" );
234
235 return Service::finalize();
236}

◆ initialize()

StatusCode TileInfoLoader::initialize ( )
overridevirtual

Definition at line 72 of file TileInfoLoader.cxx.

72 {
73//*****************************************************************************
74
75 ATH_MSG_DEBUG( "Initializing...." << name() );
76
77 auto info = std::make_unique<TileInfo>();
78
79 // Forward properties.
80 info->m_nSamples = m_nSamples;
81 info->m_iTrigSample = m_iTrigSample;
82 info->m_tileNoise = m_tileNoise;
83 info->m_tileCoherNoise = m_tileCoherNoise;
84 info->m_tileZeroSuppress = m_tileZeroSuppress;
85 info->m_noiseScaleIndex = m_noiseScaleIndex;
86 info->m_thresholdRawChannel = m_thresholdRawChannel;
87 info->m_thresholdDigits = m_thresholdDigits;
88 info->m_ttL1Calib = m_ttL1Calib;
89 info->m_ttL1NoiseSigma = m_ttL1NoiseSigma;
90 info->m_ttL1Thresh = m_ttL1Thresh;
91 info->m_ttL1Ped = m_ttL1Ped;
92 info->m_ttL1Max = m_ttL1Max;
93 info->m_MuRcvCalib = m_MuRcvCalib;
94 info->m_MuRcvNoiseSigma = m_MuRcvNoiseSigma;
95 info->m_MuRcvThresh = m_MuRcvThresh;
96 info->m_MuRcvPed = m_MuRcvPed;
97 info->m_MuRcvMax = m_MuRcvMax;
98 info->m_muL1Calib = m_muL1Calib;
99 info->m_muL1NoiseSigma = m_muL1NoiseSigma;
100 info->m_muL1Thresh = m_muL1Thresh;
101 info->m_muL1Ped = m_muL1Ped;
102 info->m_muL1Max = m_muL1Max;
103 info->m_mbtsL1Calib = m_mbtsL1Calib;
104 info->m_mbtsL1NoiseSigma = m_mbtsL1NoiseSigma;
105 info->m_mbtsL1Thresh = m_mbtsL1Thresh;
106 info->m_mbtsL1Ped = m_mbtsL1Ped;
107 info->m_mbtsL1Max = m_mbtsL1Max;
108 info->m_ttL1CosmicsGain = m_ttL1CosmicsGain;
109 info->m_ttL1CosmicsThresh = m_ttL1CosmicsThresh;
110 info->m_ADCmax = m_ADCmax;
111 info->m_ADCmaskValue = m_ADCmaskValue;
112
113 // Forward reference pulse shape filenames to TilePulseShapes.
114 m_pulsevar->m_filenameLoCIS = m_filenameLoCIS;
115 m_pulsevar->m_filenameLoCISDer = m_filenameLoCISDer;
116 m_pulsevar->m_filenameSLoCIS = m_filenameSLoCIS;
117 m_pulsevar->m_filenameSLoCISDer = m_filenameSLoCISDer;
118 m_pulsevar->m_filenameHiCIS = m_filenameHiCIS;
119 m_pulsevar->m_filenameHiCISDer = m_filenameHiCISDer;
120 m_pulsevar->m_filenameSHiCIS = m_filenameSHiCIS;
121 m_pulsevar->m_filenameSHiCISDer = m_filenameSHiCISDer;
122 m_pulsevar->m_filenameLoPhys = m_filenameLoPhys;
123 m_pulsevar->m_filenameHiPhys = m_filenameHiPhys;
124 m_pulsevar->m_filenameLoPhysDer = m_filenameLoPhysDer;
125 m_pulsevar->m_filenameHiPhysDer = m_filenameHiPhysDer;
126 m_pulsevar->m_filenameLoLas = m_filenameLoLas;
127 m_pulsevar->m_filenameHiLas = m_filenameHiLas;
128 m_pulsevar->m_filenameLoLasDer = m_filenameLoLasDer;
129 m_pulsevar->m_filenameHiLasDer = m_filenameHiLasDer;
130 m_pulsevar->m_filenameSLeakLo = m_filenameSLeakLo;
131 m_pulsevar->m_filenameLeakLo = m_filenameLeakLo;
132 m_pulsevar->m_filenameDSLeakLo = m_filenameDSLeakLo;
133 m_pulsevar->m_filenameDLeakLo = m_filenameDLeakLo;
134 m_pulsevar->m_filenameSLeakHi = m_filenameSLeakHi;
135 m_pulsevar->m_filenameLeakHi = m_filenameLeakHi;
136 m_pulsevar->m_filenameDSLeakHi = m_filenameDSLeakHi;
137 m_pulsevar->m_filenameDLeakHi = m_filenameDLeakHi;
138 m_pulsevar->m_filenameOrigNoise = m_filenameOrigNoise;
139 m_pulsevar->m_filenameNkNoise = m_filenameNkNoise;
140
141 // Forward Wiener filter configuration to TileWienerFilterWeights.
142 m_WFWeights->m_NSamples_Phys = m_WFNSamplesPhys;
143 m_WFWeights->m_Luminosity = m_WFLuminosity;
144
145 m_WFWeights->m_NSamples_Phys = info->m_nSamples; // to make sure that everything is consistent
146
147 //=== Find the detector store service.
148 CHECK( m_detStore.retrieve() );
149
150 SmartIF<IGeoModelSvc> geoModel{service("GeoModelSvc")};
151 if(!geoModel) {
152 ATH_MSG_ERROR( "Could not locate GeoModelSvc" );
153 } else {
154 // check the DetDescr version
155 std::string atlasVersion = geoModel->atlasVersion();
156 int geo = atlasVersion.compare(0,9,"ATLAS-GEO");
157 int run1 = atlasVersion.compare(0,8,"ATLAS-R1");
158 int ibl = atlasVersion.compare(0,9,"ATLAS-IBL");
159 int run2 = atlasVersion.compare(0,8,"ATLAS-R2");
160 int comm = atlasVersion.compare(0,10,"ATLAS-Comm");
161 int upg = atlasVersion.compare(0,7,"ATLAS-P") ;
162 int ver = 0;
163 const auto comparisons={geo, run1, ibl, run2, comm, upg};
164 bool nothing_found = std::none_of(comparisons.begin(), comparisons.end(), [](int zeroMeansFound){return zeroMeansFound==0;});
165 GeoModel::GeoConfig geoConfig = geoModel->geoConfig();
166 bool RUN2 = (nothing_found && (geoConfig==GeoModel::GEO_RUN2
167 || geoConfig==GeoModel::GEO_RUN3
168 || geoConfig==GeoModel::GEO_RUN4
169 )) || (run2 == 0); // calibration for all geometries >=RUN2 are the same as in RUN2
170
171 if (geo == 0 || comm == 0 || ibl == 0 || run1 == 0 || run2 == 0 || upg == 0 || RUN2) {
172 int pos = (atlasVersion.substr(9)).find('-');
173 if(run1 == 0 || run2 == 0) pos = (atlasVersion.substr(13)).find('-') + 4;
174 std::string geoVersion = atlasVersion.substr(pos+10,2)
175 + atlasVersion.substr(pos+13,2)
176 + atlasVersion.substr(pos+16,2);
177 ver = atoi(geoVersion.c_str());
178 ATH_MSG_DEBUG( "New ATLAS geometry detected: " << atlasVersion << " (" << geoVersion << ")" << " version " << ver );
179
180 if (fabs(info->m_ttL1Calib - 4.1) < 0.001) {
181 // They are TTL1Calib = 4.1 and TTL1NoiseSigma = 2.5 but should be 6.9 and 2.8 respectively.
182
183 msg(MSG::INFO) << "Changing TTL1 calib from " << info->m_ttL1Calib;
184 info->m_ttL1Calib = 6.9;
185 msg(MSG::INFO) << " to " << info->m_ttL1Calib << endmsg;
186
187 msg(MSG::INFO) << "Changing TTL1 noise sigma from " << info->m_ttL1NoiseSigma;
188 info->m_ttL1NoiseSigma = 2.8;
189 msg(MSG::INFO) << " to " << info->m_ttL1NoiseSigma << endmsg;
190 }
191 } else {
192 ATH_MSG_DEBUG( "ATLAS geometry " << atlasVersion << " version " << ver );
193 }
194
195 }
196
197 //=== Read in Shape profile of digits & TTL1
199
200 CHECK( buildTTL1Shapes(*info, m_TTL1ShapeFile, info->m_TTL1NBins, info->m_TTL1Time0Bin
201 , info->m_TTL1BinsPerX, info->m_TTL1FullShape, info->m_TTL1Shape) );
202
203
204 CHECK( buildTTL1Shapes(*info, m_MuRcvShapeFile, info->m_MuRcvNBins, info->m_MuRcvTime0Bin
205 , info->m_MuRcvBinsPerX, info->m_MuRcvFullShape, info->m_MuRcvShape) );
206
207 CHECK( buildTTL1Shapes(*info, m_MuL1ShapeFile, info->m_MuL1NBins, info->m_MuL1Time0Bin
208 , info->m_MuL1BinsPerX, info->m_MuL1FullShape, info->m_MuL1Shape) );
209
210 //=== Read in coherent noise if required
211 if (info->TileCoherNoise()) buildCovMatrix (*info);
212
213 // put pointer to new TilePulseShapes in TileInfo
214 // only if we want to use them (i.e. when we also read all calib files)
215 info->m_pulseShapes = m_pulsevar;
216
217 // point to WienerFilterWeights
218 if (m_loadWienerFilterWeights) info->m_WienerFilterWeights=m_WFWeights;
219
220 //=== Initialize and register TileInfo object
221 CHECK( info->initialize() );
222
223 CHECK( m_detStore->record(std::move(info), m_tileInfoName, false ) );
224 ATH_MSG_DEBUG( "Placed TileInfo object [" << m_tileInfoName << "] in the detector store." );
225
226 return StatusCode::SUCCESS;
227}
#define CHECK(...)
Evaluate an expression and check for errors.
Gaudi::Property< std::string > m_filenameHiLas
Gaudi::Property< double > m_ttL1Max
Gaudi::Property< double > m_ttL1CosmicsGain
Gaudi::Property< std::string > m_filenameLeakHi
Gaudi::Property< bool > m_tileCoherNoise
void buildCovMatrix(TileInfo &info)
Gaudi::Property< std::string > m_filenameSLeakHi
Gaudi::Property< double > m_mbtsL1Thresh
Gaudi::Property< std::string > m_filenameDSLeakHi
Gaudi::Property< double > m_ttL1Calib
Gaudi::Property< std::string > m_filenameHiLasDer
Gaudi::Property< double > m_thresholdRawChannel
Gaudi::Property< int > m_WFNSamplesPhys
Forwarded to TileWienerFilterWeights in initialize().
Gaudi::Property< std::string > m_filenameHiCISDer
Gaudi::Property< double > m_MuRcvCalib
Gaudi::Property< double > m_ttL1Ped
Gaudi::Property< double > m_ttL1CosmicsThresh
Gaudi::Property< std::string > m_filenameHiCIS
Gaudi::Property< int > m_noiseScaleIndex
Gaudi::Property< int > m_iTrigSample
Gaudi::Property< bool > m_tileNoise
Gaudi::Property< std::string > m_TTL1ShapeFile
Gaudi::Property< double > m_thresholdDigits
Gaudi::Property< std::string > m_filenameHiPhysDer
Gaudi::Property< double > m_ttL1Thresh
Gaudi::Property< std::string > m_filenameLoLasDer
Gaudi::Property< double > m_muL1Max
Gaudi::Property< int > m_WFLuminosity
Gaudi::Property< double > m_muL1Calib
Gaudi::Property< std::string > m_MuL1ShapeFile
Gaudi::Property< bool > m_tileZeroSuppress
Gaudi::Property< std::string > m_filenameDLeakLo
Gaudi::Property< double > m_mbtsL1Max
Gaudi::Property< std::string > m_filenameSHiCISDer
Gaudi::Property< std::string > m_filenameHiPhys
Gaudi::Property< int > m_ADCmax
Gaudi::Property< std::string > m_filenameSLeakLo
Gaudi::Property< std::string > m_filenameLeakLo
StatusCode buildDigitsShapesHiLo(TileInfo &info)
Gaudi::Property< double > m_mbtsL1Ped
Gaudi::Property< std::string > m_filenameDLeakHi
Gaudi::Property< std::string > m_filenameLoCISDer
Gaudi::Property< double > m_MuRcvNoiseSigma
Gaudi::Property< std::string > m_filenameLoCIS
Reference pulse shape filenames, forwarded to TilePulseShapes in initialize().
Gaudi::Property< std::string > m_filenameLoPhys
Gaudi::Property< std::string > m_filenameSLoCIS
Gaudi::Property< double > m_MuRcvMax
Gaudi::Property< std::string > m_filenameDSLeakLo
Gaudi::Property< double > m_MuRcvThresh
Gaudi::Property< bool > m_loadWienerFilterWeights
Gaudi::Property< std::string > m_filenameSHiCIS
Gaudi::Property< std::string > m_filenameLoLas
Gaudi::Property< int > m_nSamples
Properties to forward to TileInfo.
Gaudi::Property< double > m_MuRcvPed
Gaudi::Property< std::string > m_filenameNkNoise
Gaudi::Property< std::string > m_tileInfoName
Gaudi::Property< int > m_ADCmaskValue
Gaudi::Property< std::string > m_filenameOrigNoise
Gaudi::Property< double > m_muL1Thresh
Gaudi::Property< std::string > m_filenameLoPhysDer
Gaudi::Property< double > m_mbtsL1Calib
Gaudi::Property< double > m_ttL1NoiseSigma
Gaudi::Property< double > m_muL1Ped
StatusCode buildTTL1Shapes(TileInfo &info, const std::string &ShapeFile, int &NBins, int &Time0Bin, int &BinsPerX, std::vector< double > &FullShape, std::vector< double > &Shape)
Gaudi::Property< std::string > m_filenameSLoCISDer
Gaudi::Property< double > m_mbtsL1NoiseSigma
Gaudi::Property< double > m_muL1NoiseSigma
Gaudi::Property< std::string > m_MuRcvShapeFile
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...

◆ interfaceID()

const InterfaceID & TileInfoLoader::interfaceID ( )
inlinestatic

Definition at line 66 of file TileInfoLoader.h.

66{ return IID_TileInfoLoader; }
static const InterfaceID IID_TileInfoLoader("TileInfoLoader", 1, 0)

◆ msg()

MsgStream & AthCommonMsg< Service >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ operator=()

TileInfoLoader & TileInfoLoader::operator= ( const TileInfoLoader & )
private

◆ SvcFactory< TileInfoLoader >

friend class SvcFactory< TileInfoLoader >
friend

Definition at line 53 of file TileInfoLoader.h.

Member Data Documentation

◆ m_ADCmaskValue

Gaudi::Property<int> TileInfoLoader::m_ADCmaskValue {this, "ADCmaskValue", 2047, "ADC mask value"}
private

Definition at line 126 of file TileInfoLoader.h.

126{this, "ADCmaskValue", 2047, "ADC mask value"};

◆ m_ADCmax

Gaudi::Property<int> TileInfoLoader::m_ADCmax {this, "ADCmax", 1023, "Maximum ADC value"}
private

Definition at line 125 of file TileInfoLoader.h.

125{this, "ADCmax", 1023, "Maximum ADC value"};

◆ m_calibCntName

std::string TileInfoLoader::m_calibCntName
private

Definition at line 182 of file TileInfoLoader.h.

◆ m_connectedDrawers

std::vector<std::string> TileInfoLoader::m_connectedDrawers
private

Definition at line 184 of file TileInfoLoader.h.

◆ m_DecoCovaFilePrefix

Gaudi::Property<std::string> TileInfoLoader::m_DecoCovaFilePrefix {this, "filename_DecoCovaFilePrefix", "DecoCovaMatrix", "Prefix of the files with decomposed covariance matrices for coherent noise simulation"}
private

Definition at line 140 of file TileInfoLoader.h.

140{this, "filename_DecoCovaFilePrefix", "DecoCovaMatrix", "Prefix of the files with decomposed covariance matrices for coherent noise simulation"};

◆ m_detStore

ServiceHandle<StoreGateSvc> TileInfoLoader::m_detStore
private

Definition at line 81 of file TileInfoLoader.h.

◆ m_digitsShapeFileHi

Gaudi::Property<std::string> TileInfoLoader::m_digitsShapeFileHi {this, "DigitsShapeFileHi", "pulsehi_physics.dat", "Filename for high gain pulse shape"}
private

Filenames of input files.

Definition at line 133 of file TileInfoLoader.h.

133{this, "DigitsShapeFileHi", "pulsehi_physics.dat", "Filename for high gain pulse shape"};

◆ m_digitsShapeFileLo

Gaudi::Property<std::string> TileInfoLoader::m_digitsShapeFileLo {this, "DigitsShapeFileLo", "pulselo_physics.dat", "Filename for low gain pulse shape"}
private

Definition at line 134 of file TileInfoLoader.h.

134{this, "DigitsShapeFileLo", "pulselo_physics.dat", "Filename for low gain pulse shape"};

◆ m_filenameDLeakHi

Gaudi::Property<std::string> TileInfoLoader::m_filenameDLeakHi {this, "filename_dleakhi", "dleakhi_100.dat", "Derivative high gain CIS leakage pulse 100pF"}
private

Definition at line 170 of file TileInfoLoader.h.

170{this, "filename_dleakhi", "dleakhi_100.dat", "Derivative high gain CIS leakage pulse 100pF"};

◆ m_filenameDLeakLo

Gaudi::Property<std::string> TileInfoLoader::m_filenameDLeakLo {this, "filename_dleaklo", "dleaklo_100.dat", "Derivative low gain CIS leakage pulse 100pF"}
private

Definition at line 166 of file TileInfoLoader.h.

166{this, "filename_dleaklo", "dleaklo_100.dat", "Derivative low gain CIS leakage pulse 100pF"};

◆ m_filenameDSLeakHi

Gaudi::Property<std::string> TileInfoLoader::m_filenameDSLeakHi {this, "filename_dsleakhi", "dsleakhi.0230055.12.cap.5.2.dat", "Derivative high gain CIS leakage pulse 5pF"}
private

Definition at line 169 of file TileInfoLoader.h.

169{this, "filename_dsleakhi", "dsleakhi.0230055.12.cap.5.2.dat", "Derivative high gain CIS leakage pulse 5pF"};

◆ m_filenameDSLeakLo

Gaudi::Property<std::string> TileInfoLoader::m_filenameDSLeakLo {this, "filename_dsleaklo", "dsleaklo.0230055.12.cap.5.2.dat", "Derivative low gain CIS leakage pulse 5pF"}
private

Definition at line 165 of file TileInfoLoader.h.

165{this, "filename_dsleaklo", "dsleaklo.0230055.12.cap.5.2.dat", "Derivative low gain CIS leakage pulse 5pF"};

◆ m_filenameHiCIS

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiCIS {this, "filename_hi_cis", "pulsehi_cis_100.dat", "High gain CIS pulseshape 100pF"}
private

Definition at line 148 of file TileInfoLoader.h.

148{this, "filename_hi_cis", "pulsehi_cis_100.dat", "High gain CIS pulseshape 100pF"};

◆ m_filenameHiCISDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiCISDer {this, "filename_hi_cis_der", "dpulsehi_cis_100.dat", "High gain CIS pulseshape derivative 100pF"}
private

Definition at line 149 of file TileInfoLoader.h.

149{this, "filename_hi_cis_der", "dpulsehi_cis_100.dat", "High gain CIS pulseshape derivative 100pF"};

◆ m_filenameHiLas

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiLas {this, "filename_hi_las", "pulsehi_laser.dat", "High gain laser pulseshape"}
private

Definition at line 159 of file TileInfoLoader.h.

159{this, "filename_hi_las", "pulsehi_laser.dat", "High gain laser pulseshape"};

◆ m_filenameHiLasDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiLasDer {this, "filename_hi_las_der", "dpulsehi_laser.dat", "High gain laser pulseshape derivative"}
private

Definition at line 161 of file TileInfoLoader.h.

161{this, "filename_hi_las_der", "dpulsehi_laser.dat", "High gain laser pulseshape derivative"};

◆ m_filenameHiPhys

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiPhys {this, "filename_hi_phys", "pulsehi_physics.dat", "High gain physics pulseshape"}
private

Definition at line 154 of file TileInfoLoader.h.

154{this, "filename_hi_phys", "pulsehi_physics.dat", "High gain physics pulseshape"};

◆ m_filenameHiPhysDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameHiPhysDer {this, "filename_hi_phys_der", "dpulsehi_physics.dat", "High gain physics pulseshape derivative"}
private

Definition at line 156 of file TileInfoLoader.h.

156{this, "filename_hi_phys_der", "dpulsehi_physics.dat", "High gain physics pulseshape derivative"};

◆ m_filenameLeakHi

Gaudi::Property<std::string> TileInfoLoader::m_filenameLeakHi {this, "filename_leakhi", "leakhi_100.dat", "High gain CIS leakage pulse 100pF"}
private

Definition at line 168 of file TileInfoLoader.h.

168{this, "filename_leakhi", "leakhi_100.dat", "High gain CIS leakage pulse 100pF"};

◆ m_filenameLeakLo

Gaudi::Property<std::string> TileInfoLoader::m_filenameLeakLo {this, "filename_leaklo", "leaklo_100.dat", "Low gain CIS leakage pulse 100pF"}
private

Definition at line 164 of file TileInfoLoader.h.

164{this, "filename_leaklo", "leaklo_100.dat", "Low gain CIS leakage pulse 100pF"};

◆ m_filenameLoCIS

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoCIS {this, "filename_lo_cis", "pulselo_cis_100.dat", "Low gain CIS pulseshape 100pF"}
private

Reference pulse shape filenames, forwarded to TilePulseShapes in initialize().

Definition at line 144 of file TileInfoLoader.h.

144{this, "filename_lo_cis", "pulselo_cis_100.dat", "Low gain CIS pulseshape 100pF"};

◆ m_filenameLoCISDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoCISDer {this, "filename_lo_cis_der", "dpulselo_cis_100.dat", "Low gain CIS pulseshape derivative 100pF"}
private

Definition at line 145 of file TileInfoLoader.h.

145{this, "filename_lo_cis_der", "dpulselo_cis_100.dat", "Low gain CIS pulseshape derivative 100pF"};

◆ m_filenameLoLas

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoLas {this, "filename_lo_las", "pulselo_laser.dat", "Low gain laser pulseshape"}
private

Definition at line 158 of file TileInfoLoader.h.

158{this, "filename_lo_las", "pulselo_laser.dat", "Low gain laser pulseshape"};

◆ m_filenameLoLasDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoLasDer {this, "filename_lo_las_der", "dpulselo_laser.dat", "Low gain laser pulseshape derivative"}
private

Definition at line 160 of file TileInfoLoader.h.

160{this, "filename_lo_las_der", "dpulselo_laser.dat", "Low gain laser pulseshape derivative"};

◆ m_filenameLoPhys

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoPhys {this, "filename_lo_phys", "pulselo_physics.dat", "Low gain physics pulseshape"}
private

Definition at line 153 of file TileInfoLoader.h.

153{this, "filename_lo_phys", "pulselo_physics.dat", "Low gain physics pulseshape"};

◆ m_filenameLoPhysDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameLoPhysDer {this, "filename_lo_phys_der", "dpulselo_physics.dat", "Low gain physics pulseshape derivative"}
private

Definition at line 155 of file TileInfoLoader.h.

155{this, "filename_lo_phys_der", "dpulselo_physics.dat", "Low gain physics pulseshape derivative"};

◆ m_filenameNkNoise

Gaudi::Property<std::string> TileInfoLoader::m_filenameNkNoise {this, "filename_nk_noise", "noise_digi_nk.dat", "file with noise rms per channel"}
private

Definition at line 173 of file TileInfoLoader.h.

173{this, "filename_nk_noise", "noise_digi_nk.dat", "file with noise rms per channel"};

◆ m_filenameOrigNoise

Gaudi::Property<std::string> TileInfoLoader::m_filenameOrigNoise {this, "filename_orig_noise", "noise_digi_orig.dat", "file with noise rms per channel"}
private

Definition at line 172 of file TileInfoLoader.h.

172{this, "filename_orig_noise", "noise_digi_orig.dat", "file with noise rms per channel"};

◆ m_filenameSHiCIS

Gaudi::Property<std::string> TileInfoLoader::m_filenameSHiCIS {this, "filename_shi_cis", "pulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape 5pF"}
private

Definition at line 150 of file TileInfoLoader.h.

150{this, "filename_shi_cis", "pulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape 5pF"};

◆ m_filenameSHiCISDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameSHiCISDer {this, "filename_shi_cis_der", "dpulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape derivative 5pF"}
private

Definition at line 151 of file TileInfoLoader.h.

151{this, "filename_shi_cis_der", "dpulsehi.0230055.12.cap.5.2.dat", "High gain CIS pulseshape derivative 5pF"};

◆ m_filenameSLeakHi

Gaudi::Property<std::string> TileInfoLoader::m_filenameSLeakHi {this, "filename_sleakhi", "leakhi.0230055.12.cap.5.2.dat", "High gain CIS leakage pulse 5pF"}
private

Definition at line 167 of file TileInfoLoader.h.

167{this, "filename_sleakhi", "leakhi.0230055.12.cap.5.2.dat", "High gain CIS leakage pulse 5pF"};

◆ m_filenameSLeakLo

Gaudi::Property<std::string> TileInfoLoader::m_filenameSLeakLo {this, "filename_sleaklo", "leaklo.0230055.12.cap.5.2.dat", "Low gain CIS leakage pulse 5pF"}
private

Definition at line 163 of file TileInfoLoader.h.

163{this, "filename_sleaklo", "leaklo.0230055.12.cap.5.2.dat", "Low gain CIS leakage pulse 5pF"};

◆ m_filenameSLoCIS

Gaudi::Property<std::string> TileInfoLoader::m_filenameSLoCIS {this, "filename_slo_cis", "pulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape 5pF"}
private

Definition at line 146 of file TileInfoLoader.h.

146{this, "filename_slo_cis", "pulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape 5pF"};

◆ m_filenameSLoCISDer

Gaudi::Property<std::string> TileInfoLoader::m_filenameSLoCISDer {this, "filename_slo_cis_der", "dpulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape derivative pF"}
private

Definition at line 147 of file TileInfoLoader.h.

147{this, "filename_slo_cis_der", "dpulselo.0230055.12.cap.5.2.dat", "Low gain CIS pulseshape derivative pF"};

◆ m_iTrigSample

Gaudi::Property<int> TileInfoLoader::m_iTrigSample {this, "TrigSample", 3, "sample index of t=0 in TileDigits"}
private

Definition at line 89 of file TileInfoLoader.h.

89{this, "TrigSample", 3, "sample index of t=0 in TileDigits"};

◆ m_loadWienerFilterWeights

Gaudi::Property<bool> TileInfoLoader::m_loadWienerFilterWeights {this, "LoadWienerFilterWeights", false, "Load Wiener filter weights"}
private

Definition at line 176 of file TileInfoLoader.h.

176{this, "LoadWienerFilterWeights", false, "Load Wiener filter weights"};

◆ m_mbtsL1Calib

Gaudi::Property<double> TileInfoLoader::m_mbtsL1Calib {this, "MBTSL1Calib", 222.0, "converts pCb to mV for MBTS"}
private

Definition at line 116 of file TileInfoLoader.h.

116{this, "MBTSL1Calib", 222.0, "converts pCb to mV for MBTS"};

◆ m_mbtsL1Max

Gaudi::Property<double> TileInfoLoader::m_mbtsL1Max {this, "MBTSL1Max", 1850.0, "max value for MBTS signals (mV)"}
private

Definition at line 120 of file TileInfoLoader.h.

120{this, "MBTSL1Max", 1850.0, "max value for MBTS signals (mV)"};

◆ m_mbtsL1NoiseSigma

Gaudi::Property<double> TileInfoLoader::m_mbtsL1NoiseSigma {this, "MBTSL1NoiseSigma", 0.6, "sigma of noise in MBTS (mV)"}
private

Definition at line 117 of file TileInfoLoader.h.

117{this, "MBTSL1NoiseSigma", 0.6, "sigma of noise in MBTS (mV)"};

◆ m_mbtsL1Ped

Gaudi::Property<double> TileInfoLoader::m_mbtsL1Ped {this, "MBTSL1Ped", 0.0, "pedestal for MBTS signals (mV)"}
private

Definition at line 119 of file TileInfoLoader.h.

119{this, "MBTSL1Ped", 0.0, "pedestal for MBTS signals (mV)"};

◆ m_mbtsL1Thresh

Gaudi::Property<double> TileInfoLoader::m_mbtsL1Thresh {this, "MBTSL1Thresh", 5.0, "threshold cut for MBTS signals (mV)"}
private

Definition at line 118 of file TileInfoLoader.h.

118{this, "MBTSL1Thresh", 5.0, "threshold cut for MBTS signals (mV)"};

◆ m_muL1Calib

Gaudi::Property<double> TileInfoLoader::m_muL1Calib {this, "MuL1Calib", 204.2, "converts pCb to mV for Mu"}
private

Definition at line 110 of file TileInfoLoader.h.

110{this, "MuL1Calib", 204.2, "converts pCb to mV for Mu"};

◆ m_muL1Max

Gaudi::Property<double> TileInfoLoader::m_muL1Max {this, "MuL1Max", 1850.0, "max value for Mu signals (mV)"}
private

Definition at line 114 of file TileInfoLoader.h.

114{this, "MuL1Max", 1850.0, "max value for Mu signals (mV)"};

◆ m_muL1NoiseSigma

Gaudi::Property<double> TileInfoLoader::m_muL1NoiseSigma {this, "MuL1NoiseSigma", 15.6, "sigma of noise in Mu (mV)"}
private

Definition at line 111 of file TileInfoLoader.h.

111{this, "MuL1NoiseSigma", 15.6, "sigma of noise in Mu (mV)"};

◆ m_muL1Ped

Gaudi::Property<double> TileInfoLoader::m_muL1Ped {this, "MuL1Ped", 0.0, "pedestal for Mu signals (mV)"}
private

Definition at line 113 of file TileInfoLoader.h.

113{this, "MuL1Ped", 0.0, "pedestal for Mu signals (mV)"};

◆ m_MuL1ShapeFile

Gaudi::Property<std::string> TileInfoLoader::m_MuL1ShapeFile {this, "filename_MuL1ShapeFile", "pulse_adder_muon_physics.dat", "Filename for muon level1 trigger pulse shape"}
private

Definition at line 138 of file TileInfoLoader.h.

138{this, "filename_MuL1ShapeFile", "pulse_adder_muon_physics.dat", "Filename for muon level1 trigger pulse shape"};

◆ m_muL1Thresh

Gaudi::Property<double> TileInfoLoader::m_muL1Thresh {this, "MuL1Thresh", 5.0, "threshold cut for Mu signals (mV)"}
private

Definition at line 112 of file TileInfoLoader.h.

112{this, "MuL1Thresh", 5.0, "threshold cut for Mu signals (mV)"};

◆ m_MuRcvCalib

Gaudi::Property<double> TileInfoLoader::m_MuRcvCalib {this, "MuRcvCalib", 14.20, "converts pCb to ADC counts for MuRcv"}
private

Definition at line 104 of file TileInfoLoader.h.

104{this, "MuRcvCalib", 14.20, "converts pCb to ADC counts for MuRcv"};

◆ m_MuRcvMax

Gaudi::Property<double> TileInfoLoader::m_MuRcvMax {this, "MuRcvMax", 255, "max value for MuRcv signals (ADC count)"}
private

Definition at line 108 of file TileInfoLoader.h.

108{this, "MuRcvMax", 255, "max value for MuRcv signals (ADC count)"};

◆ m_MuRcvNoiseSigma

Gaudi::Property<double> TileInfoLoader::m_MuRcvNoiseSigma {this, "MuRcvNoiseSigma", 2, "sigma of noise in MuRcv (ADC counts)"}
private

Definition at line 105 of file TileInfoLoader.h.

105{this, "MuRcvNoiseSigma", 2, "sigma of noise in MuRcv (ADC counts)"};

◆ m_MuRcvPed

Gaudi::Property<double> TileInfoLoader::m_MuRcvPed {this, "MuRcvPed", 11.73, "pedestal for MuRcv signals (ADC count)"}
private

Definition at line 107 of file TileInfoLoader.h.

107{this, "MuRcvPed", 11.73, "pedestal for MuRcv signals (ADC count)"};

◆ m_MuRcvShapeFile

Gaudi::Property<std::string> TileInfoLoader::m_MuRcvShapeFile {this, "filename_MuRcvShapeFile", "pulse_adder_muonRcv_physics.dat", "Filename for Muon Receiver pulse shape"}
private

Definition at line 137 of file TileInfoLoader.h.

137{this, "filename_MuRcvShapeFile", "pulse_adder_muonRcv_physics.dat", "Filename for Muon Receiver pulse shape"}; // using the sames as for TTL1ShapeFile !!! TO UPDATE !!!

◆ m_MuRcvThresh

Gaudi::Property<double> TileInfoLoader::m_MuRcvThresh {this, "MuRcvThresh", 5, "threshold cut for MuRcv signals (ADC count)"}
private

Definition at line 106 of file TileInfoLoader.h.

106{this, "MuRcvThresh", 5, "threshold cut for MuRcv signals (ADC count)"};

◆ m_noiseScaleIndex

Gaudi::Property<int> TileInfoLoader::m_noiseScaleIndex {this, "NoiseScaleIndex", 1, "allowed values 0-3 to choose proper ADC->OF noise scale factor for different OF methods"}
private

Definition at line 94 of file TileInfoLoader.h.

94{this, "NoiseScaleIndex", 1, "allowed values 0-3 to choose proper ADC->OF noise scale factor for different OF methods"};

◆ m_nSamples

Gaudi::Property<int> TileInfoLoader::m_nSamples {this, "NSamples", 7, "Number of 25ns time slices in TileDigits"}
private

Properties to forward to TileInfo.

Definition at line 88 of file TileInfoLoader.h.

88{this, "NSamples", 7, "Number of 25ns time slices in TileDigits"};

◆ m_pulsevar

TilePulseShapes* TileInfoLoader::m_pulsevar
private

Pointer to TilePulseShapes object.

Definition at line 84 of file TileInfoLoader.h.

◆ m_thresholdDigits

Gaudi::Property<double> TileInfoLoader::m_thresholdDigits {this, "ThresholdDigits", -2.0, "threshold for TileDigits [adc] (high gain only, negative -> cut on abs value)"}
private

Definition at line 96 of file TileInfoLoader.h.

96{this, "ThresholdDigits", -2.0, "threshold for TileDigits [adc] (high gain only, negative -> cut on abs value)"};

◆ m_thresholdRawChannel

Gaudi::Property<double> TileInfoLoader::m_thresholdRawChannel {this, "ThresholdRawChannel", -3.0, "threshold for TileRawChannel [adc] (high gain only, negative -> cut on abs value)"}
private

Definition at line 95 of file TileInfoLoader.h.

95{this, "ThresholdRawChannel", -3.0, "threshold for TileRawChannel [adc] (high gain only, negative -> cut on abs value)"};

◆ m_tileCoherNoise

Gaudi::Property<bool> TileInfoLoader::m_tileCoherNoise {this, "TileCoherNoise", false, "true => add coherent noise to TileDigits and TileRawChannels (used in MC generation)"}
private

Definition at line 92 of file TileInfoLoader.h.

92{this, "TileCoherNoise", false, "true => add coherent noise to TileDigits and TileRawChannels (used in MC generation)"};

◆ m_tileInfoName

Gaudi::Property<std::string> TileInfoLoader::m_tileInfoName
private
Initial value:
{this,
"TileInfo", "TileInfo", "Name of TileInfo object in Detector Store"}

Definition at line 77 of file TileInfoLoader.h.

77 {this,
78 "TileInfo", "TileInfo", "Name of TileInfo object in Detector Store"};

◆ m_tileNoise

Gaudi::Property<bool> TileInfoLoader::m_tileNoise {this, "TileNoise", true, "true => add noise to TileDigits and TileRawChannels (used in MC generation)"}
private

Definition at line 91 of file TileInfoLoader.h.

91{this, "TileNoise", true, "true => add noise to TileDigits and TileRawChannels (used in MC generation)"};

◆ m_tileZeroSuppress

Gaudi::Property<bool> TileInfoLoader::m_tileZeroSuppress {this, "TileZeroSuppress", false, "true => applies threshold cuts in HitToRC, HitToDigits, RCToCells"}
private

Definition at line 93 of file TileInfoLoader.h.

93{this, "TileZeroSuppress", false, "true => applies threshold cuts in HitToRC, HitToDigits, RCToCells"};

◆ m_ttL1Calib

Gaudi::Property<double> TileInfoLoader::m_ttL1Calib {this, "TTL1Calib", 4.1, "converts pCb to mV for TTL1"}
private

Definition at line 98 of file TileInfoLoader.h.

98{this, "TTL1Calib", 4.1, "converts pCb to mV for TTL1"};

◆ m_ttL1CosmicsGain

Gaudi::Property<double> TileInfoLoader::m_ttL1CosmicsGain {this, "TTL1CosmicsGain", 5.0, "gain of the Cosmics board"}
private

Definition at line 122 of file TileInfoLoader.h.

122{this, "TTL1CosmicsGain", 5.0, "gain of the Cosmics board"};

◆ m_ttL1CosmicsThresh

Gaudi::Property<double> TileInfoLoader::m_ttL1CosmicsThresh {this, "TTL1CosmicsThresh", 5.0, "threshold in the Cosmics board"}
private

Definition at line 123 of file TileInfoLoader.h.

123{this, "TTL1CosmicsThresh", 5.0, "threshold in the Cosmics board"};

◆ m_ttL1Max

Gaudi::Property<double> TileInfoLoader::m_ttL1Max {this, "TTL1Max", 1850.0, "max value for TTL1 signals (mV)"}
private

Definition at line 102 of file TileInfoLoader.h.

102{this, "TTL1Max", 1850.0, "max value for TTL1 signals (mV)"};

◆ m_ttL1NoiseSigma

Gaudi::Property<double> TileInfoLoader::m_ttL1NoiseSigma {this, "TTL1NoiseSigma", 2.5, "sigma of noise in TTL1 (mV)"}
private

Definition at line 99 of file TileInfoLoader.h.

99{this, "TTL1NoiseSigma", 2.5, "sigma of noise in TTL1 (mV)"};

◆ m_ttL1Ped

Gaudi::Property<double> TileInfoLoader::m_ttL1Ped {this, "TTL1Ped", 0.0, "pedestal for TTL1 signals (mV)"}
private

Definition at line 101 of file TileInfoLoader.h.

101{this, "TTL1Ped", 0.0, "pedestal for TTL1 signals (mV)"};

◆ m_TTL1ShapeFile

Gaudi::Property<std::string> TileInfoLoader::m_TTL1ShapeFile {this, "filename_TTL1ShapeFile", "pulse_adder_tower_physics.dat", "Filename for trigger tower pulse shape"}
private

Definition at line 136 of file TileInfoLoader.h.

136{this, "filename_TTL1ShapeFile", "pulse_adder_tower_physics.dat", "Filename for trigger tower pulse shape"};

◆ m_ttL1Thresh

Gaudi::Property<double> TileInfoLoader::m_ttL1Thresh {this, "TTL1Thresh", 5.0, "threshold cut for TTL1 signals (mV)"}
private

Definition at line 100 of file TileInfoLoader.h.

100{this, "TTL1Thresh", 5.0, "threshold cut for TTL1 signals (mV)"};

◆ m_WFLuminosity

Gaudi::Property<int> TileInfoLoader::m_WFLuminosity {this, "WienerFilterLuminosity", 40, "Luminosity for Wiener filter weights"}
private

Definition at line 179 of file TileInfoLoader.h.

179{this, "WienerFilterLuminosity", 40, "Luminosity for Wiener filter weights"};

◆ m_WFNSamplesPhys

Gaudi::Property<int> TileInfoLoader::m_WFNSamplesPhys {this, "WienerFilterPhysicsNSamples", 7, "Number of samples for Wiener filter physics weights"}
private

Forwarded to TileWienerFilterWeights in initialize().

Definition at line 178 of file TileInfoLoader.h.

178{this, "WienerFilterPhysicsNSamples", 7, "Number of samples for Wiener filter physics weights"};

◆ m_WFWeights

TileWienerFilterWeights* TileInfoLoader::m_WFWeights
private

Pointer to Wiener Filtering weights.

Definition at line 129 of file TileInfoLoader.h.


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