CocoaAnalyzer Class Reference

Inheritance diagram for CocoaAnalyzer:

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
void	beginJob () override
	CocoaAnalyzer (edm::ParameterSet const &p)
	CocoaAnalyzer (int i)
	~CocoaAnalyzer () override
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	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 &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
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 &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
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)

Private Member Functions
void	correctAllOpticalAlignments (std::vector< OpticalAlignInfo > &allDBOpticalAlignments)
void	correctOpticalAlignmentParameter (OpticalAlignParam &myXMLParam, const OpticalAlignParam &myDBParam)
std::vector< OpticalAlignInfo >	readCalibrationDB (const edm::EventSetup &evts)
void	readXMLFile (const edm::EventSetup &evts)
void	runCocoa ()

Private Attributes
edm::ESGetToken< cms::DDCompactView, IdealGeometryRecord >	ddcvToken
OpticalAlignMeasurements	measList_
OpticalAlignments	oaList_
edm::ESGetToken< OpticalAlignments, OpticalAlignmentsRcd >	optAliToken
std::string	theCocoaDaqRootFileName_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
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...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 30 of file CocoaAnalyzer.cc.

Constructor & Destructor Documentation

CocoaAnalyzer() [1/2]

CocoaAnalyzer::CocoaAnalyzer ( edm::ParameterSet const &  p )

explicit

Definition at line 56 of file CocoaAnalyzer.cc.

                                                        : optAliToken(esConsumes()), ddcvToken(esConsumes()) {
  theCocoaDaqRootFileName_ = pset.getParameter<std::string>("cocoaDaqRootFile");
  int maxEvents = pset.getParameter<int32_t>("maxEvents");
  GlobalOptionMgr::getInstance()->setDefaultGlobalOptions();
  GlobalOptionMgr::getInstance()->setGlobalOption("maxEvents", maxEvents);
  GlobalOptionMgr::getInstance()->setGlobalOption("writeDBAlign", 1);
  GlobalOptionMgr::getInstance()->setGlobalOption("writeDBOptAlign", 1);
  usesResource("CocoaAnalyzer");
}

References GlobalOptionMgr::getInstance(), Data_TkAlMinBias_Run2018C_PromptReco_v3_cff::maxEvents, muonDTDigis_cfi::pset, GlobalOptionMgr::setDefaultGlobalOptions(), GlobalOptionMgr::setGlobalOption(), AlCaHLTBitMon_QueryRunRegistry::string, and theCocoaDaqRootFileName_.

CocoaAnalyzer() [2/2]

CocoaAnalyzer::CocoaAnalyzer ( int  i )

inlineexplicit

Definition at line 33 of file CocoaAnalyzer.cc.

{}

~CocoaAnalyzer()

CocoaAnalyzer::~CocoaAnalyzer ( )

inlineoverride

Definition at line 34 of file CocoaAnalyzer.cc.

{}

Member Function Documentation

analyze()

void CocoaAnalyzer::analyze ( const edm::Event &  e, const edm::EventSetup &  c  )

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 68 of file CocoaAnalyzer.cc.

                                                                          {
  ALIUtils::setDebugVerbosity(5);
 
  // Get ideal geometry description + measurements for simulation.
  readXMLFile(evts);
 
  // Correct ideal geometry with data from DB.
  std::vector<OpticalAlignInfo> oaListCalib = readCalibrationDB(evts);
  correctAllOpticalAlignments(oaListCalib);
 
  // Run the least-squared fit and store results in DB.
  runCocoa();
}

References correctAllOpticalAlignments(), readCalibrationDB(), readXMLFile(), runCocoa(), and ALIUtils::setDebugVerbosity().

beginJob()

void CocoaAnalyzer::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 66 of file CocoaAnalyzer.cc.

{}

correctAllOpticalAlignments()

void CocoaAnalyzer::correctAllOpticalAlignments ( std::vector< OpticalAlignInfo > &  allDBOpticalAlignments )

private

Definition at line 473 of file CocoaAnalyzer.cc.

                                                                                                   {
  if (ALIUtils::debug >= 3) {
    edm::LogInfo("Alignment") << "$$$ CocoaAnalyzer::correctAllOpticalAlignments: ";
  }
 
  for (const auto& myDBInfo : allDBOpticalAlignments) {
    if (ALIUtils::debug >= 5) {
      edm::LogInfo("Alignment") << "CocoaAnalyzer::findOpticalAlignInfoXML:  Looking for OAI " << myDBInfo.name_;
    }
 
    std::vector<OpticalAlignInfo>& allXMLOpticalAlignments = oaList_.opticalAlignments_;
    const auto& myXMLInfo = std::find_if(
        allXMLOpticalAlignments.begin(), allXMLOpticalAlignments.end(), [&](const auto& myXMLInfoCandidate) {
          return myXMLInfoCandidate.name_ == myDBInfo.name_;
        });
 
    if (myXMLInfo != allXMLOpticalAlignments.end()) {
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << "CocoaAnalyzer::findOpticalAlignInfoXML:  OAI found " << myXMLInfo->name_;
        edm::LogInfo("Alignment")
            << "CocoaAnalyzer::correctAllOpticalAlignments: correcting data from XML with DB info.";
      }
      correctOpticalAlignmentParameter(myXMLInfo->x_, myDBInfo.x_);
      correctOpticalAlignmentParameter(myXMLInfo->y_, myDBInfo.y_);
      correctOpticalAlignmentParameter(myXMLInfo->z_, myDBInfo.z_);
      correctOpticalAlignmentParameter(myXMLInfo->angx_, myDBInfo.angx_);
      correctOpticalAlignmentParameter(myXMLInfo->angy_, myDBInfo.angy_);
      correctOpticalAlignmentParameter(myXMLInfo->angz_, myDBInfo.angz_);
 
      // Also correct extra entries
      const std::vector<OpticalAlignParam>& allDBExtraEntries = myDBInfo.extraEntries_;
      std::vector<OpticalAlignParam>& allXMLExtraEntries = myXMLInfo->extraEntries_;
      for (const auto& myDBExtraEntry : allDBExtraEntries) {
        const auto& myXMLExtraEntry = std::find_if(
            allXMLExtraEntries.begin(), allXMLExtraEntries.end(), [&](const auto& myXMLExtraEntryCandidate) {
              return myXMLExtraEntryCandidate.name_ == myDBExtraEntry.name_;
            });
 
        if (myXMLExtraEntry != allXMLExtraEntries.end()) {
          correctOpticalAlignmentParameter(*myXMLExtraEntry, myDBExtraEntry);
        } else {
          if (myDBExtraEntry.name_ != "None") {
            if (ALIUtils::debug >= 2) {
              edm::LogError("Alignment")
                  << "CocoaAnalyzer::correctAllOpticalAlignments:  extra entry read from DB is not present in XML "
                  << myDBExtraEntry << " in object " << myDBInfo;
            }
          }
        }
      }
 
      if (ALIUtils::debug >= 5) {
        edm::LogInfo("Alignment") << "CocoaAnalyzer::correctAllOpticalAlignments: corrected OpticalAlingInfo "
                                  << oaList_;
      }
    } else {
      if (ALIUtils::debug >= 2) {
        edm::LogError("Alignment") << "CocoaAnalyzer::correctAllOpticalAlignments:  OpticalAlignInfo read from DB "
                                   << myDBInfo << " is not present in XML.";
      }
    }
  }
}

References correctOpticalAlignmentParameter(), ALIUtils::debug, oaList_, and OpticalAlignments::opticalAlignments_.

Referenced by analyze().

correctOpticalAlignmentParameter()

void CocoaAnalyzer::correctOpticalAlignmentParameter ( OpticalAlignParam &  myXMLParam, const OpticalAlignParam &  myDBParam  )

private

Definition at line 540 of file CocoaAnalyzer.cc.

                                                                                         {
  if (myDBParam.value_ != -9.999E9) {
    const std::string& type = myDBParam.dimType();
    double dimFactor = 1.;
 
    if (type == "centre" || type == "length") {
      dimFactor = 1. / dd4hep::m;  // in DB values are stored in dd4hep unit
    } else if (type == "angles" || type == "angle" || type == "nodim") {
      dimFactor = 1.;
    } else {
      edm::LogError("Alignment") << "Incorrect OpticalAlignParam type = " << type;
    }
 
    const double correctedValue = myDBParam.value_ * dimFactor;
    if (ALIUtils::debug >= 4) {
      edm::LogInfo("Alignment") << "CocoaAnalyzer::correctOpticalAlignmentParameter  old value= " << myXMLParam.value_
                                << " new value= " << correctedValue;
    }
    myXMLParam.value_ = correctedValue;
  }
}

References ALIUtils::debug, OpticalAlignParam::dimType(), visualization-live-secondInstance_cfg::m, AlCaHLTBitMon_QueryRunRegistry::string, and OpticalAlignParam::value_.

Referenced by correctAllOpticalAlignments().

readCalibrationDB()

std::vector< OpticalAlignInfo > CocoaAnalyzer::readCalibrationDB ( const edm::EventSetup &  evts )

private

Definition at line 450 of file CocoaAnalyzer.cc.

                                                                                      {
  if (ALIUtils::debug >= 3) {
    edm::LogInfo("Alignment") << "$$$ CocoaAnalyzer::readCalibrationDB: ";
  }
 
  using namespace edm::eventsetup;
  const OpticalAlignments* pObjs = &evts.getData(optAliToken);
  const std::vector<OpticalAlignInfo>& infoFromDB = pObjs->opticalAlignments_;
 
  if (ALIUtils::debug >= 5) {
    edm::LogInfo("Alignment") << "CocoaAnalyzer::readCalibrationDB:  Number of OpticalAlignInfo READ "
                              << infoFromDB.size();
    for (const auto& myInfoFromDB : infoFromDB) {
      edm::LogInfo("Alignment") << "CocoaAnalyzer::readCalibrationDB:  OpticalAlignInfo READ " << myInfoFromDB;
    }
  }
 
  return infoFromDB;
}

References ALIUtils::debug, edm::EventSetup::getData(), optAliToken, and OpticalAlignments::opticalAlignments_.

Referenced by analyze().

readXMLFile()

void CocoaAnalyzer::readXMLFile ( const edm::EventSetup &  evts )

private

Definition at line 87 of file CocoaAnalyzer.cc.

                                                         {
  edm::ESTransientHandle<cms::DDCompactView> myCompactView = evts.getTransientHandle(ddcvToken);
  const cms::DDDetector* mySystem = myCompactView->detector();
 
  if (mySystem) {
    // Always store world volume first.
    const dd4hep::Volume& worldVolume = mySystem->worldVolume();
 
    if (ALIUtils::debug >= 3) {
      edm::LogInfo("Alignment") << "CocoaAnalyzer::ReadXML: world object = " << worldVolume.name();
    }
 
    OpticalAlignInfo worldInfo;
    worldInfo.ID_ = 0;
    worldInfo.name_ = worldVolume.name();
    worldInfo.type_ = "system";
    worldInfo.parentName_ = "";
    worldInfo.x_.value_ = 0.;
    worldInfo.x_.error_ = 0.;
    worldInfo.x_.quality_ = 0;
    worldInfo.y_.value_ = 0.;
    worldInfo.y_.error_ = 0.;
    worldInfo.y_.quality_ = 0;
    worldInfo.z_.value_ = 0.;
    worldInfo.z_.error_ = 0.;
    worldInfo.z_.quality_ = 0;
    worldInfo.angx_.value_ = 0.;
    worldInfo.angx_.error_ = 0.;
    worldInfo.angx_.quality_ = 0;
    worldInfo.angy_.value_ = 0.;
    worldInfo.angy_.error_ = 0.;
    worldInfo.angy_.quality_ = 0;
    worldInfo.angz_.value_ = 0.;
    worldInfo.angz_.error_ = 0.;
    worldInfo.angz_.quality_ = 0;
    oaList_.opticalAlignments_.emplace_back(worldInfo);
 
    // This gathers all the 'SpecPar' sections from the loaded XMLs.
    // NB: Definition of a SpecPar section:
    // It is a block in the XML file(s), containing paths to specific volumes,
    // and ALLOWING THE ASSOCIATION OF SPECIFIC PARAMETERS AND VALUES TO THESE VOLUMES.
    const cms::DDSpecParRegistry& allSpecParSections = myCompactView->specpars();
 
    // CREATION OF A COCOA FILTERED VIEW
    // Creation of the dd4hep-based filtered view.
    // NB: not filtered yet!
    cms::DDFilteredView myFilteredView(mySystem, worldVolume);
    // Declare a container which will gather all the filtered SpecPar sections.
    cms::DDSpecParRefs cocoaParameterSpecParSections;
    // Define a COCOA filter
    const std::string cocoaParameterAttribute = "COCOA";
    const std::string cocoaParameterValue = "COCOA";
    // All the COCOA SpecPar sections are filtered from allSpecParSections,
    // and assigned to cocoaParameterSpecParSections.
    allSpecParSections.filter(cocoaParameterSpecParSections, cocoaParameterAttribute, cocoaParameterValue);
    // This finally allows to filter the filtered view, with the COCOA filter.
    // This means that we now have, in myFilteredView, all volumes whose paths were selected:
    // ie all volumes with "COCOA" parameter and value in a SpecPar section from a loaded XML.
    myFilteredView.mergedSpecifics(cocoaParameterSpecParSections);
 
    // Loop on parts
    int nObjects = 0;
    bool doCOCOA = myFilteredView.firstChild();
 
    // Loop on all COCOA volumes from filtered view
    while (doCOCOA) {
      ++nObjects;
 
      OpticalAlignInfo oaInfo;
      OpticalAlignParam oaParam;
      OpticalAlignMeasurementInfo oaMeas;
 
      // Current volume
      const dd4hep::PlacedVolume& myPlacedVolume = myFilteredView.volume();
      const std::string& name = myPlacedVolume.name();
      const std::string& nodePath = myFilteredView.path();
      oaInfo.name_ = nodePath;
 
      // Parent name
      oaInfo.parentName_ = nodePath.substr(0, nodePath.rfind('/', nodePath.length()));
 
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << " CocoaAnalyzer::ReadXML reading object " << name;
        edm::LogInfo("Alignment") << " @@ Name built= " << oaInfo.name_ << " short_name= " << name
                                  << " parent= " << oaInfo.parentName_;
      }
 
      // TRANSLATIONS
 
      // A) GET TRANSLATIONS FROM DDETECTOR.
      // Directly get translation from parent to child volume
      const dd4hep::Direction& transl = myPlacedVolume.position();
 
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << "Local translation in dd4hep units = " << transl;
      }
 
      // B) READ INFO FROM XMLS
      // X
      oaInfo.x_.name_ = "X";
      oaInfo.x_.dim_type_ = "centre";
      oaInfo.x_.value_ = transl.x() / dd4hep::m;  // COCOA units are m
      oaInfo.x_.error_ = cms::getParameterValueFromSpecParSections<double>(allSpecParSections,
                                                                           nodePath,
                                                                           "centre_X_sigma",
                                                                           0) /
                         dd4hep::m;  // COCOA units are m
      oaInfo.x_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "centre_X_quality", 0));
      // Y
      oaInfo.y_.name_ = "Y";
      oaInfo.y_.dim_type_ = "centre";
      oaInfo.y_.value_ = transl.y() / dd4hep::m;  // COCOA units are m
      oaInfo.y_.error_ = cms::getParameterValueFromSpecParSections<double>(allSpecParSections,
                                                                           nodePath,
                                                                           "centre_Y_sigma",
                                                                           0) /
                         dd4hep::m;  // COCOA units are m
      oaInfo.y_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "centre_Y_quality", 0));
      // Z
      oaInfo.z_.name_ = "Z";
      oaInfo.z_.dim_type_ = "centre";
      oaInfo.z_.value_ = transl.z() / dd4hep::m;  // COCOA units are m
      oaInfo.z_.error_ = cms::getParameterValueFromSpecParSections<double>(allSpecParSections,
                                                                           nodePath,
                                                                           "centre_Z_sigma",
                                                                           0) /
                         dd4hep::m;  // COCOA units are m
      oaInfo.z_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "centre_Z_quality", 0));
 
      // ROTATIONS
 
      // A) GET ROTATIONS FROM DDETECTOR.
 
      // Unlike in the initial code, here we manage to directly get the rotation matrix placement
      // of the child in parent, EXPRESSED IN THE PARENT FRAME OF REFERENCE.
      // Hence the (ugly) initial block of code is replaced by just 2 lines.
      // PlacedVolume::matrix() returns the rotation matrix IN THE PARENT FRAME OF REFERENCE.
      // NB: Not using DDFilteredView::rotation(),
      // because it returns the rotation matrix IN THE WORLD FRAME OF REFERENCE.
      const TGeoHMatrix parentToChild = myPlacedVolume.matrix();
      // COCOA convention is FROM CHILD TO PARENT
      const TGeoHMatrix& childToParent = parentToChild.Inverse();
 
      // Convert it to CLHEP::Matrix
      // Below is not my code, below block is untouched (apart from bug fix).
      // I would just directly use childToParent...
      const Double_t* rot = childToParent.GetRotationMatrix();
      const double xx = rot[0];
      const double xy = rot[1];
      const double xz = rot[2];
      const double yx = rot[3];
      const double yy = rot[4];
      const double yz = rot[5];
      const double zx = rot[6];
      const double zy = rot[7];
      const double zz = rot[8];
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << "Local rotation = ";
        edm::LogInfo("Alignment") << xx << "  " << xy << "  " << xz;
        edm::LogInfo("Alignment") << yx << "  " << yy << "  " << yz;
        edm::LogInfo("Alignment") << zx << "  " << zy << "  " << zz;
      }
      const CLHEP::Hep3Vector colX(xx, yx, zx);
      const CLHEP::Hep3Vector colY(xy, yy, zy);
      const CLHEP::Hep3Vector colZ(xz, yz, zz);
      const CLHEP::HepRotation rotclhep(colX, colY, colZ);
      const std::vector<double>& angles = ALIUtils::getRotationAnglesFromMatrix(rotclhep, 0., 0., 0.);
 
      // B) READ INFO FROM XMLS
      // X
      oaInfo.angx_.name_ = "X";
      oaInfo.angx_.dim_type_ = "angles";
      oaInfo.angx_.value_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_X_value", 0);
      oaInfo.angx_.error_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_X_sigma", 0);
      oaInfo.angx_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_X_quality", 0));
      // Y
      oaInfo.angy_.name_ = "Y";
      oaInfo.angy_.dim_type_ = "angles";
      oaInfo.angy_.value_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Y_value", 0);
      oaInfo.angy_.error_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Y_sigma", 0);
      oaInfo.angy_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Y_quality", 0));
      // Z
      oaInfo.angz_.name_ = "Z";
      oaInfo.angz_.dim_type_ = "angles";
      oaInfo.angz_.value_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Z_value", 0);
      oaInfo.angz_.error_ =
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Z_sigma", 0);
      oaInfo.angz_.quality_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "angles_Z_quality", 0));
 
      oaInfo.type_ =
          cms::getParameterValueFromSpecParSections<std::string>(allSpecParSections, nodePath, "cocoa_type", 0);
 
      oaInfo.ID_ = static_cast<int>(
          cms::getParameterValueFromSpecParSections<double>(allSpecParSections, nodePath, "cmssw_ID", 0));
 
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << "CocoaAnalyzer::ReadXML OBJECT " << oaInfo.name_ << " pos/angles read ";
      }
 
      // Check that rotations match with values from XMLs.
      // Same, that ugly code is not mine ;p
      if (fabs(oaInfo.angx_.value_ - angles[0]) > 1.E-9 || fabs(oaInfo.angy_.value_ - angles[1]) > 1.E-9 ||
          fabs(oaInfo.angz_.value_ - angles[2]) > 1.E-9) {
        edm::LogError("Alignment") << " WRONG ANGLE IN OBJECT " << oaInfo.name_ << oaInfo.angx_.value_ << " =? "
                                   << angles[0] << oaInfo.angy_.value_ << " =? " << angles[1] << oaInfo.angz_.value_
                                   << " =? " << angles[2];
      }
 
      // EXTRA PARAM ENTRIES (FROM XMLS)
      // Here initial code to define the containers was fully removed, this is much more compact.
      const std::vector<std::string>& names =
          cms::getAllParameterValuesFromSpecParSections<std::string>(allSpecParSections, nodePath, "extra_entry");
      const std::vector<std::string>& dims =
          cms::getAllParameterValuesFromSpecParSections<std::string>(allSpecParSections, nodePath, "dimType");
      const std::vector<double>& values =
          cms::getAllParameterValuesFromSpecParSections<double>(allSpecParSections, nodePath, "value");
      const std::vector<double>& errors =
          cms::getAllParameterValuesFromSpecParSections<double>(allSpecParSections, nodePath, "sigma");
      const std::vector<double>& quality =
          cms::getAllParameterValuesFromSpecParSections<double>(allSpecParSections, nodePath, "quality");
 
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << " CocoaAnalyzer::ReadXML:  Fill extra entries with read parameters ";
      }
 
      if (names.size() == dims.size() && dims.size() == values.size() && values.size() == errors.size() &&
          errors.size() == quality.size()) {
        for (size_t i = 0; i < names.size(); ++i) {
          double dimFactor = 1.;
          const std::string& type = dims[i];
          if (type == "centre" || type == "length") {
            dimFactor =
                1. / dd4hep::m;  // was converted to dd4hep unit with getParameterValueFromSpecPar, COCOA unit is m
          } else if (type == "angles" || type == "angle" || type == "nodim") {
            dimFactor = 1.;
          }
          oaParam.value_ = values[i] * dimFactor;
          oaParam.error_ = errors[i] * dimFactor;
          oaParam.quality_ = static_cast<int>(quality[i]);
          oaParam.name_ = names[i];
          oaParam.dim_type_ = dims[i];
          oaInfo.extraEntries_.emplace_back(oaParam);
          oaParam.clear();
        }
 
        oaList_.opticalAlignments_.emplace_back(oaInfo);
      } else {
        edm::LogInfo("Alignment") << "WARNING FOR NOW: sizes of extra parameters (names, dimType, value, quality) do"
                                  << " not match!  Did not add " << nObjects << " item to OpticalAlignments.";
      }
 
      // MEASUREMENTS (FROM XMLS)
      const std::vector<std::string>& measNames =
          cms::getAllParameterValuesFromSpecParSections<std::string>(allSpecParSections, nodePath, "meas_name");
      const std::vector<std::string>& measTypes =
          cms::getAllParameterValuesFromSpecParSections<std::string>(allSpecParSections, nodePath, "meas_type");
 
      std::map<std::string, std::vector<std::string>> measObjectNames;
      std::map<std::string, std::vector<std::string>> measParamNames;
      std::map<std::string, std::vector<double>> measParamValues;
      std::map<std::string, std::vector<double>> measParamSigmas;
      std::map<std::string, std::vector<double>> measIsSimulatedValue;
      for (const auto& name : measNames) {
        measObjectNames[name] = cms::getAllParameterValuesFromSpecParSections<std::string>(
            allSpecParSections, nodePath, "meas_object_name_" + name);
        measParamNames[name] = cms::getAllParameterValuesFromSpecParSections<std::string>(
            allSpecParSections, nodePath, "meas_value_name_" + name);
        measParamValues[name] =
            cms::getAllParameterValuesFromSpecParSections<double>(allSpecParSections, nodePath, "meas_value_" + name);
        measParamSigmas[name] =
            cms::getAllParameterValuesFromSpecParSections<double>(allSpecParSections, nodePath, "meas_sigma_" + name);
        measIsSimulatedValue[name] = cms::getAllParameterValuesFromSpecParSections<double>(
            allSpecParSections, nodePath, "meas_is_simulated_value_" + name);
      }
 
      if (ALIUtils::debug >= 4) {
        edm::LogInfo("Alignment") << " CocoaAnalyzer::ReadXML:  Fill measurements with read parameters ";
      }
 
      if (measNames.size() == measTypes.size()) {
        for (size_t i = 0; i < measNames.size(); ++i) {
          oaMeas.ID_ = i;
          oaMeas.name_ = measNames[i];
          oaMeas.type_ = measTypes[i];
          oaMeas.measObjectNames_ = measObjectNames[oaMeas.name_];
          if (measParamNames.size() == measParamValues.size() && measParamValues.size() == measParamSigmas.size()) {
            for (size_t i2 = 0; i2 < measParamNames[oaMeas.name_].size(); i2++) {
              oaParam.name_ = measParamNames[oaMeas.name_][i2];
              oaParam.value_ = measParamValues[oaMeas.name_][i2];
              oaParam.error_ = measParamSigmas[oaMeas.name_][i2];
              oaParam.quality_ = 2;
              if (oaMeas.type_ == "SENSOR2D" || oaMeas.type_ == "COPS" || oaMeas.type_ == "DISTANCEMETER" ||
                  oaMeas.type_ == "DISTANCEMETER!DIM" || oaMeas.type_ == "DISTANCEMETER3DIM") {
                oaParam.dim_type_ = "length";
              } else if (oaMeas.type_ == "TILTMETER") {
                oaParam.dim_type_ = "angle";
              } else {
                edm::LogError("Alignment") << "CocoaAnalyzer::readXMLFile. Invalid measurement type: " << oaMeas.type_;
              }
 
              oaMeas.values_.emplace_back(oaParam);
              oaMeas.isSimulatedValue_.emplace_back(measIsSimulatedValue[oaMeas.name_][i2]);
              if (ALIUtils::debug >= 5) {
                edm::LogInfo("Alignment") << oaMeas.name_ << " copying issimu "
                                          << oaMeas.isSimulatedValue_[oaMeas.isSimulatedValue_.size() - 1] << " = "
                                          << measIsSimulatedValue[oaMeas.name_][i2];
              }
              oaParam.clear();
            }
          } else {
            if (ALIUtils::debug >= 2) {
              edm::LogWarning("Alignment") << "WARNING FOR NOW: sizes of measurement parameters (name, value, sigma) do"
                                           << " not match! for measurement " << oaMeas.name_
                                           << " !Did not fill parameters for this measurement ";
            }
          }
          measList_.oaMeasurements_.emplace_back(oaMeas);
          if (ALIUtils::debug >= 5) {
            edm::LogInfo("Alignment") << "CocoaAnalyser: MEASUREMENT " << oaMeas.name_ << " extra entries read "
                                      << oaMeas;
          }
          oaMeas.clear();
        }
 
      } else {
        if (ALIUtils::debug >= 2) {
          edm::LogWarning("Alignment") << "WARNING FOR NOW: sizes of measurements (names, types do"
                                       << " not match!  Did not add " << nObjects << " item to XXXMeasurements";
        }
      }
 
      oaInfo.clear();
      doCOCOA = myFilteredView.firstChild();
    }  // while (doCOCOA)
 
    if (ALIUtils::debug >= 3) {
      edm::LogInfo("Alignment") << "CocoaAnalyzer::ReadXML: Finished building " << nObjects + 1
                                << " OpticalAlignInfo objects"
                                << " and " << measList_.oaMeasurements_.size()
                                << " OpticalAlignMeasurementInfo objects ";
    }
    if (ALIUtils::debug >= 5) {
      edm::LogInfo("Alignment") << " @@@@@@ OpticalAlignments " << oaList_;
      edm::LogInfo("Alignment") << " @@@@@@ OpticalMeasurements " << measList_;
    }
  }
}

References particleFlowDisplacedVertex_cfi::angles, OpticalAlignInfo::angx_, OpticalAlignInfo::angy_, OpticalAlignInfo::angz_, OpticalAlignMeasurementInfo::clear(), OpticalAlignParam::clear(), OpticalAlignInfo::clear(), ddcvToken, ALIUtils::debug, cms::DDCompactView::detector(), OpticalAlignParam::dim_type_, OpticalAlignParam::error_, OpticalAlignInfo::extraEntries_, cms::DDFilteredView::firstChild(), ALIUtils::getRotationAnglesFromMatrix(), edm::EventSetup::getTransientHandle(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i2, OpticalAlignMeasurementInfo::ID_, OpticalAlignInfo::ID_, OpticalAlignMeasurementInfo::isSimulatedValue_, visualization-live-secondInstance_cfg::m, measList_, OpticalAlignMeasurementInfo::measObjectNames_, cms::DDFilteredView::mergedSpecifics(), Skims_PA_cff::name, OpticalAlignMeasurementInfo::name_, OpticalAlignParam::name_, OpticalAlignInfo::name_, names, oaList_, OpticalAlignMeasurements::oaMeasurements_, OpticalAlignments::opticalAlignments_, OpticalAlignInfo::parentName_, cms::DDFilteredView::path(), quality, OpticalAlignParam::quality_, makeMuonMisalignmentScenario::rot, cms::DDCompactView::specpars(), AlCaHLTBitMon_QueryRunRegistry::string, OpticalAlignMeasurementInfo::type_, OpticalAlignInfo::type_, OpticalAlignParam::value_, contentValuesCheck::values, OpticalAlignMeasurementInfo::values_, cms::DDFilteredView::volume(), cms::DDDetector::worldVolume(), OpticalAlignInfo::x_, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, OpticalAlignInfo::y_, geometryCSVtoXML::yy, geometryCSVtoXML::yz, OpticalAlignInfo::z_, and geometryCSVtoXML::zz.

Referenced by analyze().

runCocoa()

void CocoaAnalyzer::runCocoa ( )

private

Definition at line 566 of file CocoaAnalyzer.cc.

                             {
  if (ALIUtils::debug >= 3) {
    edm::LogInfo("Alignment") << "$$$ CocoaAnalyzer::runCocoa: ";
  }
 
  // Geometry model built from XML file (corrected with values from DB)
  Model& model = Model::getInstance();
  model.BuildSystemDescriptionFromOA(oaList_);
 
  if (ALIUtils::debug >= 3) {
    edm::LogInfo("Alignment") << "$$ CocoaAnalyzer::runCocoa: geometry built ";
  }
 
  // Build measurements
  model.BuildMeasurementsFromOA(measList_);
 
  if (ALIUtils::debug >= 3) {
    edm::LogInfo("Alignment") << "$$ CocoaAnalyzer::runCocoa: measurements built ";
  }
 
  // Do fit and store results in DB
  Fit::getInstance();
  Fit::startFit();
 
  if (ALIUtils::debug >= 0)
    edm::LogInfo("Alignment") << "............ program ended OK";
  if (ALIUtils::report >= 1) {
    ALIFileOut& fileout = ALIFileOut::getInstance(Model::ReportFName());
    fileout << "............ program ended OK";
  }
}

References ALIUtils::debug, ALIFileOut::getInstance(), Fit::getInstance(), Model::getInstance(), measList_, ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, oaList_, ALIUtils::report, Model::ReportFName(), and Fit::startFit().

Referenced by analyze().

Member Data Documentation

ddcvToken

edm::ESGetToken<cms::DDCompactView, IdealGeometryRecord> CocoaAnalyzer::ddcvToken

private

Definition at line 50 of file CocoaAnalyzer.cc.

Referenced by readXMLFile().

measList_

OpticalAlignMeasurements CocoaAnalyzer::measList_

private

Definition at line 52 of file CocoaAnalyzer.cc.

Referenced by readXMLFile(), and runCocoa().

oaList_

OpticalAlignments CocoaAnalyzer::oaList_

private

Definition at line 51 of file CocoaAnalyzer.cc.

Referenced by correctAllOpticalAlignments(), readXMLFile(), and runCocoa().

optAliToken

edm::ESGetToken<OpticalAlignments, OpticalAlignmentsRcd> CocoaAnalyzer::optAliToken

private

Definition at line 49 of file CocoaAnalyzer.cc.

Referenced by readCalibrationDB().

theCocoaDaqRootFileName_

std::string CocoaAnalyzer::theCocoaDaqRootFileName_

private

Definition at line 53 of file CocoaAnalyzer.cc.

Referenced by CocoaAnalyzer().