MuonMillepedeAlgorithm Class Reference

#include <MuonMillepedeAlgorithm.h>

Inheritance diagram for MuonMillepedeAlgorithm:

Public Member Functions
void	collect ()
void	initialize (const edm::EventSetup &setup, AlignableTracker *tracker, AlignableMuon *muon, AlignableExtras *extras, AlignmentParameterStore *store) override
	Call at beginning of job. More...
	MuonMillepedeAlgorithm (const edm::ParameterSet &cfg)
	Constructor. More...
void	run (const edm::EventSetup &setup, const EventInfo &eventInfo) override
	Run the algorithm. More...
void	terminate (const edm::EventSetup &setup) override
	Call at end of job. More...
void	toTMat (AlgebraicMatrix *, TMatrixD *)
void	updateInfo (const AlgebraicMatrix &, const AlgebraicMatrix &, const AlgebraicMatrix &, std::string)
	~MuonMillepedeAlgorithm () override
	Destructor. More...
Public Member Functions inherited from AlignmentAlgorithmBase
virtual bool	addCalibrations (const Calibrations &)
bool	addCalibrations (const CalibrationsOwner &cals)
	AlignmentAlgorithmBase (const edm::ParameterSet &)
	Constructor. More...
virtual void	beginLuminosityBlock (const edm::EventSetup &setup)
	called at begin of luminosity block (no lumi block info passed yet) More...
virtual void	beginRun (const edm::Run &, const edm::EventSetup &, bool changed)
	called at begin of run More...
virtual void	endLuminosityBlock (const edm::EventSetup &setup)
	called at end of luminosity block (no lumi block info passed yet) More...
virtual void	endRun (const EndRunInfo &runInfo, const edm::EventSetup &setup)
	called at end of run - order of arguments like in EDProducer etc. More...
virtual bool	processesEvents ()
	Returns whether algorithm proccesses events in current configuration. More...
virtual bool	setParametersForRunRange (const RunRange &rr)
virtual void	startNewLoop ()
virtual bool	storeAlignments ()
	Returns whether algorithm produced results to be stored. More...
virtual bool	supportsCalibrations ()
virtual void	terminate ()
	Called at end of job (must be implemented in derived class) More...
virtual	~AlignmentAlgorithmBase ()
	Destructor. More...

Private Member Functions
void	printM (const AlgebraicMatrix &)

Private Attributes
double	chi2nCut
std::string	collec_f
int	collec_number
std::string	collec_path
edm::Service< TFileService >	fs
std::map< std::string, TH1D * >	histoMap
bool	isCollectionJob
std::map< std::string, AlgebraicMatrix * >	map_invCov
std::map< std::string, AlgebraicMatrix * >	map_N
std::map< std::string, AlgebraicMatrix * >	map_weightRes
std::string	outputCollName
double	ptCut
AlignableNavigator *	theAlignableDetAccessor
align::Alignables	theAlignables
AlignmentParameterStore *	theAlignmentParameterStore
bool	verbose

Additional Inherited Members
Public Types inherited from AlignmentAlgorithmBase
typedef std::pair< const Trajectory *, const reco::Track * >	ConstTrajTrackPair
typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection
using	RunNumber = align::RunNumber
using	RunRange = align::RunRange

Detailed Description

Definition at line 19 of file MuonMillepedeAlgorithm.h.

Constructor & Destructor Documentation

MuonMillepedeAlgorithm::MuonMillepedeAlgorithm

(

const edm::ParameterSet &

cfg

)

Constructor.

Definition at line 34 of file MuonMillepedeAlgorithm.cc.

References chi2nCut, collec_f, collec_number, collec_path, edm::ParameterSet::getParameter(), isCollectionJob, outputCollName, ptCut, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                         : AlignmentAlgorithmBase(cfg) {
  // parse parameters

  edm::LogWarning("Alignment") << "[MuonMillepedeAlgorithm] constructed.";

  collec_f = cfg.getParameter<std::string>("CollectionFile");

  isCollectionJob = cfg.getParameter<bool>("isCollectionJob");

  collec_path = cfg.getParameter<std::string>("collectionPath");

  collec_number = cfg.getParameter<int>("collectionNumber");

  outputCollName = cfg.getParameter<std::string>("outputCollName");

  ptCut = cfg.getParameter<double>("ptCut");

  chi2nCut = cfg.getParameter<double>("chi2nCut");
}

MuonMillepedeAlgorithm::~MuonMillepedeAlgorithm ( )

inlineoverride

Destructor.

Definition at line 25 of file MuonMillepedeAlgorithm.h.

References collect(), ZMuMuAnalysisNtupler_cff::eventInfo, initialize(), printM(), run(), singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, AlignmentAlgorithmBase::terminate(), toTMat(), PbPb_ZMuSkimMuonDPG_cff::tracker, and updateInfo().

{};

Member Function Documentation

void MuonMillepedeAlgorithm::collect

(

)

Definition at line 73 of file MuonMillepedeAlgorithm.cc.

References collec_f, collec_number, collec_path, genParticles_cff::map, dqmiodumpmetadata::n, summarizeEdmComparisonLogfiles::objectName, outputCollName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by terminate(), and ~MuonMillepedeAlgorithm().

                                     {
  std::map<std::string, TMatrixD *> map;

  for (int c_job = 0; c_job < collec_number; ++c_job) {
    char name_f[40];
    snprintf(name_f, sizeof(name_f), "%s_%d/%s", collec_path.c_str(), c_job, collec_f.c_str());
    TFile file_it(name_f);

    if (file_it.IsZombie())
      continue;

    TList *m_list = file_it.GetListOfKeys();
    if (m_list == nullptr) {
      return;
    }
    TKey *index = (TKey *)m_list->First();
    if (index == nullptr) {
    }
    if (index != nullptr) {
      do {
        std::string objectName(index->GetName());
        TMatrixD *mat = (TMatrixD *)index->ReadObj();
        std::map<std::string, TMatrixD *>::iterator node = map.find(objectName);
        if (node == map.end()) {
          TMatrixD *n_mat = new TMatrixD(mat->GetNrows(), mat->GetNcols());
          map.insert(make_pair(objectName, n_mat));
        }
        *(map[objectName]) += *mat;
        index = (TKey *)m_list->After(index);
      } while (index != nullptr);
    }
    file_it.Close();
  }

  TFile theFile2(outputCollName.c_str(), "recreate");
  theFile2.cd();

  std::map<std::string, TMatrixD *>::iterator m_it = map.begin();
  for (; m_it != map.end(); ++m_it) {
    if (m_it->first.find("_invCov") != std::string::npos) {
      std::string id_s = m_it->first.substr(0, m_it->first.find("_invCov"));
      std::string id_w = id_s + "_weightRes";
      std::string id_n = id_s + "_N";
      std::string cov = id_s + "_cov";
      std::string sol = id_s + "_sol";

      //Covariance calculation
      TMatrixD invMat(m_it->second->GetNrows(), m_it->second->GetNcols());
      invMat = *(m_it->second);
      invMat.Invert();
      //weighted residuals
      TMatrixD weightMat(m_it->second->GetNcols(), 1);
      weightMat = *(map[id_w]);
      //Solution of the linear system
      TMatrixD solution(m_it->second->GetNrows(), 1);
      solution = invMat * weightMat;
      //Number of Tracks
      TMatrixD n(1, 1);
      n = *(map[id_n]);

      invMat.Write(cov.c_str());
      n.Write(id_n.c_str());
      solution.Write(sol.c_str());
    }
  }
  theFile2.Write();
  theFile2.Close();
}

void MuonMillepedeAlgorithm::initialize ( const edm::EventSetup &  setup, AlignableTracker *  tracker, AlignableMuon *  muon, AlignableExtras *  extras, AlignmentParameterStore *  store  )

overridevirtual

Call at beginning of job.

Implements AlignmentAlgorithmBase.

Definition at line 56 of file MuonMillepedeAlgorithm.cc.

References AlignmentParameterStore::alignables(), theAlignableDetAccessor, theAlignables, and theAlignmentParameterStore.

Referenced by ~MuonMillepedeAlgorithm().

                                                                        {
  edm::LogWarning("Alignment") << "[MuonMillepedeAlgorithm] Initializing...";

  // accessor Det->AlignableDet
  theAlignableDetAccessor = new AlignableNavigator(tracker, muon);

  // set alignmentParameterStore
  theAlignmentParameterStore = store;

  // get alignables
  theAlignables = theAlignmentParameterStore->alignables();
}

void MuonMillepedeAlgorithm::printM ( const AlgebraicMatrix &  m )

private

Definition at line 427 of file MuonMillepedeAlgorithm.cc.

Referenced by ~MuonMillepedeAlgorithm().

                                                            {
  //for(int i = 0; i < m.num_row(); ++i)
  // {
  //  for(int j = 0; j < m.num_col(); ++j)
  //  {
  //    std::cout << m[i][j] << " ";
  //  }
  //  std::cout << std::endl;
  //}
}

void MuonMillepedeAlgorithm::run ( const edm::EventSetup &  setup, const EventInfo &  eventInfo  )

overridevirtual

Run the algorithm.

Implements AlignmentAlgorithmBase.

Definition at line 198 of file MuonMillepedeAlgorithm.cc.

References CompositeAlignmentParameters::alignableFromAlignableDet(), AlignableNavigator::alignableFromGeomDet(), AlignableNavigator::alignablesFromHits(), Alignable::alignmentParameters(), chi2n, chi2nCut, AlignableNavigator::detAndSubdetInMap(), PVValHelper::eta, reco::TrackBase::eta(), TrajectoryMeasurement::forwardPredictedState(), GeomDet::geographicalId(), TrackingRecHit::geographicalId(), isCollectionJob, TrajectoryStateOnSurface::isValid(), TrackingRecHit::isValid(), LogDebug, Trajectory::measurements(), Skims_PA_cff::name, reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfValidHits(), CalibrationSummaryClient_cfi::params, phi, reco::TrackBase::phi(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), ptCut, TrajectoryMeasurement::recHit(), AlignmentParameters::selectedDerivatives(), corrVsCorr::selection, AlignmentParameterStore::selectParameters(), AlCaHLTBitMon_QueryRunRegistry::string, theAlignableDetAccessor, theAlignmentParameterStore, HLT_2018_cff::track, PDWG_EXOHSCP_cff::tracks, AlignmentAlgorithmBase::EventInfo::trajTrackPairs(), and updateInfo().

Referenced by DTWorkflow.DTWorkflow::all(), Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), o2olib.O2OTool::execute(), and ~MuonMillepedeAlgorithm().

                                                                                       {
  if (isCollectionJob) {
    return;
  }

  // loop over tracks
  //int t_counter = 0;
  const ConstTrajTrackPairCollection &tracks = eventInfo.trajTrackPairs();
  for (ConstTrajTrackPairCollection::const_iterator it = tracks.begin(); it != tracks.end(); it++) {
    const Trajectory *traj = (*it).first;
    const reco::Track *track = (*it).second;

    float pt = track->pt();
    float chi2n = track->normalizedChi2();
#ifdef EDM_ML_DEBUG
    float eta = track->eta();
    float phi = track->phi();
    //int   ndof = track->ndof();
    int nhit = track->numberOfValidHits();

    LogDebug("Alignment") << "New track pt,eta,phi,chi2n,hits: " << pt << "," << eta << "," << phi << "," << chi2n
                          << "," << nhit;
#endif

    //Accept or not accept the track
    if (pt > ptCut && chi2n < chi2nCut) {
      std::vector<const TransientTrackingRecHit *> hitvec;
      std::vector<TrajectoryStateOnSurface> tsosvec;

      std::vector<TrajectoryMeasurement> measurements = traj->measurements();

      //In this loop the measurements and hits are extracted and put on two vectors
      for (std::vector<TrajectoryMeasurement>::iterator im = measurements.begin(); im != measurements.end(); im++) {
        TrajectoryMeasurement meas = *im;
        const TransientTrackingRecHit *hit = &(*meas.recHit());
        //We are not very strict at this point
        if (hit->isValid() && theAlignableDetAccessor->detAndSubdetInMap(hit->geographicalId())) {
          //***Forward
          const TrajectoryStateOnSurface &tsos = meas.forwardPredictedState();
          if (tsos.isValid()) {
            hitvec.push_back(hit);
            tsosvec.push_back(tsos);
          }
        }
      }

      // transform RecHit vector to AlignableDet vector
      std::vector<AlignableDetOrUnitPtr> alidetvec = theAlignableDetAccessor->alignablesFromHits(hitvec);

      // get concatenated alignment parameters for list of alignables
      CompositeAlignmentParameters aap = theAlignmentParameterStore->selectParameters(alidetvec);

      std::vector<TrajectoryStateOnSurface>::const_iterator itsos = tsosvec.begin();
      std::vector<const TransientTrackingRecHit *>::const_iterator ihit = hitvec.begin();

      //int ch_counter = 0;

      while (itsos != tsosvec.end()) {
        // get AlignableDet for this hit
        const GeomDet *det = (*ihit)->det();
        AlignableDetOrUnitPtr alidet = theAlignableDetAccessor->alignableFromGeomDet(det);

        // get relevant Alignable
        Alignable *ali = aap.alignableFromAlignableDet(alidet);

        //To be sure that the ali is not null and that it's a DT segment
        if (ali != nullptr && (*ihit)->geographicalId().subdetId() == 1) {
          DTChamberId m_Chamber(det->geographicalId());
          //Station 4 does not contain Theta SL
          if ((*ihit)->dimension() == 4 || ((*ihit)->dimension() == 2 && m_Chamber.station() == 4))
          //if((*ihit)->dimension() == 4)
          {
            edm::LogInfo("Alignment") << "Entrando";

            AlignmentParameters *params = ali->alignmentParameters();

            edm::LogInfo("Alignment") << "Entrando";
            //(dx/dz,dy/dz,x,y) for a 4DSegment
            AlgebraicVector ihit4D = (*ihit)->parameters();

            //The innerMostState always contains the Z
            //(q/pt,dx/dz,dy/dz,x,y)
            AlgebraicVector5 alivec = (*itsos).localParameters().mixedFormatVector();

            //The covariance matrix follows the sequence
            //(q/pt,dx/dz,dy/dz,x,y) but we reorder to
            //(x,y,dx/dz,dy/dz)
            AlgebraicSymMatrix55 rawCovMat = (*itsos).localError().matrix();
            AlgebraicMatrix CovMat(4, 4);
            int m_index[] = {2, 3, 0, 1};
            for (int c_ei = 0; c_ei < 4; ++c_ei) {
              for (int c_ej = 0; c_ej < 4; ++c_ej) {
                CovMat[m_index[c_ei]][m_index[c_ej]] = rawCovMat(c_ei + 1, c_ej + 1);
              }
            }

            int inv_check;
            //printM(CovMat);
            CovMat.invert(inv_check);
            if (inv_check != 0) {
              edm::LogError("Alignment") << "Covariance Matrix inversion failed";
              return;
            }

            //The order is changed to:
            // (x,0,dx/dz,0) MB4 Chamber
            // (x,y,dx/dz,dy/dz) Not MB4 Chamber
            AlgebraicMatrix residuals(4, 1);
            if (m_Chamber.station() == 4) {
              //Filling Residuals
              residuals[0][0] = ihit4D[2] - alivec[3];
              residuals[1][0] = 0.0;
              residuals[2][0] = ihit4D[0] - alivec[1];
              residuals[3][0] = 0.0;
              //The error in the Theta coord is set to infinite
              CovMat[1][0] = 0.0;
              CovMat[1][1] = 0.0;
              CovMat[1][2] = 0.0;
              CovMat[1][3] = 0.0;
              CovMat[0][1] = 0.0;
              CovMat[2][1] = 0.0;
              CovMat[3][1] = 0.0;
              CovMat[3][0] = 0.0;
              CovMat[3][2] = 0.0;
              CovMat[3][3] = 0.0;
              CovMat[0][3] = 0.0;
              CovMat[2][3] = 0.0;
            } else {
              //Filling Residuals
              residuals[0][0] = ihit4D[2] - alivec[3];
              residuals[1][0] = ihit4D[3] - alivec[4];
              residuals[2][0] = ihit4D[0] - alivec[1];
              residuals[3][0] = ihit4D[1] - alivec[2];
            }

            // Derivatives
            AlgebraicMatrix derivsAux = params->selectedDerivatives(*itsos, alidet);

            std::vector<bool> mb4_mask;
            std::vector<bool> selection;
            //To be checked
            mb4_mask.push_back(true);
            mb4_mask.push_back(false);
            mb4_mask.push_back(true);
            mb4_mask.push_back(true);
            mb4_mask.push_back(true);
            mb4_mask.push_back(false);
            selection.push_back(true);
            selection.push_back(true);
            selection.push_back(false);
            selection.push_back(false);
            selection.push_back(false);
            selection.push_back(false);
            int nAlignParam = 0;
            if (m_Chamber.station() == 4) {
              for (int icor = 0; icor < 6; ++icor) {
                if (mb4_mask[icor] && selection[icor])
                  nAlignParam++;
              }
            } else {
              nAlignParam = derivsAux.num_row();
            }

            AlgebraicMatrix derivs(nAlignParam, 4);
            if (m_Chamber.station() == 4) {
              int der_c = 0;
              for (int icor = 0; icor < 6; ++icor) {
                if (mb4_mask[icor] && selection[icor]) {
                  for (int ccor = 0; ccor < 4; ++ccor) {
                    derivs[der_c][ccor] = derivsAux[icor][ccor];
                    ++der_c;
                  }
                }
              }
            } else {
              derivs = derivsAux;
            }

            //for(int co = 0; co < derivs.num_row(); ++co)
            //{
            //  for(int ci = 0; ci < derivs.num_col(); ++ci)
            //  {
            //     edm::LogInfo("Alignment") << "Derivatives: " << co << " " << ci << " " << derivs[co][ci] << " ";
            //  }
            //}

            AlgebraicMatrix derivsT = derivs.T();
            AlgebraicMatrix invCov = derivs * CovMat * derivsT;
            AlgebraicMatrix weightRes = derivs * CovMat * residuals;

            //this->printM(derivs);
            //this->printM(CovMat);
            //this->printM(residuals);

            char name[40];
            snprintf(
                name, sizeof(name), "Chamber_%d_%d_%d", m_Chamber.wheel(), m_Chamber.station(), m_Chamber.sector());
            std::string chamId(name);
            //MB4 need a special treatment
            /*AlgebraicMatrix invCovMB4(2,2);
            AlgebraicMatrix weightResMB4(2,1); 
            if( m_Chamber.station() == 4 )
            { 
              int m_index_2[] = {0,2};
              for(int c_i = 0; c_i < 2; ++c_i)
              {
            weightResMB4[c_i][0] = weightRes[m_index_2[c_i]][0];
            for(int c_j = 0; c_j < 2; ++c_j)
            {
              invCovMB4[c_i][c_j] = invCov[m_index_2[c_i]][m_index_2[c_j]];
            }  
              }
              this->updateInfo(invCovMB4, weightResMB4, residuals, chamId); 
            }
            else
            {
              this->updateInfo(invCov, weightRes, residuals, chamId); 
            }*/
            this->updateInfo(invCov, weightRes, residuals, chamId);
          }
        }
        itsos++;
        ihit++;
      }
    }
  }  // end of track loop
}

void MuonMillepedeAlgorithm::terminate ( const edm::EventSetup &  setup )

overridevirtual

Call at end of job.

Implements AlignmentAlgorithmBase.

Definition at line 144 of file MuonMillepedeAlgorithm.cc.

References AlignmentParameterStore::applyParameters(), collec_f, collect(), isCollectionJob, map_invCov, map_N, map_weightRes, theAlignables, theAlignmentParameterStore, interactiveExample::theFile, and toTMat().

                                                                  {
  if (isCollectionJob) {
    this->collect();
    return;
  }

  edm::LogWarning("Alignment") << "[MuonMillepedeAlgorithm] Terminating";

  // iterate over alignment parameters
  for (const auto &ali : theAlignables) {
    // Alignment parameters
    // AlignmentParameters* par = ali->alignmentParameters();
    edm::LogInfo("Alignment") << "now apply params";
    theAlignmentParameterStore->applyParameters(ali);
    // set these parameters 'valid'
    ali->alignmentParameters()->setValid(true);
  }

  edm::LogWarning("Alignment") << "[MuonMillepedeAlgorithm] Writing aligned parameters to file: "
                               << theAlignables.size();

  TFile *theFile = new TFile(collec_f.c_str(), "recreate");
  theFile->cd();
  std::map<std::string, AlgebraicMatrix *>::iterator invCov_it = map_invCov.begin();
  std::map<std::string, AlgebraicMatrix *>::iterator weightRes_it = map_weightRes.begin();
  std::map<std::string, AlgebraicMatrix *>::iterator n_it = map_N.begin();
  for (; n_it != map_N.end(); ++invCov_it, ++weightRes_it, ++n_it) {
    TMatrixD tmat_invcov(0, 0);
    this->toTMat(invCov_it->second, &tmat_invcov);
    TMatrixD tmat_weightres(0, 0);
    this->toTMat(weightRes_it->second, &tmat_weightres);
    TMatrixD tmat_n(0, 0);
    this->toTMat(n_it->second, &tmat_n);

    tmat_invcov.Write(invCov_it->first.c_str());
    tmat_weightres.Write(weightRes_it->first.c_str());
    tmat_n.Write(n_it->first.c_str());
  }

  theFile->Write();
  theFile->Close();
}

void MuonMillepedeAlgorithm::toTMat	(	AlgebraicMatrix *	am_mat,
		TMatrixD *	tmat_mat
	)

Definition at line 187 of file MuonMillepedeAlgorithm.cc.

Referenced by terminate(), and ~MuonMillepedeAlgorithm().

                                                                               {
  tmat_mat->ResizeTo(am_mat->num_row(), am_mat->num_col());
  for (int c_i = 0; c_i < am_mat->num_row(); ++c_i) {
    for (int c_j = 0; c_j < am_mat->num_col(); ++c_j) {
      (*tmat_mat)(c_i, c_j) = (*am_mat)[c_i][c_j];
    }
  }
}

void MuonMillepedeAlgorithm::updateInfo	(	const AlgebraicMatrix &	m_invCov,
		const AlgebraicMatrix &	m_weightRes,
		const AlgebraicMatrix &	m_res,
		std::string	id
	)

Definition at line 438 of file MuonMillepedeAlgorithm.cc.

References DEFINE_EDM_PLUGIN, fs, timingPdfMaker::histo, histoMap, versionedElectronIDProducer_cfi::idName, TFileService::make(), map_invCov, map_N, map_weightRes, Skims_PA_cff::name, FastTimerService_cff::range, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by run(), and ~MuonMillepedeAlgorithm().

                                                      {
  std::string id_invCov = id + "_invCov";
  std::string id_weightRes = id + "_weightRes";
  std::string id_n = id + "_N";

  edm::LogInfo("Alignment") << "Entrando";

  std::map<std::string, AlgebraicMatrix *>::iterator node = map_invCov.find(id_invCov);
  if (node == map_invCov.end()) {
    AlgebraicMatrix *f_invCov = new AlgebraicMatrix(m_invCov.num_row(), m_invCov.num_col());
    AlgebraicMatrix *f_weightRes = new AlgebraicMatrix(m_weightRes.num_row(), m_weightRes.num_col());
    AlgebraicMatrix *f_n = new AlgebraicMatrix(1, 1);

    map_invCov.insert(make_pair(id_invCov, f_invCov));
    map_weightRes.insert(make_pair(id_weightRes, f_weightRes));
    map_N.insert(make_pair(id_n, f_n));

    for (int iCount = 0; iCount < 4; ++iCount) {
      char name[40];
      snprintf(name, sizeof(name), "%s_var_%d", id.c_str(), iCount);
      std::string idName(name);
      float range = 5.0;
      //if( iCount == 0 || iCount == 1 ) {
      //  range = 0.01;
      //}
      TH1D *histo = fs->make<TH1D>(idName.c_str(), idName.c_str(), 200, -range, range);
      histoMap.insert(make_pair(idName, histo));
    }
  }

  *map_invCov[id_invCov] = *map_invCov[id_invCov] + m_invCov;
  *map_weightRes[id_weightRes] = *map_weightRes[id_weightRes] + m_weightRes;
  (*map_N[id_n])[0][0]++;

  for (int iCount = 0; iCount < 4; ++iCount) {
    char name[40];
    snprintf(name, sizeof(name), "%s_var_%d", id.c_str(), iCount);
    std::string idName(name);
    histoMap[idName]->Fill(m_res[iCount][0]);
  }
}

Member Data Documentation

double MuonMillepedeAlgorithm::chi2nCut

private

Definition at line 65 of file MuonMillepedeAlgorithm.h.

Referenced by MuonMillepedeAlgorithm(), and run().

std::string MuonMillepedeAlgorithm::collec_f

private

Definition at line 70 of file MuonMillepedeAlgorithm.h.

Referenced by collect(), MuonMillepedeAlgorithm(), and terminate().

int MuonMillepedeAlgorithm::collec_number

private

Definition at line 74 of file MuonMillepedeAlgorithm.h.

Referenced by collect(), and MuonMillepedeAlgorithm().

std::string MuonMillepedeAlgorithm::collec_path

private

Definition at line 73 of file MuonMillepedeAlgorithm.h.

Referenced by collect(), and MuonMillepedeAlgorithm().

edm::Service<TFileService> MuonMillepedeAlgorithm::fs

private

Definition at line 68 of file MuonMillepedeAlgorithm.h.

Referenced by updateInfo().

std::map<std::string, TH1D*> MuonMillepedeAlgorithm::histoMap

private

Definition at line 59 of file MuonMillepedeAlgorithm.h.

Referenced by updateInfo().

bool MuonMillepedeAlgorithm::isCollectionJob

private

Definition at line 72 of file MuonMillepedeAlgorithm.h.

Referenced by MuonMillepedeAlgorithm(), run(), and terminate().

std::map<std::string, AlgebraicMatrix*> MuonMillepedeAlgorithm::map_invCov

private

Definition at line 61 of file MuonMillepedeAlgorithm.h.

Referenced by terminate(), and updateInfo().

std::map<std::string, AlgebraicMatrix*> MuonMillepedeAlgorithm::map_N

private

Definition at line 63 of file MuonMillepedeAlgorithm.h.

Referenced by terminate(), and updateInfo().

std::map<std::string, AlgebraicMatrix*> MuonMillepedeAlgorithm::map_weightRes

private

Definition at line 62 of file MuonMillepedeAlgorithm.h.

Referenced by terminate(), and updateInfo().

std::string MuonMillepedeAlgorithm::outputCollName

private

Definition at line 71 of file MuonMillepedeAlgorithm.h.

Referenced by collect(), and MuonMillepedeAlgorithm().

double MuonMillepedeAlgorithm::ptCut

private

Definition at line 65 of file MuonMillepedeAlgorithm.h.

Referenced by MuonMillepedeAlgorithm(), and run().

AlignableNavigator* MuonMillepedeAlgorithm::theAlignableDetAccessor

private

Definition at line 53 of file MuonMillepedeAlgorithm.h.

Referenced by initialize(), and run().

align::Alignables MuonMillepedeAlgorithm::theAlignables

private

Definition at line 52 of file MuonMillepedeAlgorithm.h.

Referenced by initialize(), and terminate().

AlignmentParameterStore* MuonMillepedeAlgorithm::theAlignmentParameterStore

private

Definition at line 51 of file MuonMillepedeAlgorithm.h.

Referenced by initialize(), run(), and terminate().

bool MuonMillepedeAlgorithm::verbose

private

Definition at line 56 of file MuonMillepedeAlgorithm.h.

Referenced by python.diff_provenance.difference::list_diff(), python.diffProv.difference::list_diff(), python.diff_provenance.difference::module_diff(), python.diffProv.difference::module_diff(), python.diff_provenance.difference::onefilemodules(), python.diffProv.difference::onefilemodules(), core.TriggerMatchAnalyzer.TriggerMatchAnalyzer::process(), core.SkimAnalyzerCount.SkimAnalyzerCount::process(), objects.VertexAnalyzer.VertexAnalyzer::process(), and confdbOfflineConverter.OfflineConverter::query().