MuonDTLocalMillepedeAlgorithm Class Reference

#include <MuonDTLocalMillepedeAlgorithm.h>

Inheritance diagram for MuonDTLocalMillepedeAlgorithm:

Classes
struct	Info1D

Public Member Functions
void	initialize (const edm::EventSetup &setup, AlignableTracker *tracker, AlignableMuon *muon, AlignmentParameterStore *store)
	Call at beginning of job. More...
	MuonDTLocalMillepedeAlgorithm (const edm::ParameterSet &cfg)
	Constructor. More...
void	run (const edm::EventSetup &setup, const EventInfo &eventInfo)
	Run the algorithm on trajectories and tracks. More...
void	terminate (void)
	Call at end of job. More...
	~MuonDTLocalMillepedeAlgorithm ()
	Destructor. More...
Public Member Functions inherited from AlignmentAlgorithmBase
virtual bool	addCalibrations (const Calibrations &)
	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 void	initialize (const edm::EventSetup &setup, AlignableTracker *tracker, AlignableMuon *muon, AlignableExtras *extras, AlignmentParameterStore *store)=0
	Call at beginning of job (must be implemented in derived class) 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 (const edm::EventSetup &iSetup)=0
	Call at end of each loop (must be implemented in derived class) More...
virtual	~AlignmentAlgorithmBase ()
	Destructor. More...

Private Member Functions
bool	build4DSegments ()
void	setBranchTrees ()

Private Attributes
float	charge
edm::InputTag	consTraj
float	dxdzSl [5]
float	dxdzSlSL1 [5]
float	dxdzSlSL3 [5]
float	dydzSl [5]
float	edxdzSl [5]
float	edxdzSlSL1 [5]
float	edxdzSlSL3 [5]
float	edydzSl [5]
float	eta
float	ex [5][14]
float	excp [5][14]
float	exdxdzSl [5]
float	exdxdzSlSL1 [5]
float	exdxdzSlSL3 [5]
float	exSl [5]
float	exSlSL1 [5]
float	exSlSL3 [5]
float	eycp [5][14]
float	eydydzSl [5]
float	eySl [5]
TFile *	f
edm::Service< TFileService >	fs
edm::InputTag	globalTracks
int	la [5][14]
float	meandxdz [5][4][14]
float	meandydz [5][4][14]
float	meanx [5][4][14]
float	meany [5][4][14]
Info1D	myTrack1D
int	nhits [5]
int	nMtxSection
int	nphihits [5]
float	nPhihits
int	nseg
int	nthetahits [5]
float	nThetahits
std::string	ntuplePath
int	numberOfRootFiles
float	numberOfSigmasDXDZ
float	numberOfSigmasDYDZ
float	numberOfSigmasX
float	numberOfSigmasY
float	p
float	phi
float	pt
float	ptMax
float	ptMin
float	sigmadxdz [5][4][14]
float	sigmadydz [5][4][14]
float	sigmax [5][4][14]
float	sigmay [5][4][14]
int	sl [5][14]
int	sr [5]
int	st [5]
TChain *	tali
AlignableNavigator *	theAlignableDetAccessor
std::vector< Alignable * >	theAlignables
AlignmentParameterStore *	theAlignmentParameterStore
TTree *	ttreeOutput
int	wh [5]
int	workingmode
float	xc [5][14]
float	xcp [5][14]
float	xSl [5]
float	xSL1SL3 [5]
float	xSL3SL1 [5]
float	xSlSL1 [5]
float	xSlSL3 [5]
float	yc [5][14]
float	ycp [5][14]
float	ySl [5]
float	zc [5][14]

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 30 of file MuonDTLocalMillepedeAlgorithm.h.

Constructor & Destructor Documentation

MuonDTLocalMillepedeAlgorithm::MuonDTLocalMillepedeAlgorithm

(

const edm::ParameterSet &

cfg

)

Constructor.

Definition at line 41 of file MuonDTLocalMillepedeAlgorithm.cc.

References f, edm::ParameterSet::getParameter(), nMtxSection, nPhihits, nThetahits, ntuplePath, numberOfRootFiles, numberOfSigmasDXDZ, numberOfSigmasDYDZ, numberOfSigmasX, numberOfSigmasY, ptMax, ptMin, setBranchTrees(), AlCaHLTBitMon_QueryRunRegistry::string, and workingmode.

                                                                                      :
  AlignmentAlgorithmBase( cfg )
{
  
  edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] constructed.";

  //Parse parameters. In the future this section should be completed with more options
  ntuplePath = cfg.getParameter<std::string>( "ntuplePath" );
  numberOfRootFiles = cfg.getParameter<int>( "numberOfRootFiles" ); 
  ptMax = cfg.getParameter<double>( "ptMax" );
  ptMin = cfg.getParameter<double>( "ptMin" );
  numberOfSigmasX = cfg.getParameter<double>( "numberOfSigmasX" );
  numberOfSigmasDXDZ = cfg.getParameter<double>( "numberOfSigmasDXDZ" );
  numberOfSigmasY = cfg.getParameter<double>( "numberOfSigmasY" );
  numberOfSigmasDYDZ = cfg.getParameter<double>( "numberOfSigmasDYDZ" );
  nPhihits = cfg.getParameter<double>( "nPhihits" );
  nThetahits = cfg.getParameter<double>( "nThetahits" );
  workingmode = cfg.getParameter<int>( "workingMode" );
  nMtxSection = cfg.getParameter<int>( "nMtxSection" );

 
  //The algorithm has three working modes:
  //0.- aligment information is extracted from the events and stored in root files
  //1.- The SLtoSl algorithm
  //2.- The local MuonMillepede algorithm
  if(workingmode == 0) {
    edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] Running on production mode."; 
    char nameOfFile[200];
    snprintf(nameOfFile, sizeof(nameOfFile), "%s/MyNtupleResidual.root", ntuplePath.c_str());
    f = new TFile(nameOfFile, "RECREATE");
    f->cd();
    setBranchTrees();
  } else if (workingmode == 1) {
    edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] Running SLToSL algorithm."; 
  } else {
    edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] Running Local Millepede algorithm."; 
  }

}

MuonDTLocalMillepedeAlgorithm::~MuonDTLocalMillepedeAlgorithm ( )

inline

Destructor.

Definition at line 39 of file MuonDTLocalMillepedeAlgorithm.h.

References build4DSegments(), dumpTauVariables_cfi::eventInfo, initialize(), run(), setBranchTrees(), GeneralSetup::setup(), terminate(), and mixOne_simraw_on_sim_cfi::tracker.

{};

Member Function Documentation

bool MuonDTLocalMillepedeAlgorithm::build4DSegments ( )

private

Definition at line 214 of file MuonDTLocalMillepedeAlgorithm.cc.

References counter, dxdzSl, dxdzSlSL1, dxdzSlSL3, dydzSl, edxdzSl, edxdzSlSL1, edxdzSlSL3, edydzSl, MuonDTLocalMillepedeAlgorithm::Info1D::erx, ex, excp, exdxdzSl, exdxdzSlSL1, exdxdzSlSL3, exSl, exSlSL1, exSlSL3, eycp, eydydzSl, eySl, gen::k, MuonDTLocalMillepedeAlgorithm::Info1D::la, la, MAX_HIT_CHAM, MAX_SEGMENT, myTrack1D, MuonDTLocalMillepedeAlgorithm::Info1D::nhits, nhits, nphihits, nPhihits, nseg, nthetahits, nThetahits, alignCSCRings::s, MuonDTLocalMillepedeAlgorithm::Info1D::sl, sl, MuonDTLocalMillepedeAlgorithm::Info1D::sr, sr, MuonDTLocalMillepedeAlgorithm::Info1D::st, st, MuonDTLocalMillepedeAlgorithm::Info1D::wh, wh, MuonDTLocalMillepedeAlgorithm::Info1D::xc, xc, xcp, xSl, xSL1SL3, xSL3SL1, xSlSL1, xSlSL3, MuonDTLocalMillepedeAlgorithm::Info1D::yc, yc, ycp, ySl, MuonDTLocalMillepedeAlgorithm::Info1D::zc, and zc.

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

                                                    {

  bool saveThis = false;
  
  //Set to 0
  int id[20][5];
  int numlayer[20][12];
  for(int s = 0; s < 20; ++s) {
    for(int k = 0; k < 5; ++k) id[s][k] = 0;
    for(int k = 0; k < 12; ++k) numlayer[s][k] = 0;
  }

  
  int nChambers = 0;
  for(int counter = 0; counter < myTrack1D.nhits; ++counter) {
    bool isNew = true;
    for(int counterCham = 0; counterCham < nChambers; counterCham++) {
      if(myTrack1D.wh[counter] == id[counterCham][0] &&
     myTrack1D.st[counter] == id[counterCham][1] &&
         myTrack1D.sr[counter] == id[counterCham][2]) {
    if(myTrack1D.sl[counter] == 2) { 
      id[counterCham][4]++;
    } else {
      id[counterCham][3]++;
    }
    for (int ila = 1; ila<=4; ila++)
      if (myTrack1D.la[counter]==ila) {
        int jla = (myTrack1D.sl[counter]-1)*4 + ila -1;
        numlayer[counterCham][jla]++;
      }
    isNew = false;
      } 
    }
    if(isNew) {
      id[nChambers][0] = myTrack1D.wh[counter];
      id[nChambers][1] = myTrack1D.st[counter];
      id[nChambers][2] = myTrack1D.sr[counter];
      if(myTrack1D.sl[counter] == 2) {
        id[nChambers][4]++;
      } else {
        id[nChambers][3]++;
      }
      for (int ila = 1; ila<=4; ila++)
    if (myTrack1D.la[counter]==ila) {
      int jla = (myTrack1D.sl[counter]-1)*4 + ila -1;
      numlayer[nChambers][jla]++;
    }
      nChambers++;
    }
  }
  
  for (int iseg = 0; iseg<MAX_SEGMENT; iseg++) 
    for (int ihit = 0; ihit<MAX_HIT_CHAM; ihit++) {
      xc[iseg][ihit] = -250.;
      yc[iseg][ihit] = -250.;
      zc[iseg][ihit] = -250.;
      ex[iseg][ihit] = -250.;
      xcp[iseg][ihit] = -250.;
      ycp[iseg][ihit] = -250.;
      excp[iseg][ihit] = -250.;
      eycp[iseg][ihit] = -250.;
      sl[iseg][ihit] = 0;
      la[iseg][ihit] = 0;
    }

  nseg = 0;
  for(int counter = 0; counter < nChambers; ++counter) {
    
    bool GoodPhiChamber = true, GoodThetaChamber = true;
    for (int ila = 1; ila<=12; ila++) {
      if (numlayer[counter][ila-1]!=1 && (ila<5 || ila>8)) GoodPhiChamber = false;
      if (numlayer[counter][ila-1]!=1 && (ila<9 || ila>4) && id[counter][1]!=4) GoodThetaChamber = false;
    }

    if(id[counter][3] >= nPhihits && (id[counter][4] >= nThetahits || id[counter][1] == 4) &&
       GoodPhiChamber && GoodThetaChamber) {

      TMatrixD phiProjection(2,2);
      TMatrixD thetaProjection(2,2);
      TMatrixD bphiProjection(2,1);
      TMatrixD bthetaProjection(2,1);
      
      TMatrixD phiProjectionSL1(2,2);
      TMatrixD bphiProjectionSL1(2,1);
      TMatrixD phiProjectionSL3(2,2);
      TMatrixD bphiProjectionSL3(2,1);
     
      float SL1_z_ave = 0;
      float SL3_z_ave = 0;

      int numh1 = 0, numh2 = 0, numh3 = 0;
      for(int counterH = 0; counterH < myTrack1D.nhits; ++counterH) {
        if(myTrack1D.wh[counterH] == id[counter][0] && myTrack1D.st[counterH] == id[counter][1] &&
           myTrack1D.sr[counterH] == id[counter][2]) {
      if(myTrack1D.sl[counterH] == 2) {
        numh2++;
            thetaProjection(0,0) += 1.0/myTrack1D.erx[counterH];
            thetaProjection(0,1) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            thetaProjection(1,0) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            thetaProjection(1,1) += myTrack1D.zc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            bthetaProjection(0,0) += myTrack1D.yc[counterH]/myTrack1D.erx[counterH];
            bthetaProjection(1,0) += myTrack1D.yc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
          } else {
            phiProjection(0,0) += 1.0/myTrack1D.erx[counterH];
            phiProjection(0,1) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            phiProjection(1,0) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            phiProjection(1,1) += myTrack1D.zc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
            bphiProjection(0,0) += myTrack1D.xc[counterH]/myTrack1D.erx[counterH];
            bphiProjection(1,0) += myTrack1D.xc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
        if(myTrack1D.sl[counterH] == 1) {
          numh1++;
              phiProjectionSL1(0,0) += 1.0/myTrack1D.erx[counterH];
              phiProjectionSL1(0,1) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              phiProjectionSL1(1,0) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              phiProjectionSL1(1,1) += myTrack1D.zc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              bphiProjectionSL1(0,0) += myTrack1D.xc[counterH]/myTrack1D.erx[counterH];
              bphiProjectionSL1(1,0) += myTrack1D.xc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              SL1_z_ave += myTrack1D.zc[counterH];
            } else {
          numh3++;
              phiProjectionSL3(0,0) += 1.0/myTrack1D.erx[counterH];
              phiProjectionSL3(0,1) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              phiProjectionSL3(1,0) += myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              phiProjectionSL3(1,1) += myTrack1D.zc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              bphiProjectionSL3(0,0) += myTrack1D.xc[counterH]/myTrack1D.erx[counterH];
              bphiProjectionSL3(1,0) += myTrack1D.xc[counterH]*myTrack1D.zc[counterH]/myTrack1D.erx[counterH];
              SL3_z_ave += myTrack1D.zc[counterH];
            } 
          }
    }
      }

      SL1_z_ave /= 4.0;
      SL3_z_ave /= 4.0;
      
      if (phiProjection(0,0) != 0 && phiProjectionSL1(0,0) != 0 && phiProjectionSL3(0,0) != 0 && 
      (thetaProjection(0,0) != 0 || id[counter][1] == 4)) {
    
    wh[nseg] = id[counter][0];
    st[nseg] = id[counter][1];
    sr[nseg] = id[counter][2];
    
    if(thetaProjection(0,0) != 0 && id[counter][1] != 4) { // Already asked (almost)
      thetaProjection.Invert();
      TMatrixD solution = thetaProjection*bthetaProjection;
      ySl[nseg] = solution(0,0);
      dydzSl[nseg] = solution(1,0);
      eySl[nseg] = thetaProjection(0,0);
      edydzSl[nseg] = thetaProjection(1,1);
      eydydzSl[nseg] = thetaProjection(0,1);
    }
    phiProjection.Invert();
    phiProjectionSL1.Invert();
    phiProjectionSL3.Invert();
    TMatrixD solution = phiProjection*bphiProjection;
    TMatrixD solutionSL1 = phiProjectionSL1*bphiProjectionSL1;
    TMatrixD solutionSL3 = phiProjectionSL3*bphiProjectionSL3;
    xSl[nseg] = solution(0,0);
    dxdzSl[nseg] = solution(1,0);
    exSl[nseg] = phiProjection(0,0);
    edxdzSl[nseg] = phiProjection(1,1);
    exdxdzSl[nseg] = phiProjection(0,0);
    xSlSL1[nseg] = solutionSL1(0,0);
    dxdzSlSL1[nseg] = solutionSL1(1,0);
    exSlSL1[nseg] = phiProjectionSL1(0,0);
    edxdzSlSL1[nseg] = phiProjectionSL1(1,1);
    exdxdzSlSL1[nseg] = phiProjectionSL1(0,0);
        xSL1SL3[nseg] = solutionSL1(0,0) + SL3_z_ave * solutionSL1(1,0);
    xSlSL3[nseg] = solutionSL3(0,0);
    dxdzSlSL3[nseg] = solutionSL3(1,0);
    exSlSL3[nseg] = phiProjectionSL3(0,0);
    edxdzSlSL3[nseg] = phiProjectionSL3(1,1);
    exdxdzSlSL3[nseg] = phiProjectionSL3(0,0);
        xSL3SL1[nseg] = solutionSL3(0,0) + SL1_z_ave * solutionSL3(1,0);
        int hitcounter = 0;
        for(int counterH = 0; counterH < myTrack1D.nhits; ++counterH) {
          if(myTrack1D.wh[counterH] == wh[nseg] && myTrack1D.st[counterH] == st[nseg] &&
             myTrack1D.sr[counterH] == sr[nseg]) {
            xc[nseg][hitcounter] = myTrack1D.xc[counterH];
            yc[nseg][hitcounter] = myTrack1D.yc[counterH];
            zc[nseg][hitcounter] = myTrack1D.zc[counterH];
            ex[nseg][hitcounter] = myTrack1D.erx[counterH];
            xcp[nseg][hitcounter] = xSl[nseg]+dxdzSl[nseg]*myTrack1D.zc[counterH];
            ycp[nseg][hitcounter] = ySl[nseg]+dydzSl[nseg]*myTrack1D.zc[counterH];
            excp[nseg][hitcounter] = exSl[nseg]*exSl[nseg]+ (edxdzSl[nseg]*edxdzSl[nseg])*myTrack1D.zc[counterH];
            eycp[nseg][hitcounter] = eySl[nseg]*eySl[nseg]+ (edydzSl[nseg]*edydzSl[nseg])*myTrack1D.zc[counterH];
            sl[nseg][hitcounter] = myTrack1D.sl[counterH];
            la[nseg][hitcounter] = myTrack1D.la[counterH];
            saveThis = true;
            hitcounter++;
          }
        }
    nphihits[nseg] = id[counter][3];
    nthetahits[nseg] = id[counter][4];
    nhits[nseg] = hitcounter;
    nseg++;
      }
    }
  }
  return saveThis;
}

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

Call at beginning of job.

Definition at line 86 of file MuonDTLocalMillepedeAlgorithm.cc.

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

Referenced by ~MuonDTLocalMillepedeAlgorithm().

{
  
  // accessor Det->AlignableDet
  if ( !muon )
    theAlignableDetAccessor = new AlignableNavigator(tracker);
  else if ( !tracker )
    theAlignableDetAccessor = new AlignableNavigator(muon);
  else 
    theAlignableDetAccessor = new AlignableNavigator(tracker,muon);
  
  // set alignmentParameterStore
  theAlignmentParameterStore=store;
  
  // get alignables
  theAlignables = theAlignmentParameterStore->alignables();
  
}

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

virtual

Run the algorithm on trajectories and tracks.

Implements AlignmentAlgorithmBase.

Definition at line 132 of file MuonDTLocalMillepedeAlgorithm.cc.

References build4DSegments(), charge, reco::TrackBase::charge(), DetId::det(), TrackingRecHit::det(), MuonDTLocalMillepedeAlgorithm::Info1D::erx, eta, reco::TrackBase::eta(), GeomDet::geographicalId(), TrackingRecHit::isValid(), MuonDTLocalMillepedeAlgorithm::Info1D::la, Trajectory::measurements(), myTrack1D, MuonDTLocalMillepedeAlgorithm::Info1D::nhits, p, reco::TrackBase::p(), phi, reco::TrackBase::phi(), pt, reco::TrackBase::pt(), ptMax, DetId::rawId(), TrajectoryMeasurement::recHit(), MuonDTLocalMillepedeAlgorithm::Info1D::sl, MuonDTLocalMillepedeAlgorithm::Info1D::sr, MuonDTLocalMillepedeAlgorithm::Info1D::st, DetId::subdetId(), theAlignableDetAccessor, GeomDet::toGlobal(), HiIsolationCommonParameters_cff::track, l1t::tracks, AlignmentAlgorithmBase::EventInfo::trajTrackPairs(), ttreeOutput, MuonDTLocalMillepedeAlgorithm::Info1D::wh, workingmode, PV3DBase< T, PVType, FrameType >::x(), MuonDTLocalMillepedeAlgorithm::Info1D::xc, PV3DBase< T, PVType, FrameType >::y(), MuonDTLocalMillepedeAlgorithm::Info1D::yc, PV3DBase< T, PVType, FrameType >::z(), and MuonDTLocalMillepedeAlgorithm::Info1D::zc.

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

{

  //Only important in the production mode
  if(workingmode != 0) return;
 
  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;
    
    p    = track->p();
    pt    = track->pt();
    eta   = track->eta();
    phi   = track->phi();
    charge = track->charge();
 

    if(pt < ptMin || pt > ptMax) continue;
    
    vector<const TransientTrackingRecHit*> hitvec;
    vector<TrajectoryMeasurement> measurements = traj->measurements();

    //In this loop the measurements and hits are extracted and put into two vectors 
    int ch_muons = 0;
    for (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()) {
        if(hit->det()->geographicalId().det() == 2 && hit->det()->geographicalId().subdetId() == 1) {
          hitvec.push_back(hit);
          ch_muons++;
    } 
      }
    }


    vector<const TransientTrackingRecHit*>::const_iterator ihit=hitvec.begin();
    //Information is stored temporally in the myTrack1D object, which is analyzed
    //in the build4DSegments method in order to associate hits to segments. 
    int ch_counter = 0;
    while (ihit != hitvec.end()) 
      {
    const GeomDet* det=(*ihit)->det();
        if(det->geographicalId().det() == 2) {
      if(det->geographicalId().subdetId() == 1) {
            DTLayerId mLayer(det->geographicalId().rawId());
            DTChamberId mChamber(mLayer.wheel(), mLayer.station(), mLayer.sector());
            AlignableDet *aliDet = theAlignableDetAccessor->alignableDetFromDetId(mChamber);
        myTrack1D.wh[ch_counter] = mLayer.wheel();
            myTrack1D.st[ch_counter] = mLayer.station();
            myTrack1D.sr[ch_counter] = mLayer.sector();
            myTrack1D.sl[ch_counter] = mLayer.superlayer();
            myTrack1D.la[ch_counter] = mLayer.layer();
            myTrack1D.erx[ch_counter] = (*ihit)->localPositionError().xx();
            align::GlobalPoint globhit = det->toGlobal((*ihit)->localPosition());
            align::LocalPoint seghit = aliDet->surface().toLocal(globhit);
            myTrack1D.xc[ch_counter] = seghit.x();
        myTrack1D.yc[ch_counter] = seghit.y();
        myTrack1D.zc[ch_counter] = seghit.z();
        ch_counter++;
      }
        }
        ihit++;
      }
    myTrack1D.nhits = ch_counter;
    if(build4DSegments()) ttreeOutput->Fill();
  }
  
}

void MuonDTLocalMillepedeAlgorithm::setBranchTrees ( )

private

Definition at line 419 of file MuonDTLocalMillepedeAlgorithm.cc.

References charge, DEFINE_EDM_PLUGIN, dxdzSl, dxdzSlSL1, dxdzSlSL3, dydzSl, edxdzSl, edxdzSlSL1, edxdzSlSL3, edydzSl, eta, ex, excp, exSl, exSlSL1, exSlSL3, eycp, eydydzSl, eySl, la, nhits, nphihits, nseg, nthetahits, p, phi, pt, sl, sr, st, ttreeOutput, wh, xc, xcp, xSl, xSL1SL3, xSL3SL1, xSlSL1, xSlSL3, yc, ycp, ySl, and zc.

Referenced by MuonDTLocalMillepedeAlgorithm(), and ~MuonDTLocalMillepedeAlgorithm().

                                                   {

  ttreeOutput = new TTree("InfoTuple", "InfoTuple");
  
  ttreeOutput->Branch("p", &p, "p/F");
  ttreeOutput->Branch("pt", &pt, "pt/F");
  ttreeOutput->Branch("eta", &eta, "eta/F");
  ttreeOutput->Branch("phi", &phi, "phi/F");
  ttreeOutput->Branch("charge", &charge, "charge/F");
  ttreeOutput->Branch("nseg", &nseg, "nseg/I");
  ttreeOutput->Branch("nphihits", nphihits, "nphihits[nseg]/I");
  ttreeOutput->Branch("nthetahits", nthetahits, "nthetahits[nseg]/I");
  ttreeOutput->Branch("nhits", nhits, "nhits[nseg]/I");
  ttreeOutput->Branch("xSl", xSl, "xSl[nseg]/F");
  ttreeOutput->Branch("dxdzSl", dxdzSl, "dxdzSl[nseg]/F");
  ttreeOutput->Branch("exSl", exSl, "exSl[nseg]/F");
  ttreeOutput->Branch("edxdzSl", edxdzSl, "edxdzSl[nseg]/F");
  ttreeOutput->Branch("exdxdzSl", edxdzSl, "exdxdzSl[nseg]/F");
  ttreeOutput->Branch("ySl", ySl, "ySl[nseg]/F");
  ttreeOutput->Branch("dydzSl", dydzSl, "dydzSl[nseg]/F");
  ttreeOutput->Branch("eySl", eySl, "eySl[nseg]/F");
  ttreeOutput->Branch("edydzSl", edydzSl, "edydzSl[nseg]/F");
  ttreeOutput->Branch("eydydzSl", eydydzSl, "eydydzSl[nseg]/F");
  ttreeOutput->Branch("xSlSL1", xSlSL1, "xSlSL1[nseg]/F");
  ttreeOutput->Branch("dxdzSlSL1", dxdzSlSL1, "dxdzSlSL1[nseg]/F");
  ttreeOutput->Branch("exSlSL1", exSlSL1, "exSlSL1[nseg]/F");
  ttreeOutput->Branch("edxdzSlSL1", edxdzSlSL1, "edxdzSlSL1[nseg]/F");
  ttreeOutput->Branch("xSL1SL3", xSL1SL3, "xSL1SL3[nseg]/F");
  ttreeOutput->Branch("xSlSL3", xSlSL3, "xSlSL3[nseg]/F");
  ttreeOutput->Branch("dxdzSlSL3", dxdzSlSL3, "dxdzSlSL3[nseg]/F");
  ttreeOutput->Branch("exSlSL3", exSlSL3, "exSlSL3[nseg]/F");
  ttreeOutput->Branch("edxdzSlSL3", edxdzSlSL3, "edxdzSlSL3[nseg]/F");
  ttreeOutput->Branch("xSL3SL1", xSL3SL1, "xSL3SL1[nseg]/F");
  ttreeOutput->Branch("xc", xc, "xc[nseg][14]/F");
  ttreeOutput->Branch("yc", yc, "yc[nseg][14]/F");
  ttreeOutput->Branch("zc", zc, "zc[nseg][14]/F");
  ttreeOutput->Branch("ex", ex, "ex[nseg][14]/F");
  ttreeOutput->Branch("xcp", xcp, "xcp[nseg][14]/F");
  ttreeOutput->Branch("ycp", ycp, "ycp[nseg][14]/F");
  ttreeOutput->Branch("excp", excp, "excp[nseg][14]/F");
  ttreeOutput->Branch("eycp", eycp, "eycp[nseg][14]/F");
  ttreeOutput->Branch("wh", wh, "wh[nseg]/I");
  ttreeOutput->Branch("st", st, "st[nseg]/I");
  ttreeOutput->Branch("sr", sr, "sr[nseg]/I");
  ttreeOutput->Branch("sl", sl, "sl[nseg][14]/I");
  ttreeOutput->Branch("la", la, "la[nseg][14]/I");

}

void MuonDTLocalMillepedeAlgorithm::terminate ( void  )

virtual

Call at end of job.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 110 of file MuonDTLocalMillepedeAlgorithm.cc.

References f, nMtxSection, nPhihits, nThetahits, ntuplePath, numberOfRootFiles, ptMax, ptMin, and workingmode.

Referenced by ~MuonDTLocalMillepedeAlgorithm().

{

  //If workingmode equals 1 or 2, the algorithms are run before saving.   
  if(workingmode == 1) {
    edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] Starting SLToSL algorithm";
    DTMuonSLToSL mySLToSL(ntuplePath, numberOfRootFiles, ptMax, ptMin, f);
  } else if(workingmode >= 2) {
    edm::LogInfo("Alignment") << "[MuonDTLocalMillepedeAlgorithm] Starting local MuonMillepede algorithm";
    DTMuonMillepede myMillepede(ntuplePath, numberOfRootFiles, ptMax, ptMin, nPhihits, nThetahits, workingmode, nMtxSection);
  } 

  if (workingmode==0) {
    f->Write();
    f->Close();
  }

}

Member Data Documentation

float MuonDTLocalMillepedeAlgorithm::charge

private

Definition at line 78 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Vispa.Plugins.EdmBrowser.ParticleDataList.ParticleData::__repr__(), run(), and setBranchTrees().

edm::InputTag MuonDTLocalMillepedeAlgorithm::consTraj

private

Definition at line 135 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::dxdzSl[5]

private

Definition at line 84 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::dxdzSlSL1[5]

private

Definition at line 94 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::dxdzSlSL3[5]

private

Definition at line 100 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::dydzSl[5]

private

Definition at line 89 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::edxdzSl[5]

private

Definition at line 86 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::edxdzSlSL1[5]

private

Definition at line 96 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::edxdzSlSL3[5]

private

Definition at line 102 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::edydzSl[5]

private

Definition at line 91 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::eta

private

Definition at line 78 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Particle.Particle::__str__(), Jet.Jet::jetID(), Jet.Jet::puJetId(), run(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::ex[5][14]

private

Definition at line 108 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::excp[5][14]

private

Definition at line 111 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::exdxdzSl[5]

private

Definition at line 87 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments().

float MuonDTLocalMillepedeAlgorithm::exdxdzSlSL1[5]

private

Definition at line 97 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments().

float MuonDTLocalMillepedeAlgorithm::exdxdzSlSL3[5]

private

Definition at line 103 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments().

float MuonDTLocalMillepedeAlgorithm::exSl[5]

private

Definition at line 85 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::exSlSL1[5]

private

Definition at line 95 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::exSlSL3[5]

private

Definition at line 101 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::eycp[5][14]

private

Definition at line 112 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::eydydzSl[5]

private

Definition at line 92 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::eySl[5]

private

Definition at line 90 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

TFile* MuonDTLocalMillepedeAlgorithm::f

private

Definition at line 122 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Vispa.Views.RootCanvasView.RootCanvasView::createGraph(), Vispa.Views.RootCanvasView.RootCanvasView::createLegoPlot(), ztail.Decoder::initial_synchronize(), MuonDTLocalMillepedeAlgorithm(), and terminate().

edm::Service<TFileService> MuonDTLocalMillepedeAlgorithm::fs

private

Definition at line 132 of file MuonDTLocalMillepedeAlgorithm.h.

edm::InputTag MuonDTLocalMillepedeAlgorithm::globalTracks

private

Definition at line 134 of file MuonDTLocalMillepedeAlgorithm.h.

int MuonDTLocalMillepedeAlgorithm::la[5][14]

private

Definition at line 115 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::meandxdz[5][4][14]

private

Definition at line 154 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::meandydz[5][4][14]

private

Definition at line 158 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::meanx[5][4][14]

private

Definition at line 152 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::meany[5][4][14]

private

Definition at line 156 of file MuonDTLocalMillepedeAlgorithm.h.

Info1D MuonDTLocalMillepedeAlgorithm::myTrack1D

private

Definition at line 73 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and run().

int MuonDTLocalMillepedeAlgorithm::nhits[5]

private

Definition at line 82 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::nMtxSection

private

Definition at line 143 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm(), and terminate().

int MuonDTLocalMillepedeAlgorithm::nphihits[5]

private

Definition at line 80 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::nPhihits

private

Definition at line 139 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), MuonDTLocalMillepedeAlgorithm(), and terminate().

int MuonDTLocalMillepedeAlgorithm::nseg

private

Definition at line 79 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::nthetahits[5]

private

Definition at line 81 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::nThetahits

private

Definition at line 140 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), MuonDTLocalMillepedeAlgorithm(), and terminate().

std::string MuonDTLocalMillepedeAlgorithm::ntuplePath

private

Definition at line 136 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm(), and terminate().

int MuonDTLocalMillepedeAlgorithm::numberOfRootFiles

private

Definition at line 142 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm(), and terminate().

float MuonDTLocalMillepedeAlgorithm::numberOfSigmasDXDZ

private

Definition at line 148 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm().

float MuonDTLocalMillepedeAlgorithm::numberOfSigmasDYDZ

private

Definition at line 150 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm().

float MuonDTLocalMillepedeAlgorithm::numberOfSigmasX

private

Definition at line 147 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm().

float MuonDTLocalMillepedeAlgorithm::numberOfSigmasY

private

Definition at line 149 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm().

float MuonDTLocalMillepedeAlgorithm::p

private

Definition at line 78 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Vispa.Views.RootCanvasView.RootCanvasView::createGraph(), Vispa.Views.RootCanvasView.RootCanvasView::createLegoPlot(), Electron.Electron::ptErr(), run(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::phi

private

Definition at line 78 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Particle.Particle::__str__(), ntupleDataFormat.Track::phiPull(), run(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::pt

private

Definition at line 78 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by Particle.Particle::__str__(), ZMuMuRochCorAnalyzer.DiMuon::__str__(), DiObject.DiMuon::__str__(), Photon.Photon::calScaledIsoValueExp(), Photon.Photon::calScaledIsoValueLin(), Photon.Photon::calScaledIsoValueQuadr(), Electron.Electron::mvaIDLoose(), Electron.Electron::mvaIDRun2(), Electron.Electron::mvaIDTight(), Electron.Electron::ptErr(), ntupleDataFormat.Track::ptPull(), Lepton.Lepton::relIso(), Lepton.Lepton::relIsoFromEA(), Lepton.Lepton::relIsoR(), run(), setBranchTrees(), and Jet.Jet::setCorrP4().

float MuonDTLocalMillepedeAlgorithm::ptMax

private

Definition at line 137 of file MuonDTLocalMillepedeAlgorithm.h.

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

float MuonDTLocalMillepedeAlgorithm::ptMin

private

Definition at line 138 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by MuonDTLocalMillepedeAlgorithm(), and terminate().

float MuonDTLocalMillepedeAlgorithm::sigmadxdz[5][4][14]

private

Definition at line 155 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::sigmadydz[5][4][14]

private

Definition at line 159 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::sigmax[5][4][14]

private

Definition at line 153 of file MuonDTLocalMillepedeAlgorithm.h.

float MuonDTLocalMillepedeAlgorithm::sigmay[5][4][14]

private

Definition at line 157 of file MuonDTLocalMillepedeAlgorithm.h.

int MuonDTLocalMillepedeAlgorithm::sl[5][14]

private

Definition at line 114 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::sr[5]

private

Definition at line 113 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::st[5]

private

Definition at line 113 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

TChain* MuonDTLocalMillepedeAlgorithm::tali

private

Definition at line 124 of file MuonDTLocalMillepedeAlgorithm.h.

AlignableNavigator* MuonDTLocalMillepedeAlgorithm::theAlignableDetAccessor

private

Definition at line 129 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by initialize(), and run().

std::vector<Alignable*> MuonDTLocalMillepedeAlgorithm::theAlignables

private

Definition at line 128 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by initialize().

AlignmentParameterStore* MuonDTLocalMillepedeAlgorithm::theAlignmentParameterStore

private

Definition at line 127 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by initialize().

TTree* MuonDTLocalMillepedeAlgorithm::ttreeOutput

private

Definition at line 123 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by run(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::wh[5]

private

Definition at line 113 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

int MuonDTLocalMillepedeAlgorithm::workingmode

private

Definition at line 141 of file MuonDTLocalMillepedeAlgorithm.h.

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

float MuonDTLocalMillepedeAlgorithm::xc[5][14]

private

Definition at line 105 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), geometryXMLparser.Alignable::covariance(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xcp[5][14]

private

Definition at line 109 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xSl[5]

private

Definition at line 83 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xSL1SL3[5]

private

Definition at line 98 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xSL3SL1[5]

private

Definition at line 104 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xSlSL1[5]

private

Definition at line 93 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::xSlSL3[5]

private

Definition at line 99 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::yc[5][14]

private

Definition at line 106 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), geometryXMLparser.Alignable::covariance(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::ycp[5][14]

private

Definition at line 110 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::ySl[5]

private

Definition at line 88 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), and setBranchTrees().

float MuonDTLocalMillepedeAlgorithm::zc[5][14]

private

Definition at line 107 of file MuonDTLocalMillepedeAlgorithm.h.

Referenced by build4DSegments(), geometryXMLparser.Alignable::covariance(), and setBranchTrees().