[u/mrichter/AliRoot.git] / MUON / AliMUONClusterInput.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.9  2001/01/26 21:38:49  morsch
Use access functions to AliMUONDigit member data.

Revision 1.8  2001/01/23 18:58:19  hristov
Initialisation of some pointers

Revision 1.7  2000/12/21 22:14:38  morsch
Clean-up of coding rule violations.

Revision 1.6  2000/10/06 09:04:50  morsch

- Dummy z-arguments in GetPadI, SetHit, FirstPad replaced by real z-coordinate
        to make code work with slat chambers.

Revision 1.5  2000/10/02 16:58:29  egangler
Cleaning of the code :
-> coding conventions
-> void Streamers
-> some useless includes removed or replaced by "class" statement

Revision 1.4  2000/07/03 11:54:57  morsch
AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.

Revision 1.3  2000/06/28 15:16:35  morsch
(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
to allow development of slat-muon chamber simulation and reconstruction code in the MUON
framework. The changes should have no side effects (mostly dummy arguments).
(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
of chambers with overlapping modules (MakePadHits, Disintegration).

Revision 1.2  2000/06/28 12:19:18  morsch
More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
cluster and hit reconstruction algorithms in AliMUONClusterFinderVS.
AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
It requires two cathode planes. Small modifications in the code will make it usable for
one cathode plane and, hence, more general (for test beam data).
AliMUONClusterFinder is now obsolete.

Revision 1.1  2000/06/28 08:06:10  morsch
Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
It also naturally takes care of the TMinuit instance.

*/
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
#include "AliMUONClusterInput.h"
#include "AliSegmentation.h"
#include "AliMUONResponse.h"
#include "AliMUONRawCluster.h"
#include "AliMUONDigit.h"

#include <TClonesArray.h>
#include <TMinuit.h>

ClassImp(AliMUONClusterInput)

AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0; 
TMinuit* AliMUONClusterInput::fgMinuit = 0; 

AliMUONClusterInput::AliMUONClusterInput(){
  fgClusterInput = 0; 
  fgMinuit = 0; 
  fDigits[0]=0;
  fDigits[1]=0;
  fSegmentation[0]=0;
  fSegmentation[1]=0;
  fResponse=0;
  fCluster=0;
}

AliMUONClusterInput* AliMUONClusterInput::Instance()
{
// return pointer to the singleton instance
    if (fgClusterInput == 0) {
	fgClusterInput = new AliMUONClusterInput();
	fgMinuit = new TMinuit(8);
    }
    
    return fgClusterInput;
}

void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
{
// Set pointer to digits with corresponding segmentations and responses (two cathode planes)
    fChamber=chamber;
    fDigits[0]=dig1;
    fDigits[1]=dig2; 
    fNDigits[0]=dig1->GetEntriesFast();
    fNDigits[1]=dig2->GetEntriesFast();
    
    AliMUON *pMUON;
    AliMUONChamber* iChamber;

    pMUON = (AliMUON*) gAlice->GetModule("MUON");
    iChamber =  &(pMUON->Chamber(chamber));

    fSegmentation[0]=iChamber->SegmentationModel(1);
    fSegmentation[1]=iChamber->SegmentationModel(2);
    fResponse=iChamber->ResponseModel();
    fNseg = 2;
}

void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
{
// Set pointer to digits with corresponding segmentations and responses (one cathode plane)
    fDigits[0]=dig;
    AliMUON *pMUON;
    AliMUONChamber* iChamber;

    pMUON = (AliMUON*) gAlice->GetModule("MUON");
    iChamber =  &(pMUON->Chamber(chamber));

    fSegmentation[0]=iChamber->SegmentationModel(1);
    fResponse=iChamber->ResponseModel();
    fNseg=1;
}

void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
{
// Set the current cluster
    printf("\n %p \n", cluster);
    fCluster=cluster;
    Float_t qtot;
    Int_t   i, cath, ix, iy;
    AliMUONDigit* digit;
    fNmul[0]=cluster->fMultiplicity[0];
    fNmul[1]=cluster->fMultiplicity[1];
    printf("\n %p %p ", fDigits[0], fDigits[1]);
    
    for (cath=0; cath<2; cath++) {
	qtot=0;
	for (i=0; i<fNmul[cath]; i++) {
	    // pointer to digit
	    digit =(AliMUONDigit*)
		(fDigits[cath]->UncheckedAt(cluster->fIndexMap[i][cath]));
	    // pad coordinates
	    ix = digit->PadX();
	    iy = digit->PadY();
	    // pad charge
	    fCharge[i][cath] = digit->Signal();
	    // pad centre coordinates
//	    fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
            // globals kUsed in fitting functions
	    fix[i][cath]=ix;
	    fiy[i][cath]=iy;
	    // total charge per cluster
	    qtot+=fCharge[i][cath];
	    // Current z
	    Float_t xc, yc;
	    fSegmentation[cath]->GetPadC(ix,iy,xc,yc,fZ);
	} // loop over cluster digits
	fQtot[cath]=qtot;
	fChargeTot[cath]=Int_t(qtot);  
    }  // loop over cathodes
}


Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par) 
{
// Compute the charge on first cathod only.
return DiscrChargeCombiS1(i,par,0);
}

Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath) 
{
// par[0]    x-position of cluster
// par[1]    y-position of cluster

   fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
//  First Cluster
   fSegmentation[cath]->SetHit(par[0],par[1],fZ);
   Float_t q1=fResponse->IntXY(fSegmentation[cath]);
    
   Float_t value = fQtot[cath]*q1;
   return value;
}


Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par) 
{
// par[0]    x-position of first  cluster
// par[1]    y-position of first  cluster
// par[2]    x-position of second cluster
// par[3]    y-position of second cluster
// par[4]    charge fraction of first  cluster
// 1-par[4]  charge fraction of second cluster

   fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
//  First Cluster
   fSegmentation[0]->SetHit(par[0],par[1],fZ);
   Float_t q1=fResponse->IntXY(fSegmentation[0]);
    
//  Second Cluster
   fSegmentation[0]->SetHit(par[2],par[3],fZ);
   Float_t q2=fResponse->IntXY(fSegmentation[0]);
    
   Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
   return value;
}

Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath) 
{
// par[0]    x-position of first  cluster
// par[1]    y-position of first  cluster
// par[2]    x-position of second cluster
// par[3]    y-position of second cluster
// par[4]    charge fraction of first  cluster - first cathode
// 1-par[4]  charge fraction of second cluster 
// par[5]    charge fraction of first  cluster - second cathode

   fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
//  First Cluster
   fSegmentation[cath]->SetHit(par[0],par[1],fZ);
   Float_t q1=fResponse->IntXY(fSegmentation[cath]);
    
//  Second Cluster
   fSegmentation[cath]->SetHit(par[2],par[3],fZ);
   Float_t q2=fResponse->IntXY(fSegmentation[cath]);
   Float_t value;
   if (cath==0) {
       value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
   } else {
       value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
   }
   return value;
}

AliMUONClusterInput& AliMUONClusterInput
::operator = (const AliMUONClusterInput& rhs)
{
// Dummy assignment operator
    return *this;
}
Commit	Line	Data
9825400f	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	/*
	17	$Log$
a1b02be9	18	Revision 1.9 2001/01/26 21:38:49 morsch
	19	Use access functions to AliMUONDigit member data.
	20
08a636a8	21	Revision 1.8 2001/01/23 18:58:19 hristov
	22	Initialisation of some pointers
	23
3f5cf0b3	24	Revision 1.7 2000/12/21 22:14:38 morsch
	25	Clean-up of coding rule violations.
	26
6a9bc541	27	Revision 1.6 2000/10/06 09:04:50 morsch
	28
	29	- Dummy z-arguments in GetPadI, SetHit, FirstPad replaced by real z-coordinate
	30	to make code work with slat chambers.
	31
e357fc46	32	Revision 1.5 2000/10/02 16:58:29 egangler
	33	Cleaning of the code :
	34	-> coding conventions
	35	-> void Streamers
	36	-> some useless includes removed or replaced by "class" statement
	37
ecfa008b	38	Revision 1.4 2000/07/03 11:54:57 morsch
	39	AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
	40	The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
	41
a30a000f	42	Revision 1.3 2000/06/28 15:16:35 morsch
	43	(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
	44	to allow development of slat-muon chamber simulation and reconstruction code in the MUON
	45	framework. The changes should have no side effects (mostly dummy arguments).
	46	(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
	47	of chambers with overlapping modules (MakePadHits, Disintegration).
	48
802a864d	49	Revision 1.2 2000/06/28 12:19:18 morsch
	50	More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
	51	cluster and hit reconstruction algorithms in AliMUONClusterFinderVS.
	52	AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
	53	It requires two cathode planes. Small modifications in the code will make it usable for
	54	one cathode plane and, hence, more general (for test beam data).
	55	AliMUONClusterFinder is now obsolete.
	56
30aaba74	57	Revision 1.1 2000/06/28 08:06:10 morsch
	58	Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
	59	algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
	60	It also naturally takes care of the TMinuit instance.
	61
9825400f	62	*/
	63	#include "AliRun.h"
	64	#include "AliMUON.h"
	65	#include "AliMUONChamber.h"
	66	#include "AliMUONClusterInput.h"
a30a000f	67	#include "AliSegmentation.h"
9825400f	68	#include "AliMUONResponse.h"
	69	#include "AliMUONRawCluster.h"
	70	#include "AliMUONDigit.h"
	71
	72	#include <TClonesArray.h>
	73	#include <TMinuit.h>
	74
	75	ClassImp(AliMUONClusterInput)
	76
	77	AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
	78	TMinuit* AliMUONClusterInput::fgMinuit = 0;
	79
3f5cf0b3	80	AliMUONClusterInput::AliMUONClusterInput(){
	81	fgClusterInput = 0;
	82	fgMinuit = 0;
	83	fDigits[0]=0;
	84	fDigits[1]=0;
	85	fSegmentation[0]=0;
	86	fSegmentation[1]=0;
	87	fResponse=0;
	88	fCluster=0;
	89	}
	90
9825400f	91	AliMUONClusterInput* AliMUONClusterInput::Instance()
	92	{
	93	// return pointer to the singleton instance
	94	if (fgClusterInput == 0) {
	95	fgClusterInput = new AliMUONClusterInput();
e357fc46	96	fgMinuit = new TMinuit(8);
9825400f	97	}
	98
	99	return fgClusterInput;
	100	}
	101
	102	void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
	103	{
	104	// Set pointer to digits with corresponding segmentations and responses (two cathode planes)
30aaba74	105	fChamber=chamber;
9825400f	106	fDigits[0]=dig1;
9825400f	107	fDigits[1]=dig2;
30aaba74	108	fNDigits[0]=dig1->GetEntriesFast();
	109	fNDigits[1]=dig2->GetEntriesFast();
	110
9825400f	111	AliMUON *pMUON;
	112	AliMUONChamber* iChamber;
	113
	114	pMUON = (AliMUON*) gAlice->GetModule("MUON");
	115	iChamber = &(pMUON->Chamber(chamber));
	116
	117	fSegmentation[0]=iChamber->SegmentationModel(1);
	118	fSegmentation[1]=iChamber->SegmentationModel(2);
	119	fResponse=iChamber->ResponseModel();
	120	fNseg = 2;
	121	}
	122
	123	void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
	124	{
	125	// Set pointer to digits with corresponding segmentations and responses (one cathode plane)
	126	fDigits[0]=dig;
	127	AliMUON *pMUON;
	128	AliMUONChamber* iChamber;
	129
	130	pMUON = (AliMUON*) gAlice->GetModule("MUON");
	131	iChamber = &(pMUON->Chamber(chamber));
	132
	133	fSegmentation[0]=iChamber->SegmentationModel(1);
	134	fResponse=iChamber->ResponseModel();
	135	fNseg=1;
	136	}
	137
	138	void AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
	139	{
	140	// Set the current cluster
30aaba74	141	printf("\n %p \n", cluster);
9825400f	142	fCluster=cluster;
	143	Float_t qtot;
	144	Int_t i, cath, ix, iy;
	145	AliMUONDigit* digit;
	146	fNmul[0]=cluster->fMultiplicity[0];
	147	fNmul[1]=cluster->fMultiplicity[1];
	148	printf("\n %p %p ", fDigits[0], fDigits[1]);
	149
	150	for (cath=0; cath<2; cath++) {
	151	qtot=0;
	152	for (i=0; i<fNmul[cath]; i++) {
	153	// pointer to digit
	154	digit =(AliMUONDigit*)
	155	(fDigits[cath]->UncheckedAt(cluster->fIndexMap[i][cath]));
	156	// pad coordinates
08a636a8	157	ix = digit->PadX();
08a636a8	158	iy = digit->PadY();
9825400f	159	// pad charge
08a636a8	160	fCharge[i][cath] = digit->Signal();
9825400f	161	// pad centre coordinates
	162	// fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
	163	// globals kUsed in fitting functions
	164	fix[i][cath]=ix;
	165	fiy[i][cath]=iy;
	166	// total charge per cluster
	167	qtot+=fCharge[i][cath];
e357fc46	168	// Current z
	169	Float_t xc, yc;
	170	fSegmentation[cath]->GetPadC(ix,iy,xc,yc,fZ);
9825400f	171	} // loop over cluster digits
	172	fQtot[cath]=qtot;
	173	fChargeTot[cath]=Int_t(qtot);
	174	} // loop over cathodes
	175	}
	176
	177
	178
	179	Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
	180	{
a1b02be9	181	// Compute the charge on first cathod only.
a1b02be9	182	return DiscrChargeCombiS1(i,par,0);
9825400f	183	}
	184
	185	Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
	186	{
	187	// par[0] x-position of cluster
	188	// par[1] y-position of cluster
	189
	190	fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
	191	// First Cluster
e357fc46	192	fSegmentation[cath]->SetHit(par[0],par[1],fZ);
9825400f	193	Float_t q1=fResponse->IntXY(fSegmentation[cath]);
	194
	195	Float_t value = fQtot[cath]*q1;
	196	return value;
	197	}
	198
	199
	200	Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
	201	{
	202	// par[0] x-position of first cluster
	203	// par[1] y-position of first cluster
	204	// par[2] x-position of second cluster
	205	// par[3] y-position of second cluster
	206	// par[4] charge fraction of first cluster
	207	// 1-par[4] charge fraction of second cluster
	208
	209	fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
	210	// First Cluster
e357fc46	211	fSegmentation[0]->SetHit(par[0],par[1],fZ);
9825400f	212	Float_t q1=fResponse->IntXY(fSegmentation[0]);
	213
	214	// Second Cluster
e357fc46	215	fSegmentation[0]->SetHit(par[2],par[3],fZ);
9825400f	216	Float_t q2=fResponse->IntXY(fSegmentation[0]);
	217
	218	Float_t value = fQtot[0](par[4]q1+(1.-par[4])*q2);
	219	return value;
	220	}
	221
	222	Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
	223	{
	224	// par[0] x-position of first cluster
	225	// par[1] y-position of first cluster
	226	// par[2] x-position of second cluster
	227	// par[3] y-position of second cluster
a1b02be9	228	// par[4] charge fraction of first cluster - first cathode
	229	// 1-par[4] charge fraction of second cluster
	230	// par[5] charge fraction of first cluster - second cathode
9825400f	231
	232	fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
	233	// First Cluster
e357fc46	234	fSegmentation[cath]->SetHit(par[0],par[1],fZ);
9825400f	235	Float_t q1=fResponse->IntXY(fSegmentation[cath]);
	236
	237	// Second Cluster
e357fc46	238	fSegmentation[cath]->SetHit(par[2],par[3],fZ);
9825400f	239	Float_t q2=fResponse->IntXY(fSegmentation[cath]);
	240	Float_t value;
	241	if (cath==0) {
	242	value = fQtot[0](par[4]q1+(1.-par[4])*q2);
	243	} else {
	244	value = fQtot[1](par[5]q1+(1.-par[5])*q2);
	245	}
	246	return value;
	247	}
	248
6a9bc541	249	AliMUONClusterInput& AliMUONClusterInput
	250	::operator = (const AliMUONClusterInput& rhs)
	251	{
	252	// Dummy assignment operator
	253	return *this;
	254	}