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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

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
OpticalAlignMeasurements	measList_

OpticalAlignments	oaList_

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 54 of file CocoaAnalyzer.cc.

                                                         {
   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.

33 {}

◆ ~CocoaAnalyzer()

CocoaAnalyzer::~CocoaAnalyzer ( )

inlineoverride

Definition at line 34 of file CocoaAnalyzer.cc.

34 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 66 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 64 of file CocoaAnalyzer.cc.

64 {}

◆ correctAllOpticalAlignments()

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

private

Definition at line 474 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 541 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;
   edm::ESHandle<OpticalAlignments> pObjs;
   evts.get<OpticalAlignmentsRcd>().get(pObjs);
   const std::vector<OpticalAlignInfo>& infoFromDB = pObjs.product()->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::get(), get, OpticalAlignments::opticalAlignments_, and edm::ESHandle< T >::product().

Referenced by analyze().

◆ readXMLFile()

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

private

Definition at line 85 of file CocoaAnalyzer.cc.

                                                          {
   edm::ESTransientHandle<cms::DDCompactView> myCompactView;
   evts.get<IdealGeometryRecord>().get(myCompactView);
  
   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_;
     }
   }
 }

Referenced by analyze().

◆ runCocoa()

void CocoaAnalyzer::runCocoa ( )

private

Definition at line 567 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

◆ measList_

OpticalAlignMeasurements CocoaAnalyzer::measList_

private

Definition at line 50 of file CocoaAnalyzer.cc.

Referenced by readXMLFile(), and runCocoa().

◆ oaList_

OpticalAlignments CocoaAnalyzer::oaList_

private

Definition at line 49 of file CocoaAnalyzer.cc.

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

◆ theCocoaDaqRootFileName_

std::string CocoaAnalyzer::theCocoaDaqRootFileName_

private

Definition at line 51 of file CocoaAnalyzer.cc.

Referenced by CocoaAnalyzer().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CocoaAnalyzer() [1/2]

◆ CocoaAnalyzer() [2/2]

◆ ~CocoaAnalyzer()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ correctAllOpticalAlignments()

◆ correctOpticalAlignmentParameter()

◆ readCalibrationDB()

◆ readXMLFile()

◆ runCocoa()

Member Data Documentation

◆ measList_

◆ oaList_

◆ theCocoaDaqRootFileName_