[u/mrichter/AliRoot.git] / MUON / AliMUONClusterInfo.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.                  *
**************************************************************************/

// $Id$

//-----------------------------------------------------------------------------
/// \class AliMUONClusterInfo
///
/// Class to summarize ESD data at cluster
///
/// \author Philippe Pillot, Subatech
//-----------------------------------------------------------------------------

#include "AliMUONClusterInfo.h"

#include "AliLog.h"

#include <Riostream.h>

/// \cond CLASSIMP
ClassImp(AliMUONClusterInfo)
/// \endcond

//_____________________________________________________________________________
AliMUONClusterInfo::AliMUONClusterInfo()
: TObject(),
  fRunId(0),
  fEventId(0),
  fZ(0.),
  fClusterId(0),
  fClusterX(0.),
  fClusterY(0.),
  fClusterXErr(0.),
  fClusterYErr(0.),
  fClusterChi2(0.),
  fClusterCharge(0.),
  fTrackId(0),
  fTrackX(0.),
  fTrackY(0.),
  fTrackThetaX(0.),
  fTrackThetaY(0.),
  fTrackP(0.),
  fTrackXErr(0.),
  fTrackYErr(0.),
  fTrackChi2(0.),
  fTrackCharge(0),
  fTrackNHits(0),
  fTrackChamberHitMap(0),
  fNPads(0),
  fPads(new TClonesArray("AliMUONPadInfo",10))
{
  /// default constructor
}

//_____________________________________________________________________________
AliMUONClusterInfo::AliMUONClusterInfo (const AliMUONClusterInfo& clusterInfo)
: TObject(clusterInfo),
  fRunId(clusterInfo.fRunId),
  fEventId(clusterInfo.fEventId),
  fZ(clusterInfo.fZ),
  fClusterId(clusterInfo.fClusterId),
  fClusterX(clusterInfo.fClusterX),
  fClusterY(clusterInfo.fClusterY),
  fClusterXErr(clusterInfo.fClusterXErr),
  fClusterYErr(clusterInfo.fClusterYErr),
  fClusterChi2(clusterInfo.fClusterChi2),
  fClusterCharge(clusterInfo.fClusterCharge),
  fTrackId(clusterInfo.fTrackId),
  fTrackX(clusterInfo.fTrackX),
  fTrackY(clusterInfo.fTrackY),
  fTrackThetaX(clusterInfo.fTrackThetaX),
  fTrackThetaY(clusterInfo.fTrackThetaY),
  fTrackP(clusterInfo.fTrackP),
  fTrackXErr(clusterInfo.fTrackXErr),
  fTrackYErr(clusterInfo.fTrackYErr),
  fTrackChi2(clusterInfo.fTrackChi2),
  fTrackCharge(clusterInfo.fTrackCharge),
  fTrackNHits(clusterInfo.fTrackNHits),
  fTrackChamberHitMap(clusterInfo.fTrackChamberHitMap),
  fNPads(clusterInfo.fNPads),
  fPads(new TClonesArray("AliMUONPadInfo",clusterInfo.fNPads))
{
  /// Copy constructor
  AliMUONPadInfo *pad = (AliMUONPadInfo*) clusterInfo.fPads->First();
  while (pad) {
    new ((*fPads)[fPads->GetEntriesFast()]) AliMUONPadInfo(*pad);
    pad = (AliMUONPadInfo*) clusterInfo.fPads->After(pad);
  }
}

//_____________________________________________________________________________
AliMUONClusterInfo& AliMUONClusterInfo::operator=(const AliMUONClusterInfo& clusterInfo)
{
  /// Equal operator
  if (this == &clusterInfo) return *this;
  
  TObject::operator=(clusterInfo); // don't forget to invoke the base class' assignment operator
  
  fRunId = clusterInfo.fRunId;
  fEventId = clusterInfo.fEventId;
  fZ = clusterInfo.fZ;
  fClusterId = clusterInfo.fClusterId;
  fClusterX = clusterInfo.fClusterX;
  fClusterY = clusterInfo.fClusterY;
  fClusterXErr = clusterInfo.fClusterXErr;
  fClusterYErr = clusterInfo.fClusterYErr;
  fClusterChi2 = clusterInfo.fClusterChi2;
  fClusterCharge = clusterInfo.fClusterCharge;
  fTrackId = clusterInfo.fTrackId;
  fTrackX = clusterInfo.fTrackX;
  fTrackY = clusterInfo.fTrackY;
  fTrackThetaX = clusterInfo.fTrackThetaX;
  fTrackThetaY = clusterInfo.fTrackThetaY;
  fTrackP = clusterInfo.fTrackP;
  fTrackXErr = clusterInfo.fTrackXErr;
  fTrackYErr = clusterInfo.fTrackYErr;
  fTrackChi2 = clusterInfo.fTrackChi2;
  fTrackCharge = clusterInfo.fTrackCharge;
  fTrackNHits = clusterInfo.fTrackNHits;
  fTrackChamberHitMap = clusterInfo.fTrackChamberHitMap;
  fNPads = clusterInfo.fNPads;
  
  fPads->Clear("C");
  AliMUONPadInfo *pad = (AliMUONPadInfo*) clusterInfo.fPads->First();
  while (pad) {
    new ((*fPads)[fPads->GetEntriesFast()]) AliMUONPadInfo(*pad);
    pad = (AliMUONPadInfo*) clusterInfo.fPads->After(pad);
  }
  
  return *this;
}

//__________________________________________________________________________
AliMUONClusterInfo::~AliMUONClusterInfo()
{
  /// Destructor
  delete fPads;
}

//__________________________________________________________________________
void AliMUONClusterInfo::Clear(Option_t* opt)
{
  /// Clear arrays
  fPads->Clear(opt);
  fNPads = 0;
}

//_____________________________________________________________________________
void AliMUONClusterInfo::Print(Option_t* option) const
{
  /// print cluster info content
  /// print also pad info if option=FULL
  
  // global info
  cout<<Form("eventID=%d", GetEventId())<<endl;
  
  // cluster info
  cout<<Form("- clusterID=%u (ch=%d, det=%d, index=%d)",
	     GetClusterId(), GetChamberId(), GetDetElemId(), GetClusterIndex())<<endl;
  
  cout<<Form("    position=(%5.2f, %5.2f, %5.2f), sigma=(%8.5f, %8.5f, 0.0)",
	     GetClusterX(), GetClusterY(), GetZ(), GetClusterXErr(), GetClusterYErr())<<endl;
  
  cout<<Form("    charge=%5.2f, chi2=%5.2f", GetClusterCharge(), GetClusterChi2())<<endl;
  
  // track info
  cout<<Form("- trackID=%u", GetTrackId())<<endl;
  
  cout<<Form("    position=(%5.2f, %5.2f, %5.2f), angles=(%5.2f, %5.2f), momentum=%5.2f",
	     GetTrackX(), GetTrackY(), GetZ(), GetTrackThetaX(), GetTrackThetaY(), GetTrackP())<<endl;
  
  cout<<Form("    sigma_XY=(%8.5f, %8.5f), charge=%d, chi2=%5.2f",
	     GetTrackXErr(), GetTrackYErr(), GetTrackCharge(), GetTrackChi2())<<endl;
  
  // pad info
  if (strstr(option,"FULL")) {
    AliMUONPadInfo *pad = (AliMUONPadInfo*) fPads->First();
    while (pad) {
      pad->Print("FULL");
      pad = (AliMUONPadInfo*) fPads->After(pad);
    }
  }
  
}

Double_t AliMUONClusterInfo::GetClusterCharge(Int_t iPlaneType) const
{
  Double_t lClusterChargeC = 0.;
  if (!fPads) {
    lClusterChargeC = GetClusterCharge()/2.;
  }
  else {
    AliMUONPadInfo *pad = (AliMUONPadInfo*) fPads->First();
    while (pad) {
      if (pad->GetPadPlaneType()==iPlaneType) lClusterChargeC += pad->GetPadCharge();
      pad = (AliMUONPadInfo*) fPads->After(pad);
    }    
  }
  return lClusterChargeC;
}

Int_t AliMUONClusterInfo::GetNPads(Int_t iPlaneType) const
{
  Int_t iNPads = 0;

  if (!fPads) {
    iNPads = GetNPads();
  }
  else {
    AliMUONPadInfo *pad = (AliMUONPadInfo*) fPads->First();
    while (pad) {
      if (pad->GetPadPlaneType()==iPlaneType) {
	iNPads++;
      }
      pad = (AliMUONPadInfo*) fPads->After(pad);
    }   
  }
  return iNPads;
}

Int_t AliMUONClusterInfo::GetNPadsX(Int_t iPlaneType) const
{
  Int_t iNPadsX = 0;
  Double_t lPadXMin = 10000.;
  Double_t lPadXMax = -10000.;
  Int_t nChangedMin = 0;
  Int_t nChangedMax = 0;

  if (!fPads) {
    iNPadsX = GetNPads();
  }
  else {
    AliMUONPadInfo *pad = (AliMUONPadInfo*) fPads->First();
    while (pad) {
      if (pad->GetPadPlaneType()==iPlaneType) {
	if (pad->GetPadX()<lPadXMin){
	  lPadXMin = pad->GetPadX();
	  nChangedMin++;
	}
	if (pad->GetPadX()>lPadXMax){
	  lPadXMax = pad->GetPadX();
	  nChangedMax++;
	}  
      }    
      pad = (AliMUONPadInfo*) fPads->After(pad);
    }    
    iNPadsX = TMath::Max(nChangedMin+nChangedMax-1,0);
  }
  return iNPadsX;
}

Int_t AliMUONClusterInfo::GetNPadsY(Int_t iPlaneType) const
{
  Int_t iNPadsY = 0;
  Double_t lPadYMin = 10000.;
  Double_t lPadYMax = -10000.;
  Int_t nChangedMin = 0;
  Int_t nChangedMax = 0;

  if (!fPads) {
    iNPadsY = GetNPads();
  }
  else {
    AliMUONPadInfo *pad = (AliMUONPadInfo*) fPads->First();
    while (pad) {
      if (pad->GetPadPlaneType()==iPlaneType) {
	if (pad->GetPadY()<lPadYMin){
	  lPadYMin = pad->GetPadY();
	  nChangedMin++;
	}
	if (pad->GetPadY()>lPadYMax){
	  lPadYMax = pad->GetPadY();
	  nChangedMax++;
	}  
      }    
      pad = (AliMUONPadInfo*) fPads->After(pad);
    }    
    iNPadsY = TMath::Max(nChangedMin+nChangedMax-1,0);
  }
  return iNPadsY;
}
Commit	Line	Data
	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	// $Id$
	17
	18	//-----------------------------------------------------------------------------
	19	/// \class AliMUONClusterInfo
	20	///
	21	/// Class to summarize ESD data at cluster
	22	///
	23	/// \author Philippe Pillot, Subatech
	24	//-----------------------------------------------------------------------------
	25
	26	#include "AliMUONClusterInfo.h"
	27
	28	#include "AliLog.h"
	29
	30	#include <Riostream.h>
	31
	32	/// \cond CLASSIMP
	33	ClassImp(AliMUONClusterInfo)
	34	/// \endcond
	35
	36	//_____________________________________________________________________________
	37	AliMUONClusterInfo::AliMUONClusterInfo()
	38	: TObject(),
	39	fRunId(0),
	40	fEventId(0),
	41	fZ(0.),
	42	fClusterId(0),
	43	fClusterX(0.),
	44	fClusterY(0.),
	45	fClusterXErr(0.),
	46	fClusterYErr(0.),
	47	fClusterChi2(0.),
	48	fClusterCharge(0.),
	49	fTrackId(0),
	50	fTrackX(0.),
	51	fTrackY(0.),
	52	fTrackThetaX(0.),
	53	fTrackThetaY(0.),
	54	fTrackP(0.),
	55	fTrackXErr(0.),
	56	fTrackYErr(0.),
	57	fTrackChi2(0.),
	58	fTrackCharge(0),
	59	fTrackNHits(0),
	60	fTrackChamberHitMap(0),
	61	fNPads(0),
	62	fPads(new TClonesArray("AliMUONPadInfo",10))
	63	{
	64	/// default constructor
	65	}
	66
	67	//_____________________________________________________________________________
	68	AliMUONClusterInfo::AliMUONClusterInfo (const AliMUONClusterInfo& clusterInfo)
	69	: TObject(clusterInfo),
	70	fRunId(clusterInfo.fRunId),
	71	fEventId(clusterInfo.fEventId),
	72	fZ(clusterInfo.fZ),
	73	fClusterId(clusterInfo.fClusterId),
	74	fClusterX(clusterInfo.fClusterX),
	75	fClusterY(clusterInfo.fClusterY),
	76	fClusterXErr(clusterInfo.fClusterXErr),
	77	fClusterYErr(clusterInfo.fClusterYErr),
	78	fClusterChi2(clusterInfo.fClusterChi2),
	79	fClusterCharge(clusterInfo.fClusterCharge),
	80	fTrackId(clusterInfo.fTrackId),
	81	fTrackX(clusterInfo.fTrackX),
	82	fTrackY(clusterInfo.fTrackY),
	83	fTrackThetaX(clusterInfo.fTrackThetaX),
	84	fTrackThetaY(clusterInfo.fTrackThetaY),
	85	fTrackP(clusterInfo.fTrackP),
	86	fTrackXErr(clusterInfo.fTrackXErr),
	87	fTrackYErr(clusterInfo.fTrackYErr),
	88	fTrackChi2(clusterInfo.fTrackChi2),
	89	fTrackCharge(clusterInfo.fTrackCharge),
	90	fTrackNHits(clusterInfo.fTrackNHits),
	91	fTrackChamberHitMap(clusterInfo.fTrackChamberHitMap),
	92	fNPads(clusterInfo.fNPads),
	93	fPads(new TClonesArray("AliMUONPadInfo",clusterInfo.fNPads))
	94	{
	95	/// Copy constructor
	96	AliMUONPadInfo pad = (AliMUONPadInfo) clusterInfo.fPads->First();
	97	while (pad) {
	98	new ((fPads)[fPads->GetEntriesFast()]) AliMUONPadInfo(pad);
	99	pad = (AliMUONPadInfo*) clusterInfo.fPads->After(pad);
	100	}
	101	}
	102
	103	//_____________________________________________________________________________
	104	AliMUONClusterInfo& AliMUONClusterInfo::operator=(const AliMUONClusterInfo& clusterInfo)
	105	{
	106	/// Equal operator
	107	if (this == &clusterInfo) return *this;
	108
	109	TObject::operator=(clusterInfo); // don't forget to invoke the base class' assignment operator
	110
	111	fRunId = clusterInfo.fRunId;
	112	fEventId = clusterInfo.fEventId;
	113	fZ = clusterInfo.fZ;
	114	fClusterId = clusterInfo.fClusterId;
	115	fClusterX = clusterInfo.fClusterX;
	116	fClusterY = clusterInfo.fClusterY;
	117	fClusterXErr = clusterInfo.fClusterXErr;
	118	fClusterYErr = clusterInfo.fClusterYErr;
	119	fClusterChi2 = clusterInfo.fClusterChi2;
	120	fClusterCharge = clusterInfo.fClusterCharge;
	121	fTrackId = clusterInfo.fTrackId;
	122	fTrackX = clusterInfo.fTrackX;
	123	fTrackY = clusterInfo.fTrackY;
	124	fTrackThetaX = clusterInfo.fTrackThetaX;
	125	fTrackThetaY = clusterInfo.fTrackThetaY;
	126	fTrackP = clusterInfo.fTrackP;
	127	fTrackXErr = clusterInfo.fTrackXErr;
	128	fTrackYErr = clusterInfo.fTrackYErr;
	129	fTrackChi2 = clusterInfo.fTrackChi2;
	130	fTrackCharge = clusterInfo.fTrackCharge;
	131	fTrackNHits = clusterInfo.fTrackNHits;
	132	fTrackChamberHitMap = clusterInfo.fTrackChamberHitMap;
	133	fNPads = clusterInfo.fNPads;
	134
	135	fPads->Clear("C");
	136	AliMUONPadInfo pad = (AliMUONPadInfo) clusterInfo.fPads->First();
	137	while (pad) {
	138	new ((fPads)[fPads->GetEntriesFast()]) AliMUONPadInfo(pad);
	139	pad = (AliMUONPadInfo*) clusterInfo.fPads->After(pad);
	140	}
	141
	142	return *this;
	143	}
	144
	145	//__________________________________________________________________________
	146	AliMUONClusterInfo::~AliMUONClusterInfo()
	147	{
	148	/// Destructor
	149	delete fPads;
	150	}
	151
	152	//__________________________________________________________________________
	153	void AliMUONClusterInfo::Clear(Option_t* opt)
	154	{
	155	/// Clear arrays
	156	fPads->Clear(opt);
	157	fNPads = 0;
	158	}
	159
	160	//_____________________________________________________________________________
	161	void AliMUONClusterInfo::Print(Option_t* option) const
	162	{
	163	/// print cluster info content
	164	/// print also pad info if option=FULL
	165
	166	// global info
	167	cout<<Form("eventID=%d", GetEventId())<<endl;
	168
	169	// cluster info
	170	cout<<Form("- clusterID=%u (ch=%d, det=%d, index=%d)",
	171	GetClusterId(), GetChamberId(), GetDetElemId(), GetClusterIndex())<<endl;
	172
	173	cout<<Form(" position=(%5.2f, %5.2f, %5.2f), sigma=(%8.5f, %8.5f, 0.0)",
	174	GetClusterX(), GetClusterY(), GetZ(), GetClusterXErr(), GetClusterYErr())<<endl;
	175
	176	cout<<Form(" charge=%5.2f, chi2=%5.2f", GetClusterCharge(), GetClusterChi2())<<endl;
	177
	178	// track info
	179	cout<<Form("- trackID=%u", GetTrackId())<<endl;
	180
	181	cout<<Form(" position=(%5.2f, %5.2f, %5.2f), angles=(%5.2f, %5.2f), momentum=%5.2f",
	182	GetTrackX(), GetTrackY(), GetZ(), GetTrackThetaX(), GetTrackThetaY(), GetTrackP())<<endl;
	183
	184	cout<<Form(" sigma_XY=(%8.5f, %8.5f), charge=%d, chi2=%5.2f",
	185	GetTrackXErr(), GetTrackYErr(), GetTrackCharge(), GetTrackChi2())<<endl;
	186
	187	// pad info
	188	if (strstr(option,"FULL")) {
	189	AliMUONPadInfo pad = (AliMUONPadInfo) fPads->First();
	190	while (pad) {
	191	pad->Print("FULL");
	192	pad = (AliMUONPadInfo*) fPads->After(pad);
	193	}
	194	}
	195
	196	}
	197
	198	Double_t AliMUONClusterInfo::GetClusterCharge(Int_t iPlaneType) const
	199	{
	200	Double_t lClusterChargeC = 0.;
	201	if (!fPads) {
	202	lClusterChargeC = GetClusterCharge()/2.;
	203	}
	204	else {
	205	AliMUONPadInfo pad = (AliMUONPadInfo) fPads->First();
	206	while (pad) {
	207	if (pad->GetPadPlaneType()==iPlaneType) lClusterChargeC += pad->GetPadCharge();
	208	pad = (AliMUONPadInfo*) fPads->After(pad);
	209	}
	210	}
	211	return lClusterChargeC;
	212	}
	213
	214	Int_t AliMUONClusterInfo::GetNPads(Int_t iPlaneType) const
	215	{
	216	Int_t iNPads = 0;
	217
	218	if (!fPads) {
	219	iNPads = GetNPads();
	220	}
	221	else {
	222	AliMUONPadInfo pad = (AliMUONPadInfo) fPads->First();
	223	while (pad) {
	224	if (pad->GetPadPlaneType()==iPlaneType) {
	225	iNPads++;
	226	}
	227	pad = (AliMUONPadInfo*) fPads->After(pad);
	228	}
	229	}
	230	return iNPads;
	231	}
	232
	233	Int_t AliMUONClusterInfo::GetNPadsX(Int_t iPlaneType) const
	234	{
	235	Int_t iNPadsX = 0;
	236	Double_t lPadXMin = 10000.;
	237	Double_t lPadXMax = -10000.;
	238	Int_t nChangedMin = 0;
	239	Int_t nChangedMax = 0;
	240
	241	if (!fPads) {
	242	iNPadsX = GetNPads();
	243	}
	244	else {
	245	AliMUONPadInfo pad = (AliMUONPadInfo) fPads->First();
	246	while (pad) {
	247	if (pad->GetPadPlaneType()==iPlaneType) {
	248	if (pad->GetPadX()<lPadXMin){
	249	lPadXMin = pad->GetPadX();
	250	nChangedMin++;
	251	}
	252	if (pad->GetPadX()>lPadXMax){
	253	lPadXMax = pad->GetPadX();
	254	nChangedMax++;
	255	}
	256	}
	257	pad = (AliMUONPadInfo*) fPads->After(pad);
	258	}
	259	iNPadsX = TMath::Max(nChangedMin+nChangedMax-1,0);
	260	}
	261	return iNPadsX;
	262	}
	263
	264	Int_t AliMUONClusterInfo::GetNPadsY(Int_t iPlaneType) const
	265	{
	266	Int_t iNPadsY = 0;
	267	Double_t lPadYMin = 10000.;
	268	Double_t lPadYMax = -10000.;
	269	Int_t nChangedMin = 0;
	270	Int_t nChangedMax = 0;
	271
	272	if (!fPads) {
	273	iNPadsY = GetNPads();
	274	}
	275	else {
	276	AliMUONPadInfo pad = (AliMUONPadInfo) fPads->First();
	277	while (pad) {
	278	if (pad->GetPadPlaneType()==iPlaneType) {
	279	if (pad->GetPadY()<lPadYMin){
	280	lPadYMin = pad->GetPadY();
	281	nChangedMin++;
	282	}
	283	if (pad->GetPadY()>lPadYMax){
	284	lPadYMax = pad->GetPadY();
	285	nChangedMax++;
	286	}
	287	}
	288	pad = (AliMUONPadInfo*) fPads->After(pad);
	289	}
	290	iNPadsY = TMath::Max(nChangedMin+nChangedMax-1,0);
	291	}
	292	return iNPadsY;
	293	}
	294