#include <CACut.h>

Classes
struct	CAValueByLayerIds

struct	CAValueByTripletName

struct	CAValuesByInnerLayerIds

Public Member Functions
	CACut (const double defaultCut, const std::vector< edm::ParameterSet > &tripletCuts)

CAValuesByInnerLayerIds	getCutsByInnerLayer (int layerIds1, int layerIds2) const

void	setCutValuesByInnerLayerIds ()

void	setCutValuesByLayerIds (CAGraph &caLayers)

void	setCutValuesByTripletNames (const std::vector< edm::ParameterSet > &tripletCuts)

Private Attributes
const float	defaultCut_

bool	foundAllLayerIds_

bool	useCACuts_

std::vector< CAValuesByInnerLayerIds >	valuesByInnerLayerIds_

std::vector< CAValueByLayerIds >	valuesByLayerIds_

std::vector< CAValueByTripletName >	valuesByTripletNames_

Detailed Description

Definition at line 16 of file CACut.h.

Constructor & Destructor Documentation

◆ CACut()

CACut::CACut	(	const double	defaultCut,
		const std::vector< edm::ParameterSet > &	tripletCuts
	)

inlineexplicit

Definition at line 18 of file CACut.h.

       : useCACuts_(true), foundAllLayerIds_(false), defaultCut_(defaultCut) {
     if (tripletCuts.size() == 1 && tripletCuts[0].getParameter<double>("cut") == -1.) {
       useCACuts_ = false;
       LogDebug("Configuration") << "No CACut VPSet. Using default cut value of " << defaultCut
                                 << " for all layer triplets";
       return;
     }
  
     valuesByTripletNames_.reserve(tripletCuts.size());
     valuesByLayerIds_.reserve(tripletCuts.size());
  
     setCutValuesByTripletNames(tripletCuts);
   }

References LogDebug, setCutValuesByTripletNames(), useCACuts_, valuesByLayerIds_, and valuesByTripletNames_.

Member Function Documentation

◆ getCutsByInnerLayer()

CAValuesByInnerLayerIds CACut::getCutsByInnerLayer	(	int	layerIds1,
		int	layerIds2
	)		const

inline

Definition at line 139 of file CACut.h.

                                                                                   {
     for (const auto &thisCut : valuesByInnerLayerIds_) {
       if (thisCut.outerDoubletIds_[0] == layerIds1 && thisCut.outerDoubletIds_[1] == layerIds2) {
         return thisCut;
       }
     }
  
     CAValuesByInnerLayerIds emptyCutsByInnerLayer(defaultCut_);
     return emptyCutsByInnerLayer;
   }

References defaultCut_, and valuesByInnerLayerIds_.

Referenced by CellularAutomaton::createAndConnectCells(), and CellularAutomaton::findTriplets().

◆ setCutValuesByInnerLayerIds()

void CACut::setCutValuesByInnerLayerIds ( )

inline

Definition at line 85 of file CACut.h.

                                      {
     for (auto &thisTriplet : valuesByLayerIds_) {
       if (thisTriplet.hasValueByInnerLayerId_)
         continue;
       auto it = std::find(thisTriplet.layerIds_.begin(), thisTriplet.layerIds_.end(), -1);
       if (it != thisTriplet.layerIds_.end())
         continue;
  
       bool foundOuterDoublet = false;
  
       for (auto &thisOuterDoublet : valuesByInnerLayerIds_) {
         if (thisOuterDoublet.outerDoubletIds_[0] == thisTriplet.layerIds_[1] &&
             thisOuterDoublet.outerDoubletIds_[1] == thisTriplet.layerIds_[2]) {
           thisOuterDoublet.innerLayerIds_.emplace_back(thisTriplet.layerIds_[0]);
           thisOuterDoublet.cutValues_.emplace_back(thisTriplet.cutValue_);
           foundOuterDoublet = true;
           break;
         }
       }
  
       if (!foundOuterDoublet) {
         valuesByInnerLayerIds_.emplace_back(defaultCut_);
         auto &newOuterDoublet = valuesByInnerLayerIds_.back();
  
         newOuterDoublet.outerDoubletIds_.emplace_back(thisTriplet.layerIds_[1]);
         newOuterDoublet.outerDoubletIds_.emplace_back(thisTriplet.layerIds_[2]);
         newOuterDoublet.innerLayerIds_.emplace_back(thisTriplet.layerIds_[0]);
         newOuterDoublet.cutValues_.emplace_back(thisTriplet.cutValue_);
       }
  
       thisTriplet.hasValueByInnerLayerId_ = true;
     }
   }

References defaultCut_, spr::find(), valuesByInnerLayerIds_, and valuesByLayerIds_.

Referenced by setCutValuesByLayerIds().

◆ setCutValuesByLayerIds()

void CACut::setCutValuesByLayerIds ( CAGraph & caLayers )

inline

Definition at line 43 of file CACut.h.

                                                  {
     if (!useCACuts_ || foundAllLayerIds_)
       return;
  
     foundAllLayerIds_ = true;
     valuesByLayerIds_.clear();
  
     for (const auto &thisTriplet : valuesByTripletNames_) {
       valuesByLayerIds_.emplace_back();
       auto &thisCACut = valuesByLayerIds_.back();
  
       // Triplet name, e.g. 'BPix1+BPix2+BPix3'
       std::string layersToSet = thisTriplet.tripletName_;
       for (int thisLayer = 0; thisLayer < 3; thisLayer++) {
         // Get layer name
         std::size_t layerPos = layersToSet.find("+");
         if ((thisLayer < 2 && layerPos == std::string::npos) || (thisLayer == 2 && layerPos != std::string::npos)) {
           throw cms::Exception("Configuration")
               << "Please enter a valid triplet name in the CACuts parameter set; e.g. 'BPix1+BPix2+BPix3'";
         }
  
         std::string layerName = layersToSet.substr(0, layerPos);
         layersToSet = layersToSet.substr(layerPos + 1);
  
         // Get layer ID
         thisCACut.layerIds_.emplace_back(caLayers.getLayerId(layerName));
         if (thisCACut.layerIds_.back() == -1) {
           foundAllLayerIds_ = false;
           edm::LogWarning("Configuration") << "Layer name '" << layerName
                                            << "' not found in the CAGraph. Please check CACuts parameter set if this "
                                               "warning is present for all events";
         }
       }
  
       // Cut
       thisCACut.cutValue_ = thisTriplet.cutValue_;
       thisCACut.hasValueByInnerLayerId_ = false;
     }
  
     setCutValuesByInnerLayerIds();
   }

References Exception, foundAllLayerIds_, CAGraph::getLayerId(), setCutValuesByInnerLayerIds(), AlCaHLTBitMon_QueryRunRegistry::string, useCACuts_, valuesByLayerIds_, and valuesByTripletNames_.

Referenced by CAHitTripletGenerator::hitNtuplets(), and CAHitQuadrupletGenerator::hitNtuplets().

◆ setCutValuesByTripletNames()

void CACut::setCutValuesByTripletNames ( const std::vector< edm::ParameterSet > & tripletCuts )

inline

Definition at line 33 of file CACut.h.

                                                                                  {
     for (const auto &thisTriplet : tripletCuts) {
       valuesByTripletNames_.emplace_back();
       auto &thisCACut = valuesByTripletNames_.back();
  
       thisCACut.tripletName_ = thisTriplet.getParameter<std::string>("seedingLayers");
       thisCACut.cutValue_ = thisTriplet.getParameter<double>("cut");
     }
   }