NswAsBuilt::StgcStripCalculator Class Reference

The main interface of the NswAsBuilt package: determines strip positions in the frame of the quadruplet. More...

#include <StgcStripCalculator.h>

Collaboration diagram for NswAsBuilt::StgcStripCalculator:

Classes
struct	json_t
struct	position_t
	The return object for querying strip positions with the method getPositionAlongStrip: a single point on strip is returned, in the coordinate system of the quadruplet. More...
struct	stgcStrip_t
	The return object for querying strip positions: three points along the strip are provided, in the coordinate system of the quadruplet. More...

Public Types
enum	IsValid { IsValid::INVALID =0, IsValid::VALID =1 }
	VALID: strip is found, INVALID: strip is not found. More...
using	ParameterClass = Element::ParameterClass

Public Member Functions
stgcStrip_t	getStgcStrip (ParameterClass iclass, stripIdentifier_t strip_id) const
	Computes 3 reference points along a strip identified by strip_id, in coordinate system of quadruplet. More...
position_t	getPositionAlongStgcStrip (ParameterClass iclass, stripIdentifier_t strip_id, double sx, double sy) const
	Returns a the position of a point along the strip, parameterized by s, in the coordinate system of the quadruplet. More...
void	parseJSON (const std::string &in)
	Parses a std::istream with JSON-formatted configuration of the as-built parameters. More...

Private Member Functions
void	parseRootElement (json_t j)
std::unique_ptr< Element >	buildElement (json_t j) const
quadrupletIdentifier_t	getQuadrupletIdentifier (json_t j) const
pcbIdentifier_t	getPcbIdentifier (quadrupletIdentifier_t quad_id, json_t j) const
void	collectStrip (quadrupletIdentifier_t quad_id, Element &element, json_t j)
CathodeBoardElement::stgcStripConfiguration_t	getStgcStripConfiguration (json_t j) const

Private Attributes
std::vector< std::unique_ptr< Element > >	m_rootElements
std::unordered_map< pcbIdentifier_t, CathodeBoardElement >	m_pcbMap

Detailed Description

The main interface of the NswAsBuilt package: determines strip positions in the frame of the quadruplet.

Once instanciated, the as-built geometry must be read in from a stream of JSON formatted data, using the method parseJSON.

Strip positions may then be queried, using the method getStgcStrip. (The method getStgcStrip is thread-safe.)

Definition at line 31 of file StgcStripCalculator.h.

Member Typedef Documentation

ParameterClass

using NswAsBuilt::StgcStripCalculator::ParameterClass = Element::ParameterClass

Definition at line 33 of file StgcStripCalculator.h.

Member Enumeration Documentation

IsValid

enum NswAsBuilt::StgcStripCalculator::IsValid

strong

VALID: strip is found, INVALID: strip is not found.

Enumerator
INVALID
VALID

Definition at line 38 of file StgcStripCalculator.h.

                         {
        INVALID=0,
        VALID=1
      };

Member Function Documentation

buildElement()

std::unique_ptr< Element > StgcStripCalculator::buildElement ( json_t  j ) const

private

Definition at line 61 of file StgcStripCalculator.cxx.

                                                                       {
  // Build the appropriate deformation model
  std::unique_ptr<ElementModel> deformation_model;
  std::string model = j.json.at("model");
  if (model == "nodefo") {
    deformation_model = std::make_unique<ElementModelRigid>();
  } 
  else if (model == "stgc") {
    double lenX, lenY;
    Amg::Vector3D defo0;
    const auto& jc = j.json.at("model_constant_pars");
    jc.at("len_x").get_to(lenX);
    jc.at("len_y").get_to(lenY);
    jc.at("defo0_x").get_to(defo0[0]);
    jc.at("defo0_y").get_to(defo0[1]);
    jc.at("defo0_z").get_to(defo0[2]);
    deformation_model = std::make_unique<ElementModelSTGC>(lenX, lenY, defo0);
  } 
  else {
    throw std::runtime_error("Unknown model: "+model);
  }
 
  // Build the element
  std::unique_ptr<Element> el = std::make_unique<Element>(std::move(deformation_model));
 
  // Set the model parameters
  std::map<std::string, double> correctionPars, nominalPars;
  j.json.at("pars_corrected").get_to(correctionPars);
  j.json.at("pars_nominal").get_to(nominalPars);
  el->setParametersFromMap(ParameterClass::CORRECTION, correctionPars);
  el->setParametersFromMap(ParameterClass::NOMINAL, nominalPars);
 
  return el;
}

collectStrip()

void StgcStripCalculator::collectStrip ( quadrupletIdentifier_t  quad_id, Element &  element, json_t  j  )

private

Definition at line 142 of file StgcStripCalculator.cxx.

                                                                                                 {
  if (j.json.contains("strip_configuration") && j.json.contains("identifier")) {
    pcbIdentifier_t pcb_id = getPcbIdentifier(quad_id, j.json.at("identifier"));
    CathodeBoardElement::stgcStripConfiguration_t config = getStgcStripConfiguration(j.json.at("strip_configuration"));
    m_pcbMap.insert(std::make_pair(pcb_id, CathodeBoardElement(config, element)));
  }
}

getPcbIdentifier()

pcbIdentifier_t StgcStripCalculator::getPcbIdentifier ( quadrupletIdentifier_t  quad_id, json_t  j  ) const

private

Definition at line 112 of file StgcStripCalculator.cxx.

                                                                                                    {
  pcbIdentifier_t ret;
  ret.quadruplet = quad_id;
  j.json.at("ilayer").get_to(ret.ilayer);
  j.json.at("ipcb").get_to(ret.ipcb);
  return ret;
}

getPositionAlongStgcStrip()

StgcStripCalculator::position_t StgcStripCalculator::getPositionAlongStgcStrip	(	ParameterClass	iclass,
		stripIdentifier_t	strip_id,
		double	sx,
		double	sy
	)		const

Returns a the position of a point along the strip, parameterized by s, in the coordinate system of the quadruplet.

s is in [-1,1]: -1 returns the left-most point along the strip, 0 returns the center point and +1 return the right-most point

Definition at line 34 of file StgcStripCalculator.cxx.

                                                                                                                                                          {
  int ipcb = 9; // since sTGC strip boards are identical  
  pcbIdentifier_t pcb_id { strip_id.quadruplet, strip_id.ilayer, ipcb };
  auto it = m_pcbMap.find(pcb_id);
 
  if (it == m_pcbMap.end()) {
    return {};
  }
 
  return { IsValid::VALID, it->second.getPositionAlongStgcStrip(iclass, strip_id.istrip, sx, sy) };
}

getQuadrupletIdentifier()

quadrupletIdentifier_t StgcStripCalculator::getQuadrupletIdentifier ( json_t  j ) const

private

Definition at line 96 of file StgcStripCalculator.cxx.

                                                                                  {
  quadrupletIdentifier_t ret;
  std::string stationName;
  j.json.at("station_name").get_to(stationName);
  if (stationName == "STS") {
    ret.stationName = quadrupletIdentifier_t::STS;
  } else if (stationName == "STL") {
    ret.stationName = quadrupletIdentifier_t::STL;
  } else {
    throw std::runtime_error("StgcStripCalculator: stationName not implemented: "+stationName);
  }
  j.json.at("station_eta").get_to(ret.stationEta);
  j.json.at("station_phi").get_to(ret.stationPhi);
  j.json.at("multilayer").get_to(ret.multilayer);
  return ret;
}

getStgcStrip()

StgcStripCalculator::stgcStrip_t StgcStripCalculator::getStgcStrip	(	ParameterClass	iclass,
		stripIdentifier_t	strip_id
	)		const

Computes 3 reference points along a strip identified by strip_id, in coordinate system of quadruplet.

Use iclass=ParameterClass::NOMINAL or ParameterClass::CORRECTION to get the nominal or as-built values, respectively.

Definition at line 22 of file StgcStripCalculator.cxx.

                                                                                                                        {
  int ipcb = 9; // since sTGC strip boards are identical  
  pcbIdentifier_t pcb_id { strip_id.quadruplet, strip_id.ilayer, ipcb };
  auto it = m_pcbMap.find(pcb_id);
 
  if (it == m_pcbMap.end()) {
    return {};
  }
 
  auto strip = it->second.getStgcStrip(iclass, strip_id.istrip);
  return { IsValid::VALID, strip.center, strip.left, strip.right };
}

getStgcStripConfiguration()

CathodeBoardElement::stgcStripConfiguration_t StgcStripCalculator::getStgcStripConfiguration ( json_t  j ) const

private

Definition at line 119 of file StgcStripCalculator.cxx.

                                                                                                         {
  auto getPoint = [](const nlohmann::json& j) {
    double xpos, ypos, xpitch, ypitch;
    j.at("pos").at("x").get_to(xpos);
    j.at("pos").at("y").get_to(ypos);
    j.at("pitch").at("x").get_to(xpitch);
    j.at("pitch").at("y").get_to(ypitch);
    return CathodeBoardElement::stgcStripPoint_t{{xpos,ypos,0.0},{xpitch,ypitch,0.0}};
  };
  CathodeBoardElement::stgcStripConfiguration_t ret;
  j.json.at("nstrip").get_to(ret.lastStripNumber);
  ret.fCenterPoint = getPoint(j.json.at("first_strip_center"));
  ret.fLeftPoint   = getPoint(j.json.at("first_strip_left"));
  ret.fRightPoint  = getPoint(j.json.at("first_strip_right"));
  ret.sCenterPoint = getPoint(j.json.at("second_strip_center"));
  ret.sLeftPoint   = getPoint(j.json.at("second_strip_left"));
  ret.sRightPoint  = getPoint(j.json.at("second_strip_right"));
  ret.lCenterPoint = getPoint(j.json.at("last_strip_center"));
  ret.lLeftPoint   = getPoint(j.json.at("last_strip_left"));
  ret.lRightPoint  = getPoint(j.json.at("last_strip_right"));
  return ret;
}

parseJSON()

void StgcStripCalculator::parseJSON

(

const std::string &

in

)

Parses a std::istream with JSON-formatted configuration of the as-built parameters.

Definition at line 46 of file StgcStripCalculator.cxx.

                                                       {
  try {
    using json = nlohmann::json;
    json jroot = json::parse(in);
    for (const json& jmodule : jroot.at("elementarray")) {
      parseRootElement(jmodule);
    }
  } catch (const std::exception& e) {
    throw std::runtime_error(e.what());
  }
}

parseRootElement()

void StgcStripCalculator::parseRootElement ( json_t  j )

private

Definition at line 150 of file StgcStripCalculator.cxx.

                                                   {
  using json = nlohmann::json;
  struct tree_t {
    json::const_iterator it;
    json::const_iterator end;
  };
 
  if (!j.json.contains("identifier")) {
    // No athena identifier given for this element, skip
    return;
  }
 
  std::unique_ptr<Element> root = buildElement(j);
  quadrupletIdentifier_t quad_id = getQuadrupletIdentifier(j.json.at("identifier"));
  Element* mom = root.get();
  const std::string KEY = "zdaughters";
 
  // Depth-traversal of json tree, collect elements along the way
  std::list<tree_t> jtree;
  jtree.push_back({j.json.at(KEY).begin(), j.json.at(KEY).end()});
  while (!jtree.empty()) {
    auto& it = jtree.back().it;
    if (it != jtree.back().end) {
      std::unique_ptr<Element> daughter = buildElement(*it);
      collectStrip(quad_id, *daughter, *it);
      Element* daugref = mom->addDaughter(std::move(daughter));
      if (it->contains(KEY)) {
        jtree.push_back({it->at(KEY).begin(), it->at(KEY).end()});
        mom = daugref;
      }
      ++it;
    } else {
      jtree.pop_back();
      mom = mom->mother();
    }
  }
 
  m_rootElements.push_back(std::move(root));
}

Member Data Documentation

m_pcbMap

std::unordered_map<pcbIdentifier_t, CathodeBoardElement> NswAsBuilt::StgcStripCalculator::m_pcbMap

private

Definition at line 88 of file StgcStripCalculator.h.

m_rootElements

std::vector<std::unique_ptr<Element> > NswAsBuilt::StgcStripCalculator::m_rootElements

private

Definition at line 87 of file StgcStripCalculator.h.

---

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

• StgcStripCalculator.h
• StgcStripCalculator.cxx