#include <Validation/HGCalValidation/plugins/HGCalWaferValidation.cc>

Inheritance diagram for HGCalWaferValidation:

Classes
struct	WaferInfo

Public Member Functions
	HGCalWaferValidation (const edm::ParameterSet &)

	~HGCalWaferValidation () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
using	WaferCoord = std::tuple< int, int, int >

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

bool	DDFindHGCal (DDCompactView::GraphWalker &walker, std::string targetName)

void	DDFindWafers (DDCompactView::GraphWalker &walker)

void	endJob () override

void	ProcessWaferLayer (DDCompactView::GraphWalker &walker)

std::string	strWaferCoord (const WaferCoord &coord)

Private Attributes
edm::FileInPath	geometryFileName_

const std::string	logcat = "HGCalWaferValidation"

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	viewToken_

std::map< WaferCoord, struct WaferInfo >	waferData

std::map< WaferCoord, bool >	waferValidated

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Validates HGCal wafer data inside DD against specifications given in a flat text file.

Implementation: Uses GraphWalker to follow DD hierarchy to find HGCal EE module and the HE modules. Search of wafer layers and iterates each wafer found. Extract x, y coordinate position from wafer positioning; thickness, u & v coords from copyNo. Wafer shape and rotation are extracted from given names of wafer logical volumes. All extracted wafer info saved into a map indexed by (layer#, u, v). Each line in flat text file are compared against wafer information in the map. Any errors are reported, counted and summarized at the end. Unaccounted wafers, which are in DD but not in the flat text file, are also reported and counted.

Definition at line 62 of file HGCalWaferValidation.cc.

Member Typedef Documentation

using HGCalWaferValidation::WaferCoord = std::tuple<int, int, int>

private

Definition at line 74 of file HGCalWaferValidation.cc.

Constructor & Destructor Documentation

HGCalWaferValidation::HGCalWaferValidation ( const edm::ParameterSet & iConfig )

explicit

Definition at line 120 of file HGCalWaferValidation.cc.

References viewToken_.

     : geometryFileName_(iConfig.getParameter<edm::FileInPath>("GeometryFileName")) {
   viewToken_ = esConsumes<DDCompactView, IdealGeometryRecord>();
   //now do what ever initialization is needed
 }

HGCalWaferValidation::~HGCalWaferValidation ( )

override

Definition at line 126 of file HGCalWaferValidation.cc.

                                             {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
   //
   // please remove this method altogether if it would be left empty
 }

Member Function Documentation

void HGCalWaferValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 247 of file HGCalWaferValidation.cc.

References visDQMUpload::buf, DDFindHGCal(), DDFindWafers(), MillePedeFileConverter_cfg::fileName, edm::FileInPath::fullPath(), geometryFileName_, edm::EventSetup::getHandle(), logcat, HGCalWaferValidation::WaferInfo::rotCode, HGCalWaferValidation::WaferInfo::shapeCode, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, strWaferCoord(), HGCalWaferValidation::WaferInfo::thickClass, viewToken_, waferData, HGCalWaferIndex::waferLayer(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), waferValidated, HGCalWaferValidation::WaferInfo::x, and HGCalWaferValidation::WaferInfo::y.

                                                                                       {
   using namespace edm;
 
   // Get the CMS DD
   auto viewH = iSetup.getHandle(viewToken_);
 
   if (!viewH.isValid()) {
     edm::LogPrint(logcat) << "Error obtaining geometry handle!";
     return;
   }
 
   edm::LogVerbatim(logcat) << "Root is : " << viewH->root();
   edm::LogVerbatim(logcat) << std::endl;
 
   // find HGCalEE
   auto eeWalker = viewH->walker();
   const bool eeFound = DDFindHGCal(eeWalker, "HGCalEE");
   if (eeFound) {
     edm::LogVerbatim(logcat) << "HGCalEE found!";
     edm::LogVerbatim(logcat) << "name     = " << eeWalker.current().first.name().name();
     edm::LogVerbatim(logcat) << "fullname = " << eeWalker.current().first.name().fullname();
   } else {
     edm::LogPrint(logcat) << "HGCalEE not found!";
   }
   edm::LogVerbatim(logcat) << std::endl;
 
   // find HGCalHEsil
   auto hesilWalker = viewH->walker();
   const bool hesilFound = DDFindHGCal(hesilWalker, "HGCalHEsil");
   if (hesilFound) {
     edm::LogVerbatim(logcat) << "HGCalHEsil found!";
     edm::LogVerbatim(logcat) << "name     = " << hesilWalker.current().first.name().name();
     edm::LogVerbatim(logcat) << "fullname = " << hesilWalker.current().first.name().fullname();
   } else {
     edm::LogPrint(logcat) << "HGCalHEsil not found!";
   }
   edm::LogVerbatim(logcat) << std::endl;
 
   // find HGCalHEmix
   auto hemixWalker = viewH->walker();
   const bool hemixFound = DDFindHGCal(hemixWalker, "HGCalHEmix");
   if (hemixFound) {
     edm::LogVerbatim(logcat) << "HGCalHEmix found!";
     edm::LogVerbatim(logcat) << "name     = " << hemixWalker.current().first.name().name();
     edm::LogVerbatim(logcat) << "fullname = " << hemixWalker.current().first.name().fullname();
   } else {
     edm::LogPrint(logcat) << "HGCalHEmix not found!";
   }
   edm::LogVerbatim(logcat) << std::endl;
 
   // give up if no HGCal found at all
   if (!(eeFound || hesilFound || hemixFound)) {
     edm::LogPrint(logcat) << "Nothing found. Giving up.";
     return;
   }
 
   // Now walk the HGCalEE walker to find the first wafer on each layer and process them
   edm::LogVerbatim(logcat) << "Calling DDFindWafers(eeWalker);";
   DDFindWafers(eeWalker);
 
   // Walk the HGCalHEsilwalker to find the first wafer on each layer and process them
   edm::LogVerbatim(logcat) << "Calling DDFindWafers(hesilWalker);";
   DDFindWafers(hesilWalker);
 
   // Walk the HGCalHEmix walker to find the first wafer on each layer and process them
   edm::LogVerbatim(logcat) << "Calling DDFindWafers(hemixWalker);";
   DDFindWafers(hemixWalker);
 
   // Confirm all the DD wafers have been read
   edm::LogVerbatim(logcat) << "Number of wafers read from DD: " << waferData.size();
 
   // Now open the geometry text file
   std::string fileName = geometryFileName_.fullPath();
   edm::LogVerbatim(logcat) << "Opening geometry text file: " << fileName;
   std::ifstream geoTxtFile(fileName);
 
   if (!geoTxtFile) {
     edm::LogPrint(logcat) << "Cannot open geometry text file.";
     return;
   }
 
   // total processed counter
   int nTotalProcessed = 0;
 
   // geometry error counters
   int nMissing = 0;
   int nThicknessError = 0;
   int nPosXError = 0;
   int nPosYError = 0;
   int nShapeError = 0;
   int nRotError = 0;
   int nUnaccounted = 0;
 
   std::string buf;
 
   // process each line on the text file
   while (std::getline(geoTxtFile, buf)) {
     std::stringstream ss(buf);
     std::vector<std::string> tokens;
     while (ss >> buf)
       if (!buf.empty())
         tokens.push_back(buf);
     if (tokens.size() != 8)
       continue;
 
     nTotalProcessed++;
 
     int waferLayer;
     std::string waferShapeStr;
     std::string waferDensityStr;
     int waferThickness;
     double waferX;
     double waferY;
     int waferRotCode;
     int waferU;
     int waferV;
     int waferShapeCode;
     // extract wafer info from a textfile line
     if (tokens[2].substr(0, 1) == "l" || tokens[2].substr(0, 1) == "h") {
       //if using new format flat file
       waferLayer = std::stoi(tokens[0]);
       waferShapeStr = tokens[1];
       waferDensityStr = tokens[2].substr(0, 1);
       waferThickness = std::stoi(tokens[2].substr(1));
       waferX = std::stod(tokens[3]);
       waferY = std::stod(tokens[4]);
       waferRotCode = std::stoi(tokens[5]);
       waferU = std::stoi(tokens[6]);
       waferV = std::stoi(tokens[7]);
       waferShapeCode = HGCalTypes::WaferPartialType::WaferOut;
       if (waferDensityStr == "l") {
         if (waferShapeStr == "0")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferFull;
         else if (waferShapeStr == "1" || waferShapeStr == "2")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferHalf;
         else if (waferShapeStr == "3" || waferShapeStr == "4")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferSemi;
         else if (waferShapeStr == "5")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferFive;
         else if (waferShapeStr == "6")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferThree;
       } else if (waferDensityStr == "h") {
         if (waferShapeStr == "0")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferFull;
         else if (waferShapeStr == "1")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferHalf2;
         else if (waferShapeStr == "2")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferChopTwoM;
         else if (waferShapeStr == "3" || waferShapeStr == "4")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferSemi2;
         else if (waferShapeStr == "5")
           waferShapeCode = HGCalTypes::WaferPartialType::WaferFive2;
       }
     } else {
       //if using old format flat file
       waferLayer = std::stoi(tokens[0]);
       waferShapeStr = tokens[1];
       waferThickness = std::stoi(tokens[2]);
       waferX = std::stod(tokens[3]);
       waferY = std::stod(tokens[4]);
       waferRotCode = (std::stoi(tokens[5]));
       waferU = std::stoi(tokens[6]);
       waferV = std::stoi(tokens[7]);
       waferShapeCode = HGCalTypes::WaferPartialType::WaferOut;
       if (waferShapeStr == "F")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferFull;
       else if (waferShapeStr == "a")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferHalf;
       else if (waferShapeStr == "am")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferHalf2;
       else if (waferShapeStr == "b")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferFive;
       else if (waferShapeStr == "bm")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferFive2;
       else if (waferShapeStr == "c")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferThree;
       else if (waferShapeStr == "d")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferSemi;
       else if (waferShapeStr == "dm")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferSemi2;
       else if (waferShapeStr == "g")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferChopTwo;
       else if (waferShapeStr == "gm")
         waferShapeCode = HGCalTypes::WaferPartialType::WaferChopTwoM;
     }
 
     // map index for crosschecking with DD
     const WaferCoord waferCoord(waferLayer, waferU, waferV);
 
     // now check for (and report) wafer data disagreements
 
     if (waferData.find(waferCoord) == waferData.end()) {
       nMissing++;
       edm::LogVerbatim(logcat) << "MISSING: " << strWaferCoord(waferCoord);
       continue;
     }
 
     const struct WaferInfo waferInfo = waferData[waferCoord];
     waferValidated[waferCoord] = true;
 
     if ((waferInfo.thickClass == 0 && waferThickness != 120) || (waferInfo.thickClass == 1 && waferThickness != 200) ||
         (waferInfo.thickClass == 2 && waferThickness != 300)) {
       nThicknessError++;
       edm::LogVerbatim(logcat) << "THICKNESS ERROR: " << strWaferCoord(waferCoord);
     }
 
     // it seems that wafer x-coords relative to their layer plane are mirrored...
     if (fabs(-waferInfo.x - waferX) > 0.015) {  // assuming this much tolerance
       nPosXError++;
       edm::LogVerbatim(logcat) << "POSITION x ERROR: " << strWaferCoord(waferCoord);
     }
 
     if (fabs(waferInfo.y - waferY) > 0.015) {  // assuming this much tolerance
       nPosYError++;
       edm::LogVerbatim(logcat) << "POSITION y ERROR: " << strWaferCoord(waferCoord);
     }
 
     if (waferInfo.shapeCode != waferShapeCode || waferShapeCode == HGCalTypes::WaferPartialType::WaferOut) {
       nShapeError++;
       edm::LogVerbatim(logcat) << "SHAPE ERROR: " << strWaferCoord(waferCoord);
     }
 
     if ((waferShapeCode != HGCalTypes::WaferPartialType::WaferFull && waferInfo.rotCode != waferRotCode) ||
         (waferShapeCode == HGCalTypes::WaferPartialType::WaferFull && (waferInfo.rotCode % 2 != waferRotCode % 2))) {
       nRotError++;
       edm::LogVerbatim(logcat) << "ROTATION ERROR: " << strWaferCoord(waferCoord) << "  ( " << waferInfo.rotCode
                                << " != " << waferRotCode << " )";
     }
   }
 
   geoTxtFile.close();
 
   // Find unaccounted DD wafers
   for (auto const& accounted : waferValidated) {
     if (!accounted.second) {
       nUnaccounted++;
       edm::LogVerbatim(logcat) << "UNACCOUNTED: " << strWaferCoord(accounted.first);
     }
   }
 
   // Print out error counts
   edm::LogVerbatim(logcat) << std::endl;
   edm::LogVerbatim(logcat) << "*** ERROR COUNTS ***";
   edm::LogVerbatim(logcat) << "Missing         :  " << nMissing;
   edm::LogVerbatim(logcat) << "Thickness error :  " << nThicknessError;
   edm::LogVerbatim(logcat) << "Pos-x error     :  " << nPosXError;
   edm::LogVerbatim(logcat) << "Pos-y error     :  " << nPosYError;
   edm::LogVerbatim(logcat) << "Shape error     :  " << nShapeError;
   edm::LogVerbatim(logcat) << "Rotation error  :  " << nRotError;
   edm::LogVerbatim(logcat) << "Unaccounted     :  " << nUnaccounted;
   edm::LogVerbatim(logcat) << std::endl;
   edm::LogVerbatim(logcat) << "Total wafers processed from geotxtfile = " << nTotalProcessed;
   edm::LogVerbatim(logcat) << std::endl;
 
   // Issue a LogPrint (warning) if there is at least one wafer errors
   if (nMissing > 0 || nThicknessError > 0 || nPosXError > 0 || nPosYError > 0 || nShapeError > 0 || nRotError > 0 ||
       nUnaccounted > 0) {
     edm::LogPrint(logcat) << "There are at least one wafer error.";
   }
 }

void HGCalWaferValidation::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 509 of file HGCalWaferValidation.cc.

                                     {
   // please remove this method if not needed
 }

bool HGCalWaferValidation::DDFindHGCal	(	DDCompactView::GraphWalker &	walker,
		std::string	targetName
	)

private

Definition at line 145 of file HGCalWaferValidation.cc.

References math::GraphWalker< N, E >::current(), math::GraphWalker< N, E >::firstChild(), math::GraphWalker< N, E >::nextSibling(), and math::GraphWalker< N, E >::parent().

Referenced by analyze().

                                                                                              {
   if (walker.current().first.name().name() == targetName) {
     // target found
     return true;
   }
   if (walker.firstChild()) {
     do {
       if (DDFindHGCal(walker, targetName))
         // target inside child
         return true;
     } while (walker.nextSibling());
     walker.parent();
   }
   return false;
 }

void HGCalWaferValidation::DDFindWafers ( DDCompactView::GraphWalker & walker )

private

Definition at line 162 of file HGCalWaferValidation.cc.

References math::GraphWalker< N, E >::current(), math::GraphWalker< N, E >::firstChild(), math::GraphWalker< N, E >::nextSibling(), math::GraphWalker< N, E >::parent(), and ProcessWaferLayer().

Referenced by analyze().

                                                                         {
   if (walker.current().first.name().fullname().rfind("hgcalwafer:", 0) == 0) {
     // first wafer found. Now process the entire layer of wafers.
     ProcessWaferLayer(walker);
     return;
   }
   if (walker.firstChild()) {
     do {
       DDFindWafers(walker);
     } while (walker.nextSibling());
     walker.parent();
   }
 }

void HGCalWaferValidation::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 514 of file HGCalWaferValidation.cc.

                                   {
   // please remove this method if not needed
 }

void HGCalWaferValidation::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 519 of file HGCalWaferValidation.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and submitPVResolutionJobs::desc.

                                                                                       {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.add<edm::FileInPath>("GeometryFileName",
                             edm::FileInPath("Validation/HGCalValidation/data/geomnew_corrected_360.txt"));
   descriptions.add("hgcalWaferValidation", desc);
 }

void HGCalWaferValidation::ProcessWaferLayer ( DDCompactView::GraphWalker & walker )

private

Definition at line 177 of file HGCalWaferValidation.cc.

References math::GraphWalker< N, E >::current(), HGCalTypes::getUnpackedType(), HGCalTypes::getUnpackedU(), HGCalTypes::getUnpackedV(), logcat, math::GraphWalker< N, E >::nextSibling(), HGCalWaferValidation::WaferInfo::rotCode, HGCalWaferValidation::WaferInfo::shapeCode, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, HGCalWaferValidation::WaferInfo::thickClass, waferData, HGCalWaferIndex::waferLayer(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), waferValidated, HGCalWaferValidation::WaferInfo::x, and HGCalWaferValidation::WaferInfo::y.

Referenced by DDFindWafers().

                                                                              {
   static int waferLayer = 0;  // layer numbers in DD are assumed to be sequential from 1
   waferLayer++;
   edm::LogVerbatim(logcat) << "ProcessWaferLayer: Processing layer " << waferLayer;
   do {
     if (walker.current().first.name().fullname().rfind("hgcalwafer:", 0) == 0) {
       auto wafer = walker.current();
       const std::string waferName(walker.current().first.name().fullname());
       const int copyNo = wafer.second->copyno();
       // extract DD layer properties
       const int waferType = HGCalTypes::getUnpackedType(copyNo);
       const int waferU = HGCalTypes::getUnpackedU(copyNo);
       const int waferV = HGCalTypes::getUnpackedV(copyNo);
       const WaferCoord waferCoord(waferLayer, waferU, waferV);  // map index
       // build struct of DD wafer properties
       struct WaferInfo waferInfo;
       waferInfo.thickClass = waferType;
       waferInfo.x = wafer.second->translation().x();
       waferInfo.y = wafer.second->translation().y();
       const std::string waferNameData =
           std::regex_replace(waferName,
                              std::regex("(HGCal[EH]E)(Wafer[01])(Fine|Coarse[12])([a-z]*)([0-9]*)"),
                              "$1 $2-$3 $4 $5",
                              std::regex_constants::format_no_copy);
       std::stringstream ss(waferNameData);
       std::string EEorHE;
       std::string typeStr;
       std::string shapeStr;
       std::string rotStr;
       ss >> EEorHE >> typeStr >> shapeStr >> rotStr;
       // assume rotational symmetry of full-sized wafers
       if (shapeStr.empty())
         shapeStr = "F";
       if (rotStr.empty())
         rotStr = "0";
       const int rotCode(std::stoi(rotStr));
       //edm::LogVerbatim(logcat) << "rotStr " << rotStr << " rotCode " << rotCode;
 
       // convert shape code to wafer types defined in HGCalTypes.h
       waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferOut;
       if (shapeStr == "F")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferFull;
       else if (shapeStr == "a")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferHalf;
       else if (shapeStr == "am")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferHalf2;
       else if (shapeStr == "b")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferFive;
       else if (shapeStr == "bm")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferFive2;
       else if (shapeStr == "c")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferThree;
       else if (shapeStr == "d")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferSemi;
       else if (shapeStr == "dm")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferSemi2;
       else if (shapeStr == "g")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferChopTwo;
       else if (shapeStr == "gm")
         waferInfo.shapeCode = HGCalTypes::WaferPartialType::WaferChopTwoM;
 
       waferInfo.rotCode = rotCode;
       // populate the map
       waferData[waferCoord] = waferInfo;
       waferValidated[waferCoord] = false;
     }
   } while (walker.nextSibling());
 }

std::string HGCalWaferValidation::strWaferCoord ( const WaferCoord & coord )

private

Definition at line 138 of file HGCalWaferValidation.cc.

References contentValuesCheck::ss.

Referenced by analyze().

                                                                      {
   std::stringstream ss;
   ss << "(" << std::get<0>(coord) << "," << std::get<1>(coord) << "," << std::get<2>(coord) << ")";
   return ss.str();
 }