AlignPCLThresholdsWriter.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    CondFormats/PCLConfig
// Class:      AlignPCLThresholdsWriter
// 
//
// Original Author:  Marco Musich
//         Created:  Wed, 22 Feb 2017 12:04:36 GMT
//
//

// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "CondFormats/PCLConfig/interface/AlignPCLThresholds.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"

//
// class declaration
//

namespace DOFs {
  enum dof{
    X,
    Y,
    Z,
    thetaX,
    thetaY,
    thetaZ,
    extraDOF
  };
}

class AlignPCLThresholdsWriter : public edm::one::EDAnalyzer<>  {
   public:
      explicit AlignPCLThresholdsWriter(const edm::ParameterSet&);
      ~AlignPCLThresholdsWriter() override;

      static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);


   private:
      void beginJob() override;
      void analyze(const edm::Event&, const edm::EventSetup&) override;
      void endJob() override;
      DOFs::dof mapOntoEnum(std::string coord);

      // ----------member data ---------------------------
      const std::string m_record;
      const unsigned int m_minNrecords;
      const std::vector<edm::ParameterSet> m_parameters;
      AlignPCLThresholds* myThresholds;

};

//
// constructors and destructor
//
AlignPCLThresholdsWriter::AlignPCLThresholdsWriter(const edm::ParameterSet& iConfig):
  m_record(iConfig.getParameter<std::string>("record")),
  m_minNrecords(iConfig.getParameter<unsigned int>("minNRecords")),
  m_parameters(iConfig.getParameter<std::vector<edm::ParameterSet> >("thresholds"))
{
  //now do what ever initialization is needed
  myThresholds = new AlignPCLThresholds();
}


AlignPCLThresholdsWriter::~AlignPCLThresholdsWriter()
{
  delete myThresholds;
}

//
// member functions
//

// ------------ method called for each event  ------------
void
AlignPCLThresholdsWriter::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{
   using namespace edm;
  
   edm::LogInfo("AlignPCLThresholdsWriter")<<"Size of AlignPCLThresholds object "<< myThresholds->size() <<std::endl<<std::endl;
   
   // loop on the PSet and insert the conditions 

   std::array<std::string,6> mandatories = {{"X","Y","Z","thetaX","thetaY","thetaZ"}};
   std::vector<std::string> alignables;

   // fill the list of alignables
   for(auto& thePSet : m_parameters){
     const std::string alignableId(thePSet.getParameter<std::string>("alignableId"));
     // only if it is not yet in the list
     if(std::find(alignables.begin(), alignables.end(), alignableId) == alignables.end()) {
       alignables.push_back(alignableId);
     }
   }

   for (auto& alignable : alignables){
     
     AlignPCLThreshold::coordThresholds my_X;
     AlignPCLThreshold::coordThresholds my_Y;
     AlignPCLThreshold::coordThresholds my_Z;
     AlignPCLThreshold::coordThresholds my_tX;
     AlignPCLThreshold::coordThresholds my_tY;
     AlignPCLThreshold::coordThresholds my_tZ;
   
     std::vector<std::string> presentDOF;

     // extra degrees of freedom
     std::vector< AlignPCLThreshold::coordThresholds > extraDOFs = std::vector< AlignPCLThreshold::coordThresholds >();

     for(auto& thePSet : m_parameters){
     
       const std::string alignableId(thePSet.getParameter<std::string>("alignableId"));
       const std::string DOF(thePSet.getParameter<std::string>("DOF"));
       
       const double cutoff(thePSet.getParameter<double>("cut"));
       const double sigCut(thePSet.getParameter<double>("sigCut"));
       const double maxMoveCut(thePSet.getParameter<double>("maxMoveCut"));
       const double maxErrorCut(thePSet.getParameter<double>("maxErrorCut"));
       
       if (alignableId == alignable){
     presentDOF.push_back(DOF);
     // create the objects 
  
     switch( mapOntoEnum(DOF) )
       {
       case DOFs::X:
         my_X.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;                           
       case DOFs::Y:                          
         my_Y.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;                           
       case DOFs::Z:                          
         my_Z.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;                           
       case DOFs::thetaX:                         
         my_tX.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;                           
       case DOFs::thetaY:                         
         my_tY.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;                           
       case DOFs::thetaZ:                         
         my_tZ.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         break;     
       default:
         edm::LogInfo("AlignPCLThresholdsWriter")<<"Appending Extra degree of freeedom: "<< DOF <<" " << mapOntoEnum(DOF) << std::endl;
         AlignPCLThreshold::coordThresholds ExtraDOF;
         ExtraDOF.setThresholds(cutoff,sigCut,maxErrorCut,maxMoveCut,DOF);
         extraDOFs.push_back(ExtraDOF);
       }
     
     AlignPCLThreshold a(my_X,my_tX,my_Y,my_tY,my_Z,my_tZ,extraDOFs);
     myThresholds->setAlignPCLThreshold(alignableId,a);
     
       } // if alignable is found in the PSet
     } // loop on the PSets

     // checks if all mandatories are present
     edm::LogInfo("AlignPCLThresholdsWriter")<<"Size of AlignPCLThresholds object  "<<myThresholds->size() <<std::endl;
     for(auto& mandatory : mandatories){
       if(std::find(presentDOF.begin(), presentDOF.end(), mandatory) == presentDOF.end()) {
     edm::LogWarning("AlignPCLThresholdsWriter")<<"Configuration for DOF: "<<mandatory<<" for alignable "<< alignable <<"is not present \n" 
                            <<"Will build object with defaults!" <<std::endl;
       }
     }

   } // ends loop on the alignable units
   
   // set the minimum number of records to be used in pede
   myThresholds->setNRecords(m_minNrecords);
   edm::LogInfo("AlignPCLThresholdsWriter")<<"Content of AlignPCLThresholds "<<std::endl;

   // use buil-in method in the CondFormat
   myThresholds->printAll();

   // Form the data here
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   if( poolDbService.isAvailable() ){
     cond::Time_t valid_time = poolDbService->currentTime(); 
     // this writes the payload to begin in current run defined in cfg
     poolDbService->writeOne(myThresholds,valid_time, m_record);
   }
}
   
// ------------ method called once each job just before starting event loop  ------------
void 
AlignPCLThresholdsWriter::beginJob()
{
}

// ------------ method called once each job just after ending the event loop  ------------
void 
AlignPCLThresholdsWriter::endJob() 
{
}

DOFs::dof AlignPCLThresholdsWriter::mapOntoEnum(std::string coord){
  if( coord=="X" ){
    return DOFs::X;
  } 
  else if ( coord=="Y" ){
    return DOFs::Y;
  }
  else if ( coord=="Z" ){
    return DOFs::Z;
  }
  else if ( coord=="thetaX" ){
    return DOFs::thetaX;
  }
  else if ( coord=="thetaY" ){
    return DOFs::thetaY;
  }
  else if ( coord=="thetaZ" ){
    return DOFs::thetaZ;
  } 
  else {
    return DOFs::extraDOF;
  }
  
}

// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void
AlignPCLThresholdsWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

//define this as a plug-in
DEFINE_FWK_MODULE(AlignPCLThresholdsWriter);