[u/mrichter/AliRoot.git] / EVE / alice-macros / muon_all.C

void muon_all() {

  AliRunLoader* rl =  Alieve::Event::AssertRunLoader();

  rl->LoadDigits("MUON");
  rl->LoadRecPoints("MUON");
  rl->LoadTracks("MUON");

  TTree* dt = rl->GetTreeD("MUON", false);
  TTree* ct = rl->GetTreeR("MUON", false);
  TTree* tt = rl->GetTreeT("MUON", false);

  Alieve::MUONDigitsInfo* di = new Alieve::MUONDigitsInfo();
  di->SetDTree(dt);
  di->SetRTree(ct);
  di->SetTTree(tt);

  gStyle->SetPalette(1, 0);

  rl->LoadgAlice();
  gAlice = rl->GetAliRun();
  AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
  const AliMUONGeometryTransformer* kGeomTransformer = pMUON->GetGeometryTransformer();

  char name[128];
  char title[128];

  gReve->DisableRedraw();

  /* CHAMBERS */

  sprintf(name,"M-Chambers");
  Reve::RenderElementList* lch = new Reve::RenderElementList(name);
  lch->SetTitle(title);
  lch->SetMainColor((Color_t)2);
  gReve->AddRenderElement(lch);

  for (Int_t i = 1; i <= 14; i++) {

    Alieve::MUONModule* mch = new Alieve::MUONModule(i, -2, di, 0, 0, (Color_t)2);
    gReve->AddRenderElement(lch, mch);      
       
  }
  /*
  // draw pads in the trigger chambers
  for (Int_t i = 11; i <= 14; i++) {

    Alieve::MUONModule* mch1 = new Alieve::MUONModule(i, -3, di, 0, 0, (Color_t)2);
    gReve->AddRenderElement(lch, mch1);      
       
    Alieve::MUONModule* mch2 = new Alieve::MUONModule(i, -4, di, 0, 0, (Color_t)2);
    gReve->AddRenderElement(lch, mch2);      
       
  }
  */

  /* DIGITS */

  for (Int_t iSta = 1; iSta <= 7; iSta++) {

    for (Int_t iCha = 1; iCha <= 2; iCha++) {

      sprintf(name,"M-ST%1dCH%1d/Digits",iSta,iCha);

      Reve::RenderElementList* ld = new Reve::RenderElementList(name);
      
      if (iSta <= 5) {
	sprintf(title,"Station %1d chamber %1d (tracking)",iSta,iCha);
      } else {
	sprintf(title,"Station %1d chamber %1d (trigger)",iSta,iCha);
      }
      
      ld->SetTitle(title);
      ld->SetMainColor((Color_t)4);
      gReve->AddRenderElement(ld);
    
      Int_t iChamber = (iSta-1) * 2 + iCha; 

      AliMpDEIterator itd;
      for ( itd.First(iChamber-1); ! itd.IsDone(); itd.Next() ) {
	
	Int_t detElemId = itd.CurrentDE();
	
	for (Int_t iCat = 1; iCat <=2; iCat++) {

	  Alieve::MUONModule* md = new Alieve::MUONModule(detElemId, iCat, di, 1, 0, (Color_t)2);
	  gReve->AddRenderElement(ld, md);      
	
	}

      }
      
    }
    
  }
  
  /* CLUSTERS */

  for (Int_t iSta = 1; iSta <= 5; iSta++) {

    for (Int_t iCha = 1; iCha <= 2; iCha++) {

      sprintf(name,"M-ST%1dCH%1d/Clusters",iSta,iCha);

      Reve::RenderElementList* lc = new Reve::RenderElementList(name);
      
      if (iSta <= 5) {
	sprintf(title,"Station %1d chamber %1d (tracking)",iSta,iCha);
      } else {
	sprintf(title,"Station %1d chamber %1d (trigger)",iSta,iCha);
      }
      
      lc->SetTitle(title);
      lc->SetMainColor((Color_t)4);
      gReve->AddRenderElement(lc);
    
      Int_t iChamber = (iSta-1) * 2 + iCha; 

      AliMpDEIterator itc;
      for ( itc.First(iChamber-1); ! itc.IsDone(); itc.Next() ) {
	
	Int_t detElemId = itc.CurrentDE();
	
	Alieve::MUONModule* mc = new Alieve::MUONModule(detElemId, 0, di, 0, 1, (Color_t)2);
	gReve->AddRenderElement(lc, mc);      
	
      }

    }
    
  }
  
  /* TRACKS */

  /* Get the z positions of the trigger chambers */

  Float_t xg, yg, zg[4];

  // MT11 = ST6CH1, detElemId = 1100 ... 1117
  // MT12 = ST6CH2, detElemId = 1200 ... 1217
  // MT21 = ST7CH1, detElemId = 1300 ... 1317
  // MT22 = ST7CH2, detElemId = 1400 ... 1417

  kGeomTransformer->Local2Global(1100, 0, 0, 0, xg, yg, zg[0]);
  kGeomTransformer->Local2Global(1200, 0, 0, 0, xg, yg, zg[1]);
  kGeomTransformer->Local2Global(1300, 0, 0, 0, xg, yg, zg[2]);
  kGeomTransformer->Local2Global(1400, 0, 0, 0, xg, yg, zg[3]);

  /* from tracking chambers */

  TMatrixD smatrix(2,2);
  TMatrixD sums(2,1);
  TMatrixD res(2,1);

  TClonesArray *tracks = 0;
  tt->SetBranchAddress("MUONTrack",&tracks);
  tt->GetEntry(0);  // load event 0

  Int_t ntracks = tracks->GetEntriesFast();
  printf("Found %d tracks. \n",ntracks);

  Reve::TrackList* lt = new Reve::TrackList("M-Tracks"); 
  lt->SetMainColor(Color_t(6));
  
  gReve->AddRenderElement(lt);

  Float_t xRec, xRec0;
  Float_t yRec, yRec0;
  Float_t zRec, zRec0;
  
  AliMUONTrack *mt;  
  Reve::RecTrack  rt;
  Int_t count = 0;
  for (Int_t n = 0; n < ntracks; n++) {
    
    mt = (AliMUONTrack*) tracks->At(n);

    printf("Match trigger %d \n",mt->GetMatchTrigger());

    rt.label = n;

    Reve::Track* track = new Reve::Track(&rt, lt->GetRnrStyle());

    if (mt->GetMatchTrigger()) {
      track->SetName(Form("MUONTrack %2d (MT)", rt.label));
      track->SetLineColor(7);
    } else {
      track->SetName(Form("MUONTrack %2d     ", rt.label));
      track->SetLineColor(6);
    }

    AliMUONTrackParam *trackParam = mt->GetTrackParamAtVertex(); 
    xRec0  = trackParam->GetNonBendingCoor();
    yRec0  = trackParam->GetBendingCoor();
    zRec0  = trackParam->GetZ();

    track->SetPoint(count,zRec0,yRec0,xRec0);
    count++;
    
    Float_t xr[20], yr[20], zr[20];
    for (Int_t i = 0; i < 10; i++) xr[i]=yr[i]=zr[i]=0.0;

    Int_t nTrackHits = mt->GetNTrackHits();
    printf("Nhits = %d \n",nTrackHits);
    for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
      trackParamAtHit = mt->GetTrackParamAtHit();
      trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit); 
      xRec  = trackParam->GetNonBendingCoor();
      yRec  = trackParam->GetBendingCoor();
      zRec  = trackParam->GetZ();

      //printf("Hit %d x %f y %f z %f \n",iHit,xRec,yRec,zRec);

      xr[iHit] = xRec;
      yr[iHit] = yRec;
      zr[iHit] = zRec;

      track->SetPoint(count,zRec,yRec,xRec);
      count++;
    
    }

    Float_t xrc[20], yrc[20], zrc[20];
    Int_t nrc = 0;
    if (mt->GetMatchTrigger()) {

      for (Int_t i = 0; i < nTrackHits; i++) {
	if (TMath::Abs(zr[i]) > 1000.0) {
	  //printf("Hit %d x %f y %f z %f \n",iHit,xr[i],yr[i],zr[i]);
	  xrc[nrc] = xr[i];
	  yrc[nrc] = yr[i];
	  zrc[nrc] = zr[i];
	  nrc++;
	}
      }

      Double_t xv, yv;
      Float_t ax, bx, ay, by;
      
      // fit x-z
      smatrix.Zero();
      sums.Zero();
      for (Int_t i = 0; i < nrc; i++) {
	xv = (Double_t)zrc[i];
	yv = (Double_t)xrc[i];
	//printf("x-z: xv %f yv %f \n",xv,yv);
	smatrix(0,0) += 1.0;
	smatrix(1,1) += xv*xv;
	smatrix(0,1) += xv;
	smatrix(1,0) += xv;
	sums(0,0)    += yv;
	sums(1,0)    += xv*yv;
      }
      res = smatrix.Invert() * sums;
      ax = res(0,0);
      bx = res(1,0);

      // fit y-z
      smatrix.Zero();
      sums.Zero();
      for (Int_t i = 0; i < nrc; i++) {
	xv = (Double_t)zrc[i];
	yv = (Double_t)yrc[i];
	//printf("y-z: xv %f yv %f \n",xv,yv);
	smatrix(0,0) += 1.0;
	smatrix(1,1) += xv*xv;
	smatrix(0,1) += xv;
	smatrix(1,0) += xv;
	sums(0,0)    += yv;
	sums(1,0)    += xv*yv;
      }
      res = smatrix.Invert() * sums;
      ay = res(0,0);
      by = res(1,0);

      Float_t xtc, ytc, ztc;
      for (Int_t ii = 0; ii < 4; ii++) {

	ztc = zg[ii];
	ytc = ay+by*zg[ii];
	xtc = ax+bx*zg[ii];

	//printf("tc: x %f y %f z %f \n",xtc,ytc,ztc);

	track->SetPoint(count,ztc,ytc,xtc);
	count++;

      }

    }

    gReve->AddRenderElement(lt, track);

  }

  gReve->EnableRedraw();
  
}
Commit	Line	Data
34ea2f0a	1	void muon_all() {
	2
	3	AliRunLoader* rl = Alieve::Event::AssertRunLoader();
	4
	5	rl->LoadDigits("MUON");
	6	rl->LoadRecPoints("MUON");
	7	rl->LoadTracks("MUON");
	8
	9	TTree* dt = rl->GetTreeD("MUON", false);
	10	TTree* ct = rl->GetTreeR("MUON", false);
	11	TTree* tt = rl->GetTreeT("MUON", false);
	12
	13	Alieve::MUONDigitsInfo* di = new Alieve::MUONDigitsInfo();
	14	di->SetDTree(dt);
	15	di->SetRTree(ct);
	16	di->SetTTree(tt);
	17
	18	gStyle->SetPalette(1, 0);
	19
	20	rl->LoadgAlice();
	21	gAlice = rl->GetAliRun();
	22	AliMUON pMUON = (AliMUON)gAlice->GetModule("MUON");
	23	const AliMUONGeometryTransformer* kGeomTransformer = pMUON->GetGeometryTransformer();
	24
	25	char name[128];
	26	char title[128];
	27
5b96ea20	28	gReve->DisableRedraw();
5b96ea20	29
34ea2f0a	30	/* CHAMBERS */
	31
	32	sprintf(name,"M-Chambers");
	33	Reve::RenderElementList* lch = new Reve::RenderElementList(name);
	34	lch->SetTitle(title);
	35	lch->SetMainColor((Color_t)2);
5b96ea20	36	gReve->AddRenderElement(lch);
34ea2f0a	37
	38	for (Int_t i = 1; i <= 14; i++) {
	39
	40	Alieve::MUONModule* mch = new Alieve::MUONModule(i, -2, di, 0, 0, (Color_t)2);
5b96ea20	41	gReve->AddRenderElement(lch, mch);
34ea2f0a	42
	43	}
	44	/*
	45	// draw pads in the trigger chambers
	46	for (Int_t i = 11; i <= 14; i++) {
	47
	48	Alieve::MUONModule* mch1 = new Alieve::MUONModule(i, -3, di, 0, 0, (Color_t)2);
5b96ea20	49	gReve->AddRenderElement(lch, mch1);
34ea2f0a	50
34ea2f0a	51	Alieve::MUONModule* mch2 = new Alieve::MUONModule(i, -4, di, 0, 0, (Color_t)2);
5b96ea20	52	gReve->AddRenderElement(lch, mch2);
34ea2f0a	53
	54	}
	55	*/
34ea2f0a	56
	57	/* DIGITS */
	58
34ea2f0a	59	for (Int_t iSta = 1; iSta <= 7; iSta++) {
	60
	61	for (Int_t iCha = 1; iCha <= 2; iCha++) {
	62
	63	sprintf(name,"M-ST%1dCH%1d/Digits",iSta,iCha);
	64
	65	Reve::RenderElementList* ld = new Reve::RenderElementList(name);
	66
	67	if (iSta <= 5) {
	68	sprintf(title,"Station %1d chamber %1d (tracking)",iSta,iCha);
	69	} else {
	70	sprintf(title,"Station %1d chamber %1d (trigger)",iSta,iCha);
	71	}
	72
	73	ld->SetTitle(title);
	74	ld->SetMainColor((Color_t)4);
5b96ea20	75	gReve->AddRenderElement(ld);
34ea2f0a	76
	77	Int_t iChamber = (iSta-1) * 2 + iCha;
	78
	79	AliMpDEIterator itd;
	80	for ( itd.First(iChamber-1); ! itd.IsDone(); itd.Next() ) {
	81
	82	Int_t detElemId = itd.CurrentDE();
	83
	84	for (Int_t iCat = 1; iCat <=2; iCat++) {
	85
	86	Alieve::MUONModule* md = new Alieve::MUONModule(detElemId, iCat, di, 1, 0, (Color_t)2);
5b96ea20	87	gReve->AddRenderElement(ld, md);
34ea2f0a	88
	89	}
	90
	91	}
34ea2f0a	92
	93	}
	94
	95	}
	96
	97	/* CLUSTERS */
	98
	99	for (Int_t iSta = 1; iSta <= 5; iSta++) {
	100
	101	for (Int_t iCha = 1; iCha <= 2; iCha++) {
	102
	103	sprintf(name,"M-ST%1dCH%1d/Clusters",iSta,iCha);
	104
	105	Reve::RenderElementList* lc = new Reve::RenderElementList(name);
	106
	107	if (iSta <= 5) {
	108	sprintf(title,"Station %1d chamber %1d (tracking)",iSta,iCha);
	109	} else {
	110	sprintf(title,"Station %1d chamber %1d (trigger)",iSta,iCha);
	111	}
	112
	113	lc->SetTitle(title);
	114	lc->SetMainColor((Color_t)4);
5b96ea20	115	gReve->AddRenderElement(lc);
34ea2f0a	116
	117	Int_t iChamber = (iSta-1) * 2 + iCha;
	118
	119	AliMpDEIterator itc;
	120	for ( itc.First(iChamber-1); ! itc.IsDone(); itc.Next() ) {
	121
	122	Int_t detElemId = itc.CurrentDE();
	123
	124	Alieve::MUONModule* mc = new Alieve::MUONModule(detElemId, 0, di, 0, 1, (Color_t)2);
5b96ea20	125	gReve->AddRenderElement(lc, mc);
34ea2f0a	126
	127	}
	128
34ea2f0a	129	}
	130
	131	}
	132
34ea2f0a	133	/* TRACKS */
	134
	135	/* Get the z positions of the trigger chambers */
	136
	137	Float_t xg, yg, zg[4];
	138
	139	// MT11 = ST6CH1, detElemId = 1100 ... 1117
	140	// MT12 = ST6CH2, detElemId = 1200 ... 1217
	141	// MT21 = ST7CH1, detElemId = 1300 ... 1317
	142	// MT22 = ST7CH2, detElemId = 1400 ... 1417
	143
	144	kGeomTransformer->Local2Global(1100, 0, 0, 0, xg, yg, zg[0]);
	145	kGeomTransformer->Local2Global(1200, 0, 0, 0, xg, yg, zg[1]);
	146	kGeomTransformer->Local2Global(1300, 0, 0, 0, xg, yg, zg[2]);
	147	kGeomTransformer->Local2Global(1400, 0, 0, 0, xg, yg, zg[3]);
	148
	149	/* from tracking chambers */
	150
	151	TMatrixD smatrix(2,2);
	152	TMatrixD sums(2,1);
	153	TMatrixD res(2,1);
	154
	155	TClonesArray *tracks = 0;
	156	tt->SetBranchAddress("MUONTrack",&tracks);
	157	tt->GetEntry(0); // load event 0
	158
	159	Int_t ntracks = tracks->GetEntriesFast();
	160	printf("Found %d tracks. \n",ntracks);
	161
	162	Reve::TrackList* lt = new Reve::TrackList("M-Tracks");
	163	lt->SetMainColor(Color_t(6));
	164
5b96ea20	165	gReve->AddRenderElement(lt);
34ea2f0a	166
	167	Float_t xRec, xRec0;
	168	Float_t yRec, yRec0;
	169	Float_t zRec, zRec0;
	170
	171	AliMUONTrack *mt;
	172	Reve::RecTrack rt;
	173	Int_t count = 0;
	174	for (Int_t n = 0; n < ntracks; n++) {
	175
	176	mt = (AliMUONTrack*) tracks->At(n);
	177
	178	printf("Match trigger %d \n",mt->GetMatchTrigger());
	179
	180	rt.label = n;
	181
	182	Reve::Track* track = new Reve::Track(&rt, lt->GetRnrStyle());
	183
	184	if (mt->GetMatchTrigger()) {
	185	track->SetName(Form("MUONTrack %2d (MT)", rt.label));
	186	track->SetLineColor(7);
	187	} else {
	188	track->SetName(Form("MUONTrack %2d ", rt.label));
	189	track->SetLineColor(6);
	190	}
	191
	192	AliMUONTrackParam *trackParam = mt->GetTrackParamAtVertex();
	193	xRec0 = trackParam->GetNonBendingCoor();
	194	yRec0 = trackParam->GetBendingCoor();
	195	zRec0 = trackParam->GetZ();
	196
	197	track->SetPoint(count,zRec0,yRec0,xRec0);
	198	count++;
	199
	200	Float_t xr[20], yr[20], zr[20];
	201	for (Int_t i = 0; i < 10; i++) xr[i]=yr[i]=zr[i]=0.0;
	202
	203	Int_t nTrackHits = mt->GetNTrackHits();
	204	printf("Nhits = %d \n",nTrackHits);
	205	for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
	206	trackParamAtHit = mt->GetTrackParamAtHit();
	207	trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit);
	208	xRec = trackParam->GetNonBendingCoor();
	209	yRec = trackParam->GetBendingCoor();
	210	zRec = trackParam->GetZ();
	211
	212	//printf("Hit %d x %f y %f z %f \n",iHit,xRec,yRec,zRec);
	213
	214	xr[iHit] = xRec;
	215	yr[iHit] = yRec;
	216	zr[iHit] = zRec;
	217
	218	track->SetPoint(count,zRec,yRec,xRec);
	219	count++;
	220
	221	}
	222
	223	Float_t xrc[20], yrc[20], zrc[20];
	224	Int_t nrc = 0;
	225	if (mt->GetMatchTrigger()) {
	226
	227	for (Int_t i = 0; i < nTrackHits; i++) {
	228	if (TMath::Abs(zr[i]) > 1000.0) {
	229	//printf("Hit %d x %f y %f z %f \n",iHit,xr[i],yr[i],zr[i]);
230	xrc[nrc] = xr[i];
231	yrc[nrc] = yr[i];
232	zrc[nrc] = zr[i];
233	nrc++;
234	}
235	}
236
237	Double_t xv, yv;
238	Float_t ax, bx, ay, by;
239
240	// fit x-z
241	smatrix.Zero();
242	sums.Zero();
243	for (Int_t i = 0; i < nrc; i++) {
244	xv = (Double_t)zrc[i];
245	yv = (Double_t)xrc[i];
246	//printf("x-z: xv %f yv %f \n",xv,yv);
247	smatrix(0,0) += 1.0;
248	smatrix(1,1) += xv*xv;
249	smatrix(0,1) += xv;
250	smatrix(1,0) += xv;
251	sums(0,0) += yv;
252	sums(1,0) += xv*yv;
253	}
254	res = smatrix.Invert() * sums;
255	ax = res(0,0);
256	bx = res(1,0);
257
258	// fit y-z
259	smatrix.Zero();
260	sums.Zero();
261	for (Int_t i = 0; i < nrc; i++) {
262	xv = (Double_t)zrc[i];
263	yv = (Double_t)yrc[i];
264	//printf("y-z: xv %f yv %f \n",xv,yv);
265	smatrix(0,0) += 1.0;
266	smatrix(1,1) += xv*xv;
267	smatrix(0,1) += xv;
268	smatrix(1,0) += xv;
269	sums(0,0) += yv;
270	sums(1,0) += xv*yv;
271	}
272	res = smatrix.Invert() * sums;
273	ay = res(0,0);
274	by = res(1,0);
275
276	Float_t xtc, ytc, ztc;
277	for (Int_t ii = 0; ii < 4; ii++) {
278
279	ztc = zg[ii];
280	ytc = ay+by*zg[ii];
281	xtc = ax+bx*zg[ii];
282
283	//printf("tc: x %f y %f z %f \n",xtc,ytc,ztc);
284
285	track->SetPoint(count,ztc,ytc,xtc);
286	count++;
287
288	}
289
290	}
291
5b96ea20	292	gReve->AddRenderElement(lt, track);
34ea2f0a	293
	294	}
	295
5b96ea20	296	gReve->EnableRedraw();
34ea2f0a	297
34ea2f0a	298	}