NswAsBuilt::StripCalculator Class Reference

#include <StripCalculator.h>

Collaboration diagram for NswAsBuilt::StripCalculator:

Classes
struct	json_t
struct	position_t
struct	strip_t

Public Types
enum class	IsValid { INVALID =0 , VALID =1 }
using	ParameterClass = Element::ParameterClass

Public Member Functions
strip_t	getStrip (ParameterClass iclass, stripIdentifier_t strip_id) const
position_t	getPositionAlongStrip (ParameterClass iclass, stripIdentifier_t strip_id, double sx, double sy) const
void	parseJSON (const std::string &in)

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)
PcbElement::stripConfiguration_t	getStripConfiguration (json_t j) const

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

Detailed Description

Definition at line 30 of file StripCalculator.h.

Member Typedef Documentation

ParameterClass

using NswAsBuilt::StripCalculator::ParameterClass = Element::ParameterClass

Definition at line 32 of file StripCalculator.h.

Member Enumeration Documentation

IsValid

enum class NswAsBuilt::StripCalculator::IsValid

strong

Enumerator
INVALID
VALID

Definition at line 35 of file StripCalculator.h.

                         {
        INVALID=0,
        VALID=1
      };

Member Function Documentation

buildElement()

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

private

Definition at line 75 of file StripCalculator.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 == "scalesag") {
    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<ElementModelScaleSag>(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));
  el->setAsapId(j.json.at("id_asap"));
 
  // Set the model parameters
  std::map<std::string, double> correctionPars, nominalPars;
  j.json.at("pars_correction").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 StripCalculator::collectStrip ( quadrupletIdentifier_t quad_id, Element & element, json_t j )

private

Definition at line 159 of file StripCalculator.cxx.

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

getPcbIdentifier()

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

private

Definition at line 130 of file StripCalculator.cxx.

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

getPositionAlongStrip()

StripCalculator::position_t StripCalculator::getPositionAlongStrip	(	ParameterClass	iclass,
		stripIdentifier_t	strip_id,
		double	sx,
		double	sy ) const

Definition at line 42 of file StripCalculator.cxx.

                                                                                                                                              {
  int ipcb = (strip_id.istrip-1)/1024 + 1; // MM 1024 channels per PCB, hard-coded convention
  if (std::abs(strip_id.quadruplet.stationEta)==2) {
    ipcb += 5;
  }
  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.getPositionAlongStrip(iclass, strip_id.istrip, sx, sy) };
}

getQuadrupletIdentifier()

quadrupletIdentifier_t StripCalculator::getQuadrupletIdentifier ( json_t j ) const

private

Definition at line 111 of file StripCalculator.cxx.

                                                                              {
  quadrupletIdentifier_t ret;
  std::string stationName;
  j.json.at("station_name").get_to(stationName);
  if (stationName == "MMS") {
    ret.stationName = quadrupletIdentifier_t::MMS;
  } else if (stationName == "MML") {
    ret.stationName = quadrupletIdentifier_t::MML;
  } else {
    throw std::runtime_error("StripCalculator: 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;
}

getStrip()

StripCalculator::strip_t StripCalculator::getStrip	(	ParameterClass	iclass,
		stripIdentifier_t	strip_id ) const

Definition at line 24 of file StripCalculator.cxx.

                                                                                                        {
  int ipcb = (strip_id.istrip-1)/1024 + 1; // MM 1024 channels per PCB, hard-coded convention
  if (std::abs(strip_id.quadruplet.stationEta)==2) {
    ipcb += 5;
  }
  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.getStrip(iclass, strip_id.istrip);
  return {  IsValid::VALID, strip.center, strip.left, strip.right };
}

getStripConfiguration()

PcbElement::stripConfiguration_t StripCalculator::getStripConfiguration ( json_t j ) const

private

Definition at line 140 of file StripCalculator.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("pitchvec").at("x").get_to(xpitch);
    j.at("pitchvec").at("y").get_to(ypitch);
    return PcbElement::stripPoint_t{{xpos,ypos,0.0},{xpitch,ypitch,0.0}};
  };
  PcbElement::stripConfiguration_t ret;
  j.json.at("central_strip_number").get_to(ret.centralStripNumber);
  ret.centerPoint = getPoint(j.json.at("strip_center"));
  ret.leftPoint   = getPoint(j.json.at("strip_left"));
  ret.rightPoint  = getPoint(j.json.at("strip_right"));
  return ret;
}

parseJSON()

void StripCalculator::parseJSON

(

const std::string &

in

)

Definition at line 59 of file StripCalculator.cxx.

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

parseRootElement()

void StripCalculator::parseRootElement ( json_t j )

private

Definition at line 169 of file StripCalculator.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, PcbElement> NswAsBuilt::StripCalculator::m_pcbMap

private

Definition at line 75 of file StripCalculator.h.

m_rootElements

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

private

Definition at line 74 of file StripCalculator.h.

---

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

• StripCalculator.h
• StripCalculator.cxx