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

#include <Riostream.h> 
#include <TMath.h>
#include <TRandom.h>

#include "AliRICHParam.h"

ClassImp(AliRICHParam)

// RICH main parameters manipulator
//__________________________________________________________________________________________________
AliRICHParam::AliRICHParam():
fCurrentPadX(0),fCurrentPadY(0),fCurrentWire(0),
fSizeZ(0),
fAngleRot(0),fAngleYZ(0),fAngleXY(0),
fOffset(0),
fProximityGapThickness(0),
fQuartzLength(0),
fQuartzWidth(0),
fOuterFreonLength(0),
fOuterFreonWidth(0),
fInnerFreonLength(0),
fInnerFreonWidth(0),
fChargeSlope(0),
fChargeSpreadX(0),
fChargeSpreadY(0),
fSigmaIntegration(0),
fAlphaFeedback(0),
fEIonisation(0),
fMaxAdc(0),
fWireSag(0),
fVoltage(0)
{//defines the default parameters
  Size                 (132.6*kcm,26*kcm,136.7*kcm);  //full length, not GEANT half notation
  AngleRot             (-60);                         //rotation of the whole RICH around Z, deg
  Angles               (20,19.5);                     //XY angle, YZ angle  deg  
  Offset               (490*kcm+1.267*kcm);           //1.267???????cm distance from IP to the center of module 
  ProximityGapThickness(0.4*kcm);            
  QuartzLength         (133*kcm);            
  QuartzWidth          (127.9*kcm);          
  OuterFreonLength     (133*kcm);            
  OuterFreonWidth      (41.3*kcm);           
  InnerFreonLength     (133*kcm);            
  InnerFreonWidth      (41.3*kcm);           
  
  ChargeSlope(27.);
  ChargeSpreadX(0.18);ChargeSpreadY(0.18);
  SigmaIntegration(5.);
  MaxAdc(4096);
  AlphaFeedback(0.036);
  EIonisation(26.e-9);
  WireSag(1);		      // 1->On, 0->Off
  Voltage(2150);	      // Should only be 2000, 2050, 2100 or 2150  
}//AliRICHParam::named ctor 
//__________________________________________________________________________________________________
Int_t AliRICHParam::Local2Sector(Float_t &x, Float_t &y)
{//Determines sector for a given hit (x,y) and trasform this point to the local system of that sector.
  Int_t sector=kBad;  
  Float_t x1=-0.5*PcSizeX();      Float_t x2=-0.5*SectorSizeX()-DeadZone();  Float_t x3=-0.5*SectorSizeX();
  Float_t x4= 0.5*SectorSizeX();  Float_t x5= 0.5*SectorSizeX()+DeadZone();  Float_t x6= 0.5*PcSizeX();

  if     (x>=x1&&x<=x2)    {sector=1;x+=0.5*PcSizeX();}
  else if(x>=x3&&x<=x4)    {sector=2;x+=0.5*SectorSizeX();}
  else if(x>=x5&&x<=x6)    {sector=3;x-=0.5*SectorSizeX()+DeadZone();}
  else if(x< x1||x> x6)    {return kBad;}
  else                                                        {return kBad;} //in dead zone

  if     (y>=-0.5*PcSizeY()   &&y<=-0.5*DeadZone())  {y+=0.5*PcSizeY();  return -sector;}
  else if(y> -0.5*DeadZone()  &&y<  0.5*DeadZone())  {return kBad;} //in dead zone
  else if(y>= 0.5*DeadZone()  &&y<= 0.5*PcSizeY())   {y-=0.5*DeadZone(); return  sector;}
  else                                               {return kBad;}
}//Int_t AliRICHParam::Local2Sector(Float_t x, Float_t y)
//__________________________________________________________________________________________________
Int_t AliRICHParam::Pad2Sector(Int_t &padx, Int_t &pady)
{//Determines sector for a given pad (padx,pady) and trasform this point to the local system of that sector.
  Int_t sector=kBad;      
  if     (padx>=1            &&padx<=NpadsXsec())      {sector=1;}
  else if(padx> NpadsXsec()  &&padx<=NpadsXsec()*2)    {sector=2;padx-=NpadsXsec();}
  else if(padx> NpadsXsec()*2&&padx<=NpadsX())         {sector=3;padx-=NpadsXsec()*2;}
  else                                                 {return kBad;}

  if     (pady>=1         &&pady<= NpadsYsec())     {return -sector;}
  else if(pady>NpadsYsec()&&pady<= NpadsY())        {pady-=NpadsYsec();return sector;} 
  else                                              {return kBad;}
}//Local2Sector()
//__________________________________________________________________________________________________
Int_t AliRICHParam::Local2Pad(Float_t x, Float_t y, Int_t &padx, Int_t &pady)
{//returns pad numbers (iPadX,iPadY) for given point in local coordinates (x,y) 
 //count starts in lower left corner from 1,1 to 144,180
  
  padx=pady=kBad;
  Int_t sector=Local2Sector(x,y);
  if(sector==kBad) return sector;
  
  padx=Int_t(x/PadSizeX())+1; 
  if(padx>NpadsXsec())            padx= NpadsXsec();
  if(sector==2||sector==-2)       padx+=NpadsXsec();
  else if(sector==3||sector==-3)  padx+=NpadsXsec()*2;
  
  pady=Int_t(y/PadSizeY())+1;
  if(pady>NpadsYsec())            padx= NpadsYsec();
  if(sector>0)                    pady+=NpadsYsec();    

  return sector;
}//Local2Pad()
//__________________________________________________________________________________________________
void AliRICHParam::Pad2Local(Int_t padx,Int_t pady,Float_t &x,Float_t &y)
{
  Int_t sector=Pad2Sector(padx,pady);  
  if(sector>0)
    y=0.5*DeadZone()+pady*PadSizeY()-0.5*PadSizeY();
  else{
    sector=-sector;
    y=-0.5*PcSizeY()+pady*PadSizeY()-0.5*PadSizeY();
  }
  if(sector==1)
    x=-0.5*PcSizeX()+padx*PadSizeX()-0.5*PadSizeX();
  else if(sector==2)
    x=-0.5*SectorSizeX()+padx*PadSizeX()-0.5*PadSizeX();
  else
    x= 0.5*SectorSizeX()+DeadZone()+padx*PadSizeX()-0.5*PadSizeX();
  return;
}//Pad2Local()
//__________________________________________________________________________________________________
Float_t AliRICHParam::Gain(Float_t y)
{//Calculates the gain
  if(fWireSag){
    Float_t gainK=9e-6*TMath::Power(y,4)+2e-7*TMath::Power(y,3)-0.0316*TMath::Power(y,2)-3e-4*y+25.367;
    Float_t gain = (ChargeSlope()+ChargeSlope()*gainK/100)*0.9;
    return -gain*TMath::Log(gRandom->Rndm());
  }else     
    return -ChargeSlope()*TMath::Log(gRandom->Rndm());
}//Float_t AliRICHParam::IntPH(Float_t yhit)
//__________________________________________________________________________________________________
Float_t AliRICHParam::TotalCharge(Int_t iPID,Float_t eloss,Float_t y)
{//Get number of electrons and return charge
    
  if(iPID>50000)//it's photon no more then 1 electron after photoelectron conversion
    return Gain(y);
  else{  
    Int_t iNelectrons=Int_t(eloss/fEIonisation);if(iNelectrons==0) iNelectrons=1;
    Float_t charge=0;
    for(Int_t i=1;i<=iNelectrons;i++)
      charge+=Gain(y);
    return charge;
  }
}//Float_t AliRICHParam::TotalCharge(Int_t iPID,Float_t eloss, Float_t y)
//__________________________________________________________________________________________________
void AliRICHParam::FirstPad(Float_t x,Float_t y)
{
  Int_t padx,pady;
  Local2Pad(x,y,padx,pady);
}//void AliRICHParam::FirstPad(Float_t x,Float_t y)
//__________________________________________________________________________________________________
Float_t AliRICHParam::AssignChargeToPad(Float_t hitx,Float_t hity,Int_t padx,Int_t pady)
{//
  Float_t padXcenter=0,padYcenter=0;
  Pad2Local(padx,pady,padXcenter,padYcenter);
  
  Float_t xi1=hitx-padXcenter-PadSizeX()/2;
  Float_t xi2=hitx-padXcenter+PadSizeX()/2; 
  Float_t yi1=hity-padYcenter-PadSizeY()/2;
  Float_t yi2=hity-padYcenter+PadSizeY()/2;
  xi1/=AnodeCathodeGap();
  xi2/=AnodeCathodeGap();
  yi1/=AnodeCathodeGap();
  yi2/=AnodeCathodeGap();
// The Mathieson function 
  Double_t ux1=SqrtKx3()*TMath::TanH(Kx2()*xi1);
  Double_t ux2=SqrtKx3()*TMath::TanH(Kx2()*xi2);    
  Double_t uy1=SqrtKy3()*TMath::TanH(Ky2()*yi1);
  Double_t uy2=SqrtKy3()*TMath::TanH(Ky2()*yi2);
  return 4.*Kx4()*(TMath::ATan(ux2)-TMath::ATan(ux1))*Ky4()*(TMath::ATan(uy2)-TMath::ATan(uy1));
}//AssignChargeToPad()
//__________________________________________________________________________________________________
Commit	Line	Data
56148d0e	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	#include <Riostream.h>
c2c6679b	17	#include <TMath.h>
c2c6679b	18	#include <TRandom.h>
56148d0e	19
	20	#include "AliRICHParam.h"
	21
d48cca74	22	ClassImp(AliRICHParam)
d48cca74	23
d48cca74	24	// RICH main parameters manipulator
c2c6679b	25	//__________________________________________________________________________________________________
a277aaca	26	AliRICHParam::AliRICHParam():
c60862bf	27	fCurrentPadX(0),fCurrentPadY(0),fCurrentWire(0),
a277aaca	28	fSizeZ(0),
c60862bf	29	fAngleRot(0),fAngleYZ(0),fAngleXY(0),
a277aaca	30	fOffset(0),
a277aaca	31	fProximityGapThickness(0),
	32	fQuartzLength(0),
	33	fQuartzWidth(0),
a277aaca	34	fOuterFreonLength(0),
	35	fOuterFreonWidth(0),
	36	fInnerFreonLength(0),
	37	fInnerFreonWidth(0),
a277aaca	38	fChargeSlope(0),
	39	fChargeSpreadX(0),
	40	fChargeSpreadY(0),
	41	fSigmaIntegration(0),
	42	fAlphaFeedback(0),
	43	fEIonisation(0),
	44	fMaxAdc(0),
a277aaca	45	fWireSag(0),
a277aaca	46	fVoltage(0)
d48cca74	47	{//defines the default parameters
a277aaca	48	Size (132.6kcm,26kcm,136.7*kcm); //full length, not GEANT half notation
e62e4625	49	AngleRot (-60); //rotation of the whole RICH around Z, deg
	50	Angles (20,19.5); //XY angle, YZ angle deg
	51	Offset (490kcm+1.267kcm); //1.267???????cm distance from IP to the center of module
a277aaca	52	ProximityGapThickness(0.4*kcm);
	53	QuartzLength (133*kcm);
	54	QuartzWidth (127.9*kcm);
a277aaca	55	OuterFreonLength (133*kcm);
	56	OuterFreonWidth (41.3*kcm);
	57	InnerFreonLength (133*kcm);
	58	InnerFreonWidth (41.3*kcm);
d48cca74	59
d48cca74	60	ChargeSlope(27.);
d48cca74	61	ChargeSpreadX(0.18);ChargeSpreadY(0.18);
853634d3	62	SigmaIntegration(5.);
d48cca74	63	MaxAdc(4096);
	64	AlphaFeedback(0.036);
	65	EIonisation(26.e-9);
d48cca74	66	WireSag(1); // 1->On, 0->Off
d48cca74	67	Voltage(2150); // Should only be 2000, 2050, 2100 or 2150
d48cca74	68	}//AliRICHParam::named ctor
c2c6679b	69	//__________________________________________________________________________________________________
6ce834b4	70	Int_t AliRICHParam::Local2Sector(Float_t &x, Float_t &y)
c60862bf	71	{//Determines sector for a given hit (x,y) and trasform this point to the local system of that sector.
c2c6679b	72	Int_t sector=kBad;
543d5224	73	Float_t x1=-0.5PcSizeX(); Float_t x2=-0.5SectorSizeX()-DeadZone(); Float_t x3=-0.5*SectorSizeX();
	74	Float_t x4= 0.5SectorSizeX(); Float_t x5= 0.5SectorSizeX()+DeadZone(); Float_t x6= 0.5*PcSizeX();
	75
	76	if (x>=x1&&x<=x2) {sector=1;x+=0.5*PcSizeX();}
	77	else if(x>=x3&&x<=x4) {sector=2;x+=0.5*SectorSizeX();}
	78	else if(x>=x5&&x<=x6) {sector=3;x-=0.5*SectorSizeX()+DeadZone();}
6ce834b4	79	else if(x< x1\|\|x> x6) {return kBad;}
543d5224	80	else {return kBad;} //in dead zone
c60862bf	81
543d5224	82	if (y>=-0.5PcSizeY() &&y<=-0.5DeadZone()) {y+=0.5*PcSizeY(); return -sector;}
	83	else if(y> -0.5DeadZone() &&y< 0.5DeadZone()) {return kBad;} //in dead zone
	84	else if(y>= 0.5DeadZone() &&y<= 0.5PcSizeY()) {y-=0.5*DeadZone(); return sector;}
6ce834b4	85	else {return kBad;}
543d5224	86	}//Int_t AliRICHParam::Local2Sector(Float_t x, Float_t y)
c2c6679b	87	//__________________________________________________________________________________________________
6ce834b4	88	Int_t AliRICHParam::Pad2Sector(Int_t &padx, Int_t &pady)
543d5224	89	{//Determines sector for a given pad (padx,pady) and trasform this point to the local system of that sector.
	90	Int_t sector=kBad;
	91	if (padx>=1 &&padx<=NpadsXsec()) {sector=1;}
	92	else if(padx> NpadsXsec() &&padx<=NpadsXsec()*2) {sector=2;padx-=NpadsXsec();}
	93	else if(padx> NpadsXsec()2&&padx<=NpadsX()) {sector=3;padx-=NpadsXsec()2;}
6ce834b4	94	else {return kBad;}
543d5224	95
	96	if (pady>=1 &&pady<= NpadsYsec()) {return -sector;}
	97	else if(pady>NpadsYsec()&&pady<= NpadsY()) {pady-=NpadsYsec();return sector;}
6ce834b4	98	else {return kBad;}
543d5224	99	}//Local2Sector()
543d5224	100	//__________________________________________________________________________________________________
6ce834b4	101	Int_t AliRICHParam::Local2Pad(Float_t x, Float_t y, Int_t &padx, Int_t &pady)
c60862bf	102	{//returns pad numbers (iPadX,iPadY) for given point in local coordinates (x,y)
	103	//count starts in lower left corner from 1,1 to 144,180
	104
	105	padx=pady=kBad;
543d5224	106	Int_t sector=Local2Sector(x,y);
c60862bf	107	if(sector==kBad) return sector;
c60862bf	108
543d5224	109	padx=Int_t(x/PadSizeX())+1;
	110	if(padx>NpadsXsec()) padx= NpadsXsec();
	111	if(sector==2\|\|sector==-2) padx+=NpadsXsec();
	112	else if(sector==3\|\|sector==-3) padx+=NpadsXsec()*2;
c60862bf	113
543d5224	114	pady=Int_t(y/PadSizeY())+1;
	115	if(pady>NpadsYsec()) padx= NpadsYsec();
	116	if(sector>0) pady+=NpadsYsec();
c2c6679b	117
c2c6679b	118	return sector;
543d5224	119	}//Local2Pad()
	120	//__________________________________________________________________________________________________
	121	void AliRICHParam::Pad2Local(Int_t padx,Int_t pady,Float_t &x,Float_t &y)
	122	{
	123	Int_t sector=Pad2Sector(padx,pady);
	124	if(sector>0)
	125	y=0.5DeadZone()+padyPadSizeY()-0.5*PadSizeY();
	126	else{
	127	sector=-sector;
	128	y=-0.5PcSizeY()+padyPadSizeY()-0.5*PadSizeY();
	129	}
	130	if(sector==1)
	131	x=-0.5PcSizeX()+padxPadSizeX()-0.5*PadSizeX();
	132	else if(sector==2)
	133	x=-0.5SectorSizeX()+padxPadSizeX()-0.5*PadSizeX();
	134	else
	135	x= 0.5SectorSizeX()+DeadZone()+padxPadSizeX()-0.5*PadSizeX();
	136	return;
	137	}//Pad2Local()
c2c6679b	138	//__________________________________________________________________________________________________
	139	Float_t AliRICHParam::Gain(Float_t y)
	140	{//Calculates the gain
	141	if(fWireSag){
	142	Float_t gainK=9e-6TMath::Power(y,4)+2e-7TMath::Power(y,3)-0.0316TMath::Power(y,2)-3e-4y+25.367;
	143	Float_t gain = (ChargeSlope()+ChargeSlope()gainK/100)0.9;
	144	return -gain*TMath::Log(gRandom->Rndm());
	145	}else
	146	return -ChargeSlope()*TMath::Log(gRandom->Rndm());
	147	}//Float_t AliRICHParam::IntPH(Float_t yhit)
	148	//__________________________________________________________________________________________________
	149	Float_t AliRICHParam::TotalCharge(Int_t iPID,Float_t eloss,Float_t y)
	150	{//Get number of electrons and return charge
	151
c60862bf	152	if(iPID>50000)//it's photon no more then 1 electron after photoelectron conversion
c2c6679b	153	return Gain(y);
	154	else{
	155	Int_t iNelectrons=Int_t(eloss/fEIonisation);if(iNelectrons==0) iNelectrons=1;
	156	Float_t charge=0;
	157	for(Int_t i=1;i<=iNelectrons;i++)
c60862bf	158	charge+=Gain(y);
c2c6679b	159	return charge;
	160	}
	161	}//Float_t AliRICHParam::TotalCharge(Int_t iPID,Float_t eloss, Float_t y)
	162	//__________________________________________________________________________________________________
c60862bf	163	void AliRICHParam::FirstPad(Float_t x,Float_t y)
	164	{
	165	Int_t padx,pady;
543d5224	166	Local2Pad(x,y,padx,pady);
c60862bf	167	}//void AliRICHParam::FirstPad(Float_t x,Float_t y)
6ce834b4	168	//__________________________________________________________________________________________________
	169	Float_t AliRICHParam::AssignChargeToPad(Float_t hitx,Float_t hity,Int_t padx,Int_t pady)
	170	{//
	171	Float_t padXcenter=0,padYcenter=0;
	172	Pad2Local(padx,pady,padXcenter,padYcenter);
	173
	174	Float_t xi1=hitx-padXcenter-PadSizeX()/2;
	175	Float_t xi2=hitx-padXcenter+PadSizeX()/2;
	176	Float_t yi1=hity-padYcenter-PadSizeY()/2;
	177	Float_t yi2=hity-padYcenter+PadSizeY()/2;
	178	xi1/=AnodeCathodeGap();
	179	xi2/=AnodeCathodeGap();
	180	yi1/=AnodeCathodeGap();
	181	yi2/=AnodeCathodeGap();
	182	// The Mathieson function
	183	Double_t ux1=SqrtKx3()TMath::TanH(Kx2()xi1);
	184	Double_t ux2=SqrtKx3()TMath::TanH(Kx2()xi2);
	185	Double_t uy1=SqrtKy3()TMath::TanH(Ky2()yi1);
	186	Double_t uy2=SqrtKy3()TMath::TanH(Ky2()yi2);
	187	return 4.Kx4()(TMath::ATan(ux2)-TMath::ATan(ux1))Ky4()(TMath::ATan(uy2)-TMath::ATan(uy1));
	188	}//AssignChargeToPad()
	189	//__________________________________________________________________________________________________