[u/mrichter/AliRoot.git] / MUON / AliMUONPoints.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/*
$Log$
Revision 1.2  2000/06/15 07:58:48  morsch
Code from MUON-dev joined

Revision 1.1.2.6  2000/06/09 21:57:40  morsch
Most coding rule violations corrected.

Revision 1.1.2.5  2000/05/05 11:33:56  morsch
Log inside comments.

Revision 1.1.2.4  2000/05/05 10:12:09  morsch
Log messages included
*/

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  This class contains the points for the ALICE event display               //
//                                                                           //
//Begin_Html
/*
<img src="gif/AliMUONPointsClass.gif">
*/
//End_Html
//                                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliMUONPoints.h"
#include "AliMUONDisplay.h"
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
#include "AliMUONSegmentation.h"
#include "AliMUONResponse.h"
#include "AliMUONHit.h"
#include "AliMUONPadHit.h"
#include "AliMUONDigit.h"
#include "AliMUONRawCluster.h"


#include <TPolyMarker3D.h>
#include <TMatrix.h>
#include <TPad.h>
#include <TVirtualPad.h>
#include <TPolyLine3D.h>
#include <TPaveText.h>
#include <TView.h>
#include <TMath.h>

 
ClassImp(AliMUONPoints)

//_____________________________________________________________________________
AliMUONPoints::AliMUONPoints()
{
  //
  // Default constructor
  //
  fHitIndex = 0;
  fTrackIndex = 0;
  fDigitIndex = 0;
  fMarker[0] = fMarker[1] = fMarker[2]=0;
  fMatrix = 0;
}

//_____________________________________________________________________________
AliMUONPoints::AliMUONPoints(Int_t npoints)
  :AliPoints(npoints)
{
  //
  // Standard constructor
  //
  fHitIndex = 0;
  fTrackIndex = 0;
  fDigitIndex = 0;
  fMarker[0] = fMarker[1] = fMarker[2]=0;
  fMatrix = 0;
}

AliMUONPoints::AliMUONPoints(const AliMUONPoints& points)
{
// Copy constructor
}
	 
//_____________________________________________________________________________
AliMUONPoints::~AliMUONPoints()
{
  //
  // Default destructor
  //
  fHitIndex = 0;
  fTrackIndex = 0;
  fDigitIndex = 0;
  for (Int_t i=0;i<3;i++){
      if (fMarker[i]) delete fMarker[i];
  }
  fMatrix = 0;
}

//_____________________________________________________________________________
void AliMUONPoints::DumpHit()
{
  //
  //   Dump hit corresponding to this point
  //
  AliMUONHit *hit = GetHit();
  if (hit) hit->Dump();
}

//_____________________________________________________________________________
void AliMUONPoints::DumpDigit()
{
  //
  //   Dump digit corresponding to this point
  //
  AliMUONDigit *digit = GetDigit();
  if (digit) digit->Dump();
}

//_____________________________________________________________________________
void AliMUONPoints::InspectHit()
{
  //
  //   Inspect hit corresponding to this point
  //

  if (fHitIndex < 0 ) return;
  TVirtualPad *padsav = gPad;
  AliMUONHit *hit = GetHit();
  if (hit) hit->Inspect();
  TVirtualPad *padinspect = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("inspect");
   padinspect->cd();
   Float_t xmin = gPad->GetX1();
   Float_t xmax = gPad->GetX2();
   Float_t ymin = gPad->GetY1();
   Float_t ymax = gPad->GetY2();
   Float_t dy   = ymax-ymin;

      TPaveText *pad = new TPaveText(xmin, ymin+0.1*dy, xmax, ymin+0.15*dy);
      pad->SetBit(kCanDelete);
      pad->SetFillColor(42);
      pad->Draw();
      char ptitle[100];
      sprintf(ptitle," %s , fTrack: %d  fTrackIndex: %d ",GetName(),fIndex,fTrackIndex);
      pad->AddText(ptitle);
      padinspect->cd();
      padinspect->Update();
  if (padsav) padsav->cd();

}

//_____________________________________________________________________________
void AliMUONPoints::InspectDigit()
{
  //
  //   Inspect digit corresponding to this point
  //
  if (fDigitIndex < 0) return;
  TVirtualPad *padsav = gPad;
  AliMUONDigit *digit = GetDigit();
  if (digit) digit->Inspect();
  TVirtualPad *padinspect = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("inspect");
   padinspect->cd();
   Float_t xmin = gPad->GetX1();
   Float_t xmax = gPad->GetX2();
   Float_t ymin = gPad->GetY1();
   Float_t ymax = gPad->GetY2();
   Float_t dy   = ymax-ymin;

      TPaveText *pad = new TPaveText(xmin, ymin+0.1*dy, xmax, ymin+0.25*dy);
      pad->SetBit(kCanDelete);
      pad->SetFillColor(42);
      pad->Draw();
      char ptitle[11][100];
      //      sprintf(ptitle[11],"Tracks making this digit");
      //      pad->AddText(ptitle[11]);
  for (int i=0;i<10;i++) {
      if (digit->fTracks[i] == 0) continue;  
      sprintf(ptitle[i],"fTrackIndex: %d  Charge: %d",digit->fTracks[i],digit->fTcharges[i]);
      pad->AddText(ptitle[i]);
  }
      padinspect->cd();
      padinspect->Update();
  if (padsav) padsav->cd();
      
}

//_____________________________________________________________________________
Int_t AliMUONPoints::GetTrackIndex()
{
  //
  //   Dump digit corresponding to this point
  //

  this->Inspect();
  /*
  if (fDigitIndex != 0) {
    Int_t ncol=this->fMatrix->GetNcols();
    for (int i=0;i<ncol;i++) {
        printf(" track charge %f %f \n",(*(this->fMatrix))(0,i),(*(this->fMatrix))(1,i));
    }
  }
  */
  return fTrackIndex;
}

//_____________________________________________________________________________
AliMUONHit *AliMUONPoints::GetHit() const
{
  //
  //   Returns pointer to hit index in AliRun::fParticles
  //
  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
  gAlice->TreeH()->GetEvent(fTrackIndex);
  TClonesArray *muonHits  = pMUON->Hits();
  Int_t nhits = muonHits->GetEntriesFast();
  if (fHitIndex < 0 || fHitIndex >= nhits) return 0;
  return (AliMUONHit*)muonHits->UncheckedAt(fHitIndex);
}

//_____________________________________________________________________________
AliMUONDigit *AliMUONPoints::GetDigit() const
{
  //
  //   Returns pointer to digit index in AliRun::fParticles
  //

  AliMUONDisplay *display=(AliMUONDisplay*)gAlice->Display();
  Int_t chamber=display->GetChamber();
  Int_t cathode=display->GetCathode();
   
  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
  TClonesArray *muonDigits  = pMUON->DigitsAddress(chamber-1);
  Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
  gAlice->TreeD()->GetEvent(nent-2+cathode-1);
  //gAlice->TreeD()->GetEvent(cathode);
  Int_t ndigits = muonDigits->GetEntriesFast();
  if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
  return (AliMUONDigit*)muonDigits->UncheckedAt(fDigitIndex);
}
//_____________________________________________________________________________

AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& rhs)
{
    return *this;
}
Commit	Line	Data
a9e2aefa	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	/*
	16	$Log$
3ed6ebad	17	Revision 1.2 2000/06/15 07:58:48 morsch
	18	Code from MUON-dev joined
	19
a9e2aefa	20	Revision 1.1.2.6 2000/06/09 21:57:40 morsch
	21	Most coding rule violations corrected.
	22
	23	Revision 1.1.2.5 2000/05/05 11:33:56 morsch
	24	Log inside comments.
	25
	26	Revision 1.1.2.4 2000/05/05 10:12:09 morsch
	27	Log messages included
	28	*/
	29
	30	///////////////////////////////////////////////////////////////////////////////
	31	// //
	32	// This class contains the points for the ALICE event display //
	33	// //
	34	//Begin_Html
	35	/*
	36	<img src="gif/AliMUONPointsClass.gif">
	37	*/
	38	//End_Html
	39	// //
	40	// //
	41	///////////////////////////////////////////////////////////////////////////////
	42
	43	#include "AliMUONPoints.h"
	44	#include "AliMUONDisplay.h"
	45	#include "AliRun.h"
	46	#include "AliMUON.h"
	47	#include "AliMUONChamber.h"
	48	#include "AliMUONSegmentation.h"
	49	#include "AliMUONResponse.h"
	50	#include "AliMUONHit.h"
	51	#include "AliMUONPadHit.h"
	52	#include "AliMUONDigit.h"
	53	#include "AliMUONRawCluster.h"
	54
	55
	56	#include <TPolyMarker3D.h>
	57	#include <TMatrix.h>
	58	#include <TPad.h>
	59	#include <TVirtualPad.h>
	60	#include <TPolyLine3D.h>
	61	#include <TPaveText.h>
	62	#include <TView.h>
	63	#include <TMath.h>
	64
a9e2aefa	65
	66	ClassImp(AliMUONPoints)
	67
	68	//_____________________________________________________________________________
	69	AliMUONPoints::AliMUONPoints()
	70	{
	71	//
	72	// Default constructor
	73	//
	74	fHitIndex = 0;
	75	fTrackIndex = 0;
	76	fDigitIndex = 0;
	77	fMarker[0] = fMarker[1] = fMarker[2]=0;
	78	fMatrix = 0;
	79	}
	80
	81	//_____________________________________________________________________________
	82	AliMUONPoints::AliMUONPoints(Int_t npoints)
	83	:AliPoints(npoints)
	84	{
	85	//
	86	// Standard constructor
	87	//
	88	fHitIndex = 0;
	89	fTrackIndex = 0;
	90	fDigitIndex = 0;
	91	fMarker[0] = fMarker[1] = fMarker[2]=0;
	92	fMatrix = 0;
	93	}
	94
	95	AliMUONPoints::AliMUONPoints(const AliMUONPoints& points)
	96	{
	97	// Copy constructor
	98	}
	99
	100	//_____________________________________________________________________________
	101	AliMUONPoints::~AliMUONPoints()
	102	{
	103	//
	104	// Default destructor
	105	//
	106	fHitIndex = 0;
	107	fTrackIndex = 0;
	108	fDigitIndex = 0;
	109	for (Int_t i=0;i<3;i++){
	110	if (fMarker[i]) delete fMarker[i];
	111	}
	112	fMatrix = 0;
	113	}
	114
	115	//_____________________________________________________________________________
	116	void AliMUONPoints::DumpHit()
	117	{
	118	//
	119	// Dump hit corresponding to this point
	120	//
	121	AliMUONHit *hit = GetHit();
	122	if (hit) hit->Dump();
	123	}
	124
	125	//_____________________________________________________________________________
	126	void AliMUONPoints::DumpDigit()
	127	{
	128	//
129	// Dump digit corresponding to this point
130	//
131	AliMUONDigit *digit = GetDigit();
132	if (digit) digit->Dump();
133	}
134
135	//_____________________________________________________________________________
136	void AliMUONPoints::InspectHit()
137	{
138	//
139	// Inspect hit corresponding to this point
140	//
141
142	if (fHitIndex < 0 ) return;
143	TVirtualPad *padsav = gPad;
144	AliMUONHit *hit = GetHit();
145	if (hit) hit->Inspect();
146	TVirtualPad padinspect = (TVirtualPad)(gROOT->GetListOfCanvases())->FindObject("inspect");
147	padinspect->cd();
148	Float_t xmin = gPad->GetX1();
149	Float_t xmax = gPad->GetX2();
150	Float_t ymin = gPad->GetY1();
151	Float_t ymax = gPad->GetY2();
152	Float_t dy = ymax-ymin;
153
154	TPaveText pad = new TPaveText(xmin, ymin+0.1dy, xmax, ymin+0.15*dy);
155	pad->SetBit(kCanDelete);
156	pad->SetFillColor(42);
157	pad->Draw();
158	char ptitle[100];
159	sprintf(ptitle," %s , fTrack: %d fTrackIndex: %d ",GetName(),fIndex,fTrackIndex);
160	pad->AddText(ptitle);
161	padinspect->cd();
162	padinspect->Update();
163	if (padsav) padsav->cd();
164
165	}
166
167	//_____________________________________________________________________________
168	void AliMUONPoints::InspectDigit()
169	{
170	//
171	// Inspect digit corresponding to this point
172	//
173	if (fDigitIndex < 0) return;
174	TVirtualPad *padsav = gPad;
175	AliMUONDigit *digit = GetDigit();
176	if (digit) digit->Inspect();
177	TVirtualPad padinspect = (TVirtualPad)(gROOT->GetListOfCanvases())->FindObject("inspect");
178	padinspect->cd();
179	Float_t xmin = gPad->GetX1();
180	Float_t xmax = gPad->GetX2();
181	Float_t ymin = gPad->GetY1();
182	Float_t ymax = gPad->GetY2();
183	Float_t dy = ymax-ymin;
184
185	TPaveText pad = new TPaveText(xmin, ymin+0.1dy, xmax, ymin+0.25*dy);
186	pad->SetBit(kCanDelete);
187	pad->SetFillColor(42);
188	pad->Draw();
189	char ptitle[11][100];
190	// sprintf(ptitle[11],"Tracks making this digit");
191	// pad->AddText(ptitle[11]);
192	for (int i=0;i<10;i++) {
193	if (digit->fTracks[i] == 0) continue;
194	sprintf(ptitle[i],"fTrackIndex: %d Charge: %d",digit->fTracks[i],digit->fTcharges[i]);
195	pad->AddText(ptitle[i]);
196	}
197	padinspect->cd();
198	padinspect->Update();
199	if (padsav) padsav->cd();
200
201	}
202
203	//_____________________________________________________________________________
204	Int_t AliMUONPoints::GetTrackIndex()
205	{
206	//
207	// Dump digit corresponding to this point
208	//
209
210	this->Inspect();
211	/*
212	if (fDigitIndex != 0) {
213	Int_t ncol=this->fMatrix->GetNcols();
214	for (int i=0;i<ncol;i++) {
215	printf(" track charge %f %f \n",((this->fMatrix))(0,i),((this->fMatrix))(1,i));
216	}
217	}
218	*/
219	return fTrackIndex;
220	}
221
222	//_____________________________________________________________________________
223	AliMUONHit *AliMUONPoints::GetHit() const
224	{
225	//
226	// Returns pointer to hit index in AliRun::fParticles
227	//
228	AliMUON pMUON = (AliMUON)gAlice->GetModule("MUON");
229	gAlice->TreeH()->GetEvent(fTrackIndex);
230	TClonesArray *muonHits = pMUON->Hits();
231	Int_t nhits = muonHits->GetEntriesFast();
232	if (fHitIndex < 0 \|\| fHitIndex >= nhits) return 0;
233	return (AliMUONHit*)muonHits->UncheckedAt(fHitIndex);
234	}
235
236	//_____________________________________________________________________________
237	AliMUONDigit *AliMUONPoints::GetDigit() const
238	{
239	//
240	// Returns pointer to digit index in AliRun::fParticles
241	//
242
243	AliMUONDisplay display=(AliMUONDisplay)gAlice->Display();
244	Int_t chamber=display->GetChamber();
245	Int_t cathode=display->GetCathode();
246
247	AliMUON pMUON = (AliMUON)gAlice->GetModule("MUON");
248	TClonesArray *muonDigits = pMUON->DigitsAddress(chamber-1);
249	Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
250	gAlice->TreeD()->GetEvent(nent-2+cathode-1);
251	//gAlice->TreeD()->GetEvent(cathode);
252	Int_t ndigits = muonDigits->GetEntriesFast();
253	if (fDigitIndex < 0 \|\| fDigitIndex >= ndigits) return 0;
254	return (AliMUONDigit*)muonDigits->UncheckedAt(fDigitIndex);
255	}
256	//_____________________________________________________________________________
257
258	AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& rhs)
259	{
260	return *this;
261	}