ATLAS Offline Software
Loading...
Searching...
No Matches
RingerPreProcessorWrapper.icc
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4
5// $Id: RingerPreProcessorWrapper.icc 791627 2017-01-10 04:45:53Z wsfreund $
6#ifndef RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_ICC
7#define RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_ICC
8
9#include "RingerPreProcessorWrapper.h"
10#include "RingerProcedureWrapper.icc"
11#include "Normalizations.h"
12#include "RingerSelectorTools/RingerSelectorToolsDefs.h"
13
14#include <type_traits>
15
16//#undef NDEBUG
17
18namespace Ringer {
19
20namespace WrapperHelperFcns {
21
22/**
23 * Return the pre-processing on dirObj of ppType
24 **/
25inline
26PreProcessing::IPreProcessorVarDep* getPP(preProcEnum_t ppType,
27 TDirectory *dirObj )
28{
29 using namespace PreProcessing;
30 // For the interface case, we will have to create each pre-processing
31 // depending on the information written on ppType:
32 switch ( ppType )
33 {
34 case preProcEnum_t::Norm1:
35 {
36 return Norm::Norm1VarDep::read( dirObj );
37 break;
38 }
39 case preProcEnum_t::Norm2:
40 {
41 return Norm::Norm2VarDep::read( dirObj );
42 break;
43 }
44 case preProcEnum_t::Sqrt:
45 {
46 return Norm::SqrtVarDep::read( dirObj );
47 break;
48 }
49 case preProcEnum_t::ConstantValue:
50 {
51 return Norm::ConstantValueVarDep::read( dirObj );
52 break;
53 }
54 case preProcEnum_t::Sequential:
55 {
56 return Norm::SequentialVarDep::read( dirObj );
57 break;
58 }
59 case preProcEnum_t::Spherization:
60 {
61 return Norm::SpherizationVarDep::read( dirObj );
62 break;
63 }
64 case preProcEnum_t::MinMax:
65 {
66 return Norm::MinMaxVarDep::read( dirObj );
67 break;
68 }
69 default:
70 {
71 throw std::runtime_error( std::string("Cannot read preprocessor of ") +
72 "type: " + toStr(ppType) );
73 }
74 }
75}
76} // private namespace
77
78
79// Import Wrapper Helper functions
80using namespace WrapperHelperFcns;
81
82// =============================================================================
83// ----------------------------------------
84// RingerProcedureWrapper for PreProcessors
85// ----------------------------------------
86// =============================================================================
87
88// =============================================================================
89template <
90 class procedure_t,
91 /*EtaDependency*/int etaDependency,
92 /*EtDependency*/int etDependency,
93 /*SegmentationType*/int segType
94>
95void RingerProcedureWrapper<
96 procedure_t,
97 etaDependency,
98 etDependency,
99 segType,
100 true, // isPreProcessor
101 false, // isDiscriminator
102 false> // isThreshold
103::releaseMemory()
104{
105 for ( size_t segIdx = 0; segIdx < m_ppCol.size() ; ++segIdx){
106 for ( size_t etIdx = 0; etIdx < m_ppCol[segIdx].size() ; ++etIdx){
107 for ( size_t etaIdx = 0; etaIdx < m_ppCol[segIdx][etIdx].size();
108 ++etaIdx)
109 {
110 delete m_ppCol[segIdx][etIdx][etaIdx];
111 }
112 }
113 }
114 m_ppCol.clear();
115 m_pp = nullptr;
116}
117
118// =============================================================================
119template <
120 class procedure_t,
121 /*EtaDependency*/int etaDependency,
122 /*EtDependency*/int etDependency,
123 /*SegmentationType*/int segType
124>
125void RingerProcedureWrapper<
126 procedure_t,
127 etaDependency,
128 etDependency,
129 segType,
130 true,
131 false,
132 false >
133::applyPreProcessing(
134 const DepVarStruct &depVar,
135 std::vector<float> &transformVec) const
136{
137#ifndef NDEBUG
138 ATH_MSG_DEBUG("Applying internal layer pre-processing.");
139#endif
140
141 // This method only applies for segType NoSegmentation.
142 ensureNoSegmentationOnlyFcn(static_cast<SegmentationType>(segType));
143
144 // If not dependent, simply run for the first position in the vector:
145 if ( !etaDependency && !etDependency ){
146 m_pp->execute(transformVec);
147 return;
148 }
149
150 // Initialize eta and et indexes:
151 size_t etaIdx(0), etIdx(0);
152 // Get the correct pp to be applied:
153 if (etaDependency == EtaDependency::EtaDependent){
154 etaIdx = findEtaBin(depVar.eta, m_ppCol[0]);
155 }
156
157 if (etDependency == EtDependency::EtDependent){
158 etIdx = findEtBin(depVar.et, m_ppCol[0]);
159 }
160
161#ifndef NDEBUG
162 ATH_MSG_VERBOSE("Applying pre-processing at etaIdx ("
163 << etaIdx << ") and etIdx (" << etIdx << ").");
164#endif
165
166 // Apply it:
167 m_ppCol[0][etIdx][etaIdx]->execute(transformVec);
168}
169
170// =============================================================================
171template <
172 class procedure_t,
173 /*EtaDependency*/int etaDependency,
174 /*EtDependency*/int etDependency,
175 /*SegmentationType*/int segType
176>
177void RingerProcedureWrapper<
178 procedure_t,
179 etaDependency,
180 etDependency,
181 segType,
182 true,
183 false,
184 false >
185::applyPreProcessing(
186 const DepVarStruct &depVar,
187 const xAOD::CaloRings *clrings,
188 const TrackPatternsHolder *trackPat,
189 std::vector<float> &transformVec) const
190{
191
192#ifndef NDEBUG
193 ATH_MSG_DEBUG("Applying first discrimination layer pre-processing.");
194#endif
195
196 // Erase any previous information
197 transformVec.clear();
198
199 // Initialize eta and et indexes:
200 size_t etaIdx(0), etIdx(0);
201 // Get the correct idx to be applied:
202 if ( etaDependency == EtaDependency::EtaDependent ) {
203 etaIdx = findEtaBin(depVar.eta, m_ppCol[0]);
204 }
205 if ( etDependency == EtDependency::EtDependent ) {
206 etIdx = findEtBin(depVar.et, m_ppCol[0]);
207 }
208 size_t cPreProc = 0;
209
210 switch(segType){
211 case SegmentationType::NoSegmentation:
212 {
213#ifndef NDEBUG
214 ATH_MSG_VERBOSE("Applying NonSegmented pre-processing at etaIdx ("
215 << etaIdx << ") and etIdx (" << etIdx << ").");
216#endif
217 if (clrings){
218 clrings->exportRingsTo(transformVec);
219 }
220 if (trackPat){
221 trackPat->exportPatternsTo(transformVec);
222 }
223 // Apply pre-processing to all transformVec:
224 m_ppCol[cPreProc++][etIdx][etaIdx]->execute(transformVec);
225 break;
226 }
227 case SegmentationType::TrackCalSegmentation:
228 {
229#ifndef NDEBUG
230 ATH_MSG_VERBOSE("Applying Track/Cal segmented pre-processing "
231 " at etaIdx (" << etaIdx << ") and etIdx ("
232 << etIdx << ").");
233#endif
234 if (clrings){
235 // Apply pre-processing to CaloRings as one:
236 clrings->exportRingsTo(transformVec);
237 executeSegmentedPP(
238 transformVec,
239 m_ppCol[cPreProc++][etIdx][etaIdx],
240 transformVec);
241 } else {
242 cPreProc += 1;
243 }
244 if (trackPat){
245 transformVec.clear();
246 // Apply pre-processing to track patterns separated:
247 trackPat->exportPatternsTo(transformVec);
248 executeSegmentedPP(
249 transformVec,
250 m_ppCol[cPreProc++][etIdx][etaIdx],
251 transformVec);
252 } else {
253 cPreProc += 1;
254 }
255 break;
256 }
257 case SegmentationType::TrackCalPatTypeSegmentation:
258 {
259 // TODO Implement this if it is going to be used:
260 throw std::runtime_error(std::string("There is no implementation method "
261 "for ") + toStr(static_cast<SegmentationType>(segType)) );
262 }
263 case SegmentationType::TrackCalJointSections:
264 {
265#ifndef NDEBUG
266 ATH_MSG_VERBOSE("Applying Track/Cal-JointSections segmented"
267 " pre-processing at etaIdx (" << etaIdx << ") and etIdx ("
268 << etIdx << ").");
269#endif
270 if (clrings){
271 // Apply pre-processing to each CalJointSection:
272 while ( cPreProc < static_cast<size_t>(
273 CalJointSection::NJointSections) )
274 {
275 transformVec.clear();
276 clrings->exportRingsTo( transformVec,
277 *m_rsRawConfCol,
278 static_cast<CalJointSection>(cPreProc));
279
280 executeSegmentedPP(
281 transformVec,
282 m_ppCol[cPreProc++][etIdx][etaIdx],
283 transformVec);
284 }
285 } else {
286 cPreProc += static_cast<size_t>(CalJointSection::NJointSections);
287 }
288 if (trackPat){
289 transformVec.clear();
290 // Apply pre-processing to track patterns separated:
291 trackPat->exportPatternsTo(transformVec);
292 executeSegmentedPP(
293 transformVec,
294 m_ppCol[cPreProc++][etIdx][etaIdx],
295 transformVec);
296 } else {
297 cPreProc += 1;
298 }
299 break;
300 }
301 case SegmentationType::TrackCalJointLayers:
302 {
303#ifndef NDEBUG
304 ATH_MSG_VERBOSE("Applying Track/Cal-JointLayers segmented"
305 " pre-processing at etaIdx (" << etaIdx << ") and etIdx ("
306 << etIdx << ").");
307#endif
308 if (clrings){
309 // Apply pre-processing to each CalJointLayer:
310 while ( cPreProc < static_cast<size_t>(
311 CalJointLayer::NJointLayers) )
312 {
313 transformVec.clear();
314 clrings->exportRingsTo(
315 transformVec,
316 *m_rsRawConfCol,
317 static_cast<CalJointLayer>(cPreProc));
318
319 executeSegmentedPP(
320 transformVec,
321 m_ppCol[cPreProc++][etIdx][etaIdx],
322 transformVec);
323 }
324 } else {
325 cPreProc += static_cast<size_t>(CalJointLayer::NJointLayers);
326 }
327 if (trackPat){
328 transformVec.clear();
329 // Apply pre-processing to track Patterns separated:
330 trackPat->exportPatternsTo(transformVec);
331 executeSegmentedPP(
332 transformVec,
333 m_ppCol[cPreProc++][etIdx][etaIdx],
334 transformVec);
335 } else {
336 cPreProc += 1;
337 }
338 break;
339 }
340 default:
341 {
342 throw std::runtime_error(std::string("There is no implementation method "
343 "for ") + toStr(static_cast<SegmentationType>(segType)) );
344 }
345 }
346 return;
347}
348
349// =============================================================================
350template <
351 class procedure_t,
352 /*EtaDependency*/int etaDependency,
353 /*EtDependency*/int etDependency,
354 /*SegmentationType*/int segType
355>
356void RingerProcedureWrapper<
357 procedure_t,
358 etaDependency,
359 etDependency,
360 segType,
361 true, // isPreProcessor
362 false, // isDiscriminator
363 false> // isThreshold
364::checkPPCol(){
365 try {
366 checkCollection(m_ppCol,
367 static_cast<EtaDependency>(etaDependency),
368 static_cast<EtDependency>(etDependency));
369 if ( m_ppCol.size() != numberOfSegments(static_cast<SegmentationType>(segType))){
370 throw std::runtime_error(std::string("Cannot allocate segment ") +
371 "dependent vector of type " + toStr(static_cast<SegmentationType>(segType)) + " with size "
372 "different from " + std::to_string(numberOfSegments(static_cast<SegmentationType>(segType))) +
373 ". Current size is " + std::to_string(m_ppCol.size()) + ".");
374 }
375 } catch ( const std::runtime_error &e ) {
376 throw std::runtime_error(std::string("Couldn't initialize RingerPreProcessorWrapper due to: ")
377 + e.what() );
378 }
379}
380
381// =============================================================================
382template <
383 class procedure_t,
384 /*EtaDependency*/int etaDependency,
385 /*EtDependency*/int etDependency,
386 /*SegmentationType*/int segType
387>
388void RingerProcedureWrapper<
389 procedure_t,
390 etaDependency,
391 etDependency,
392 segType,
393 true, // isPreProcessing
394 false, // isDiscriminator
395 false> // isThreshold
396::setMsgStream(MsgStream *msg) const {
397 // Propagate this stream into collection:
398 setCollectionMsgStream(msg,m_ppCol);
399 // Set stream to self
400 this->RedirectMsgStream::setMsgStream(msg);
401}
402
403// =============================================================================
404template <
405 class procedure_t,
406 /*EtaDependency*/int etaDependency,
407 /*EtDependency*/int etDependency,
408 /*SegmentationType*/int segType
409>
410std::string RingerProcedureWrapper<
411 procedure_t,
412 etaDependency,
413 etDependency,
414 segType,
415 true, // isPreProcessor
416 false, // isDiscriminator
417 false> // isThreshold
418::staticFullName() {
419 typedef typename RingerProcedureType<procedure_t>::procEnum_t procEnum_t;
420 std::stringstream ss;
421 ss << "RingerProcedureWrapper<"
422 << toStr(procedure_t::template procType<procEnum_t>() )
423 << ((std::is_same<procedure_t,
424 PreProcessing::IPreProcessorVarDep>::value)?",":"(VarDep),")
425 << toStr(static_cast<EtaDependency>(etaDependency)) << ","
426 << toStr(static_cast<EtDependency>(etDependency)) << ","
427 << toStr(static_cast<SegmentationType>(segType)) << ">";
428 return ss.str();
429}
430
431// =============================================================================
432template <
433 class procedure_t,
434 /*EtaDependency*/int etaDependency,
435 /*EtDependency*/int etDependency,
436 /*SegmentationType*/int segType
437>
438std::string RingerProcedureWrapper<
439 procedure_t,
440 etaDependency,
441 etDependency,
442 segType,
443 true, // isPreProcessor
444 false, // isDiscriminator
445 false> // isThreshold
446::fullName() const {
447 return staticFullName();
448}
449
450// =============================================================================
451template <
452 class procedure_t,
453 /*EtaDependency*/int etaDependency,
454 /*EtDependency*/int etDependency,
455 /*SegmentationType*/int segType
456>
457void RingerProcedureWrapper<
458 procedure_t,
459 etaDependency,
460 etDependency,
461 segType,
462 true, // isPreProcessor
463 false, // isDiscriminator
464 false> // isThreshold
465::print(MSG::Level lvl) const
466{
467 if ( this->isStreamAvailable() ) {
468 if ( this->level() > lvl ){
469 // Don't waste time print nothing.
470 return;
471 }
472 std::vector<unsigned> posVec(3);
473 this->msg() << lvl << fullName() << " contents: "<< endmsg;
474 for ( size_t segIdx = 0; segIdx < m_ppCol.size() ; ++segIdx){
475 posVec[0] = segIdx;
476 for ( size_t etIdx = 0; etIdx < m_ppCol[segIdx].size() ; ++etIdx){
477 posVec[1] = etIdx;
478 for ( size_t etaIdx = 0; etaIdx < m_ppCol[segIdx][etIdx].size();
479 ++etaIdx)
480 {
481 posVec[2] = etaIdx;
482 this->msg() << lvl << m_ppCol[segIdx][etIdx][etaIdx]->name() <<
483 IOHelperFcns::makeIdxStr(posVec) << " configuration:" << endmsg;
484 m_ppCol[segIdx][etIdx][etaIdx]->print(lvl);
485 }
486 }
487 }
488 } else {
489 std::cerr << "Stream is not available, cannot print " <<
490 fullName() << "." << std::endl;
491 }
492}
493
494// =============================================================================
495template <
496 class procedure_t,
497 /*EtaDependency*/int etaDependency,
498 /*EtDependency*/int etDependency,
499 /*SegmentationType*/int segType
500>
501void RingerProcedureWrapper<
502 procedure_t,
503 etaDependency,
504 etDependency,
505 segType,
506 true, // isPreProcessor
507 false, // isDiscriminator
508 false> // isThreshold
509::write(TDirectory *baseDir, const char *idxStr) const
510{
511 // ----------- Template basics ----------
512 // Create configuration directory
513 TDirectory *configDir = IOHelperFcns::makeDir(baseDir,
514 (std::string(this->name()) + idxStr).c_str() );
515
516 // Write basic template information:
517 preProcEnum_t ppType = procedure_t::template procType<preProcEnum_t>();
518 SegmentationType fileSegType = static_cast<SegmentationType>(segType);
519 EtaDependency fileEtaDep = static_cast<EtaDependency>(etaDependency);
520 EtDependency fileEtDep = static_cast<EtDependency>(etDependency);
521 // FIXME Why do I need to use const? Unfortunately if I don't use so, the
522 // compiler won't accept static_casting from discr_Enum_t to unsigned int:
523 // some issue with reference casting.
524 IOHelperFcns::writeVar<const preProcEnum_t, const unsigned int>( configDir,
525 "ppType",
526 ppType);
527 IOHelperFcns::writeVar<const SegmentationType, const unsigned int>( configDir,
528 "segType",
529 fileSegType);
530 IOHelperFcns::writeVar<const EtaDependency, const unsigned int>( configDir,
531 "etaDependency",
532 fileEtaDep);
533 IOHelperFcns::writeVar<const EtDependency, const unsigned int>( configDir,
534 "etDependency",
535 fileEtDep);
536
537 // Write size information:
538 unsigned ppSegDepSize = m_ppCol.size();
539 unsigned ppEtDepSize = m_ppCol[0].size();
540 unsigned ppEtaDepSize = m_ppCol[0][0].size();
541 IOHelperFcns::writeVar( configDir, "ppSegDepSize" , ppSegDepSize );
542 IOHelperFcns::writeVar( configDir, "ppEtDepSize" , ppEtDepSize );
543 IOHelperFcns::writeVar( configDir, "ppEtaDepSize" , ppEtaDepSize );
544
545 // Write PreProcessors Collection
546 std::vector<unsigned int> ppCount(3);
547 for (size_t segIdx = 0;
548 segIdx < m_ppCol.size();
549 ++segIdx)
550 {
551 ppCount[0] = segIdx;
552 for (size_t etIdx = 0;
553 etIdx < m_ppCol[segIdx].size();
554 ++etIdx)
555 {
556 ppCount[1] = etIdx;
557 for (size_t etaIdx = 0;
558 etaIdx < m_ppCol[segIdx][etIdx].size();
559 ++etaIdx)
560 {
561 ppCount[2] = etaIdx;
562 m_ppCol[segIdx][etIdx][etaIdx]->write(
563 configDir,
564 IOHelperFcns::makeIdxStr(ppCount).c_str());
565 }
566 }
567 }
568}
569
570
571// =============================================================================
572template <
573 class procedure_t,
574 /*EtaDependency*/int etaDependency,
575 /*EtDependency*/int etDependency,
576 /*SegmentationType*/int segType
577>
578RingerProcedureWrapper<procedure_t,
579 etaDependency,
580 etDependency,
581 segType,
582 true,
583 false,
584 false> *
585RingerProcedureWrapper<
586 procedure_t,
587 etaDependency,
588 etDependency,
589 segType,
590 true, // isPreProcessor
591 false, // isDiscriminator
592 false> // isThreshold
593::read(TDirectory *configDir, unsigned /*version*/)
594{
595 using namespace PreProcessing;
596
597 IOHelperFcns::checkDir(configDir);
598
599 // ----------- PreProcesings: ----------
600 // Read pre-processing collection size:
601 unsigned ppSegDepSize(0),
602 ppEtDepSize(0),
603 ppEtaDepSize(0);
604 IOHelperFcns::readVar( configDir, "ppSegDepSize", ppSegDepSize );
605 IOHelperFcns::readVar( configDir, "ppEtDepSize" , ppEtDepSize );
606 IOHelperFcns::readVar( configDir, "ppEtaDepSize", ppEtaDepSize );
607
608 // Allocate pre-processing collection with size specified on file
609 PPDepProcCollection ppCol( ppSegDepSize,
610 std::vector< std::vector< procedure_t*> >(
611 ppEtDepSize, std::vector< procedure_t*>(
612 ppEtaDepSize, nullptr )));
613
614 // Allocate index position retriever:
615 std::vector<unsigned int> ppIdxVec(3);
616
617 // Retrieve dir list and loop on it:
618 std::shared_ptr<THashList> list(nullptr);
619 if ( !( list = IOHelperFcns::getDirList(configDir) ) ) {
620 std::runtime_error(std::string("Couldn't retrieve directory "
621 "list from wrapper folder"));
622 }
623
624 TIter iter( list.get() );
625 while ( TDirectory* dirObj = static_cast<TDirectory*>(iter()) ) {
626
627 const char* folderName = dirObj->GetName();
628
629 //ATH_MSG_VERBOSE("Scanning directory " << folderName );
630
631 // Get information about the pre-processing on the folder:
632 preProcEnum_t ppType;
633 EtaDependency fileEtaDep;
634 EtDependency fileEtDep;
635 try {
636 IOHelperFcns::readVar<preProcEnum_t, unsigned int>(dirObj,
637 "procType",
638 ppType);
639 IOHelperFcns::readVar<EtaDependency, unsigned int>(dirObj,
640 "etaDependency",
641 fileEtaDep);
642 IOHelperFcns::readVar<EtDependency, unsigned int>(dirObj,
643 "etDependency",
644 fileEtDep);
645 } catch (const std::runtime_error &e){
646 throw std::runtime_error(std::string("Couldn't get pre-processing type "
647 "while") + "reading folder: " + folderName + ". Reason: "
648 + e.what() );
649 }
650 // Check if holden information dependency information is ok:
651 if ( fileEtaDep != etaDependency ){
652 throw std::runtime_error(std::string("Folder \"") + folderName + "\" is "
653 + toStr(fileEtaDep) + " whereas Wrapper is " + toStr(static_cast<EtaDependency>(etaDependency)) + ".");
654 }
655 if ( fileEtDep != etDependency ){
656 throw std::runtime_error(std::string("Folder \"") + folderName + "\" is "
657 + toStr(fileEtDep) + " whereas Wrapper is " + toStr(static_cast<EtDependency>(etDependency)) + ".");
658 }
659 // Retrieve position indexes where we shall retrieve this pre-processing
660 IOHelperFcns::getIdxVecFromStr( folderName, ppIdxVec );
661
662 // Check if everything is ok on indexes retrieved:
663 if ( ppIdxVec.size() < 3 ||
664 ppIdxVec[0] >= ppSegDepSize ||
665 ppIdxVec[1] >= ppEtDepSize ||
666 ppIdxVec[2] >= ppEtaDepSize )
667 {
668 throw std::runtime_error(std::string("There is something wrong with ")
669 + "folder idxStr: " + folderName + ". Got idxStr " +
670 IOHelperFcns::makeIdxStr(ppIdxVec) + ". Maximum pre-processing "
671 "collection size is : " + std::to_string(ppSegDepSize) + "," +
672 std::to_string(ppEtDepSize) + "," + std::to_string(ppEtaDepSize));
673 }
674
675 // Get a reference to the pointer (only used to reduce typing):
676 procedure_t *&thisPP = ppCol[ppIdxVec[0]]
677 [ppIdxVec[1]]
678 [ppIdxVec[2]];
679
680 // Check which procedure_t this pre-processing wrapper holds.
681 if ( std::is_same<procedure_t, IPreProcessorVarDep >::value )
682 {
683 // If the procedure_t is not the PreProcessor interface, code will
684 // never get here. We only use the interpret cast so that the compiler
685 // doesn't complain about type casting.
686 thisPP = dynamic_cast<procedure_t*>( getPP(ppType, dirObj) );
687 } else {
688 // Here it's easier, we already know the type that is written in the file,
689 // so all we need to do is loop over it and retrieve the discriminator.
690 preProcEnum_t wrapperPPType = procedure_t::template procType<preProcEnum_t>();
691 if ( ppType != wrapperPPType ){
692 throw std::runtime_error( std::string("There is a pre-processing of type ") +
693 toStr(ppType) + " whereas this wrapper can only hold pre-processings "
694 "of type " + toStr(wrapperPPType));
695 }
696 thisPP = procedure_t::read( dirObj );
697 }
698 // ATH_MSG_VERBOSE("Successfully read directory " << folderName);
699 }
700
701 // Create and return PreProcessors wrapper:
702 return new RingerProcedureWrapper(ppCol);
703
704}
705
706
707} // Namespace Ringer
708
709#endif // RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_ICC
Generated on for ATLAS Offline Software by doxygen 1.14.0